feedBack/CHANGELOG.md

Changelog

All notable changes to this project will be documented in this file.

The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

[Unreleased]

Added

• chart-transform capability domain (#952) — plugins can now remap the chart before rendering and scoring through a core-owned provider coordinator. Synchronous transforms run after difficulty filtering; host data is isolated from providers, accepted timelines are time-sorted, and failures fall back to the original chart with a fixed public reason. Effective chart arrays and metadata are available to 2D/custom renderers and highway getters, while getSongInfo() retains the original metadata. Provider selection persists and applies to primary and splitscreen highways.
• Library filter: one-click "Not split" + a piano stem pill. The v3 Filters drawer's stems section gains a Not split shortcut that selects "lacks every instrument stem" in one tap — the same query Stem Splitter's missing-stems view runs — instead of cycling five pills to ✕ by hand. The pill row also gains piano (the drawer offered five of the canonical six stems, so a piano-only song wrongly matched a hand-built "lacks all" filter). "No lyrics" already existed in the Lyrics section.
• Gold tier (career passports) — an earned badge turns gold when Virtuoso verifies an improvised jam in the passport's style (the gold_improv artifact relays with the drill snapshot; a genre inherits its family's style, gained-only, and gold never substitutes for the badge bar itself). Gold gets its own ceremony, stamp slam, foil chip, and gold ink on the shelf cover, profile wall, and passport card; the bronze page's "Gold rung coming" preview becomes a live invitation to jam it.
• Gigs (the career verb, frontend) — book a gig from any opened passport: a gig poster proposes the setlist (re-roll for a different bill; save or copy the poster as a PNG), "Play the gig" hands the set to the play queue with the venue on stage, a floating strip tracks the set, and finishing it logs dated entries with per-song accuracies in the passport book — with an encore celebration (crowd eruption + confetti) when the whole set clears the bar, and a summary poster to share. Quitting mid-set simply abandons it: no log, no fail state.
• Career on the Profile and Home pages — the Profile gains a passport wall (earned-badge covers per instrument, hours, gig count; absent until a passport exists), injected through the same mount-point + rendered-event seam the achievements plugin uses (now documented in docs/plugin-v3-ui.md). The home page's plugin-count stat tile becomes a career trading card (badges, hours, the closest stamp ask, foil shine) with the old stat as the built-in fallback when career has no state. Earned passports gain Save card / Copy card — a natively-drawn PNG passport card, downloadable or copied straight to the clipboard for pasting outside the app (shared blob-io helpers replace the download idiom previously duplicated in settings-io and diagnostics-export).
• Gigs (backend) — career mode gains its verb: POST /api/plugins/career/gigs/propose builds a playable setlist for an instrument+genre (your qualifying songs plus a couple of stakes songs near the bar; a young passport fills from unplayed genre songs — the first gig is how stubs start; re-roll by calling again), naming the room your stars can book. POST /gigs logs a completed set — per-song accuracies read from the set's own freshly-recorded stats, an encore flag at the data-driven bar (avg ≥ 75%) — into the career state; abandoned sets never log (no fail state: the gig you finished is the gig you played). Passports carry their gig log; instruments their gig count.
• 3D Highway: fret wires flash on a confirmed hit — when a scorer (note_detect) confirms a note through the getNoteState provider (feedBack#254), the fret wires bracketing it light up. A fretted note lights the wire behind it and the wire it's pressed against; a chord lights only the outermost wires of its shape; an open string lights the anchor lane's edge wires (its gem is drawn as a slab spanning the lane, so those are the wires it sits between); a chord likewise lights the lane's edge wires — the lit lane strip can run a fret past the chord's outermost fret, and a bracket one wire inside the lit lane reads as misaligned (the shape's own outer pair survives only as the fallback on anchor-less charts). At most two wires are ever lit at once: when overlapping decay tails (fast passages) would light a run of wires, the flash collapses to the outermost pair of the lit span — one bracket, never a picket fence. The gem's rim joins in: on a confirmed hit the outline flashes in the string's own colour with the same intensity treatment as the wires, fading with the scorer's alpha. With no scorer attached, nothing changes.
• Background controls in the player (3D Highway) — change the highway background mid-song from the player's Plugin Controls popover instead of opening Settings: a style dropdown, a Reactive toggle, and an Intensity slider, all kept in sync with the Settings page. Controls that the active style ignores are greyed out with a reason on hover (Custom video and Butterchurn use neither; Custom image uses Intensity but not Reactive), so a knob is never present-but-inert. The control disappears when a non-3D renderer is selected.

Changed

• GET /api/song/{f}?stems=1 (new, opt-in) — returns the pack's playable stem list ([{id, url, default}] + full_mix_url), the same list the highway's WS ready sends. The stems plugin could only learn it from that WS message, which arrives once the highway is already on screen — so it decoded and then copied the whole song's PCM to its audio worklet with the player visible: over half a gigabyte of memcpy in one frame for a 6-stem pack, a measured 698 ms freeze right as the song-credits card appeared. With the list available at song:loading the plugin does all of it before the highway is drawn. Built by calling load_song itself, so it cannot drift from what the WS sends. Opt-in, so the library's metadata calls pay nothing.

• Folder library renders only the songs on screen (#965) — a song list used to render every song it held. On a flat 50,944-song library that was one <div> with 50,938 children and ~1.3 million DOM nodes (~4.2 GB of renderer memory), built even while another screen was showing. A document that size also punishes unrelated code: any document.querySelector that misses has to walk the whole tree — which is how the song-preview menu check ended up eating ~50% of the renderer and dropping the app to 2.7 fps. Lists longer than 200 songs are now windowed (25–31 rows in the DOM instead of 50,000); shorter lists are unchanged.

• 3D Highway: fret wires read as a focus cue — the contrast between the active anchor lane and the rest of the neck is widened (the lane's wires brighter, the rest dimmer), and the wires themselves are slightly thicker.

• The full mix is a stem (#933) — core no longer depends on original_audio:, a top-level manifest key this repo invented (#583) that the feedpak spec never had. The format already carried the pre-separation mixdown as a stem; feedpak 1.15.0 (feedpak-spec#53) reserves the id full for it, so that is where core reads it from now.

  full is a mixdown, not a layer — it already contains every instrument — so load_song() lifts it OUT of LoadedSloppak.stems onto LoadedSloppak.full_mix. Nothing that sums stems or renders one fader per stem can see it, which is what makes retaining it safe; leaving it in the list would double the whole song and leave "guitar" audible with the guitar fader muted. That trap is exactly why the packer invented the key instead of putting the mixdown where the format says it goes — the bug was in the reader, and this fixes the reader.

  Consequences worth knowing:

  • The highway WS song_info frame gains full_mix_url / has_full_mix. original_audio_url / has_original_audio remain as deprecated aliases (same values) for one release so a client built against the old frame keeps working; they go with the fallback below (#945).
  • stems on song_info, and stem_ids / stem_count in the library index, now describe instrument stems only — a separated pack that retains its mixdown no longer advertises a bogus "full" stem chip or an inflated stem count.
  • Audio fingerprinting (lib/enrichment.py) now resolves the mixdown the same way, which widens its coverage: it previously returned None for any pack without the invented key, so fingerprinting silently did nothing for the overwhelming majority of packs.
  • Core still reads original_audio: as a deprecated fallback, because every pack written before the spec caught up carries it and would otherwise lose its pristine mix. tools/migrate_full_mix_stem.py rewrites those packs into the spec shape (moves original/full.ogg → stems/full.ogg, adds the full stem at default: off, drops the key); the fallback and the aliases are removed once they are migrated (#945).

Added

• Genres fall back to MusicBrainz enrichment — the effective genre now resolves override → pack genre → the enrichment match's primary genre (matched or user-pinned manual rows only). Converted packs rarely carry a genres manifest key, which starved the library genre facet and career passports on real libraries; with the fallback, every enriched song's genre is browsable and passport-able immediately, and coverage grows as enrichment runs.
• Badge ceremony in the venue — earning a genre badge now stages a moment: the crowd layer erupts (new public v3VenueCrowd.celebrate() — instant ecstatic loop bypassing the stability/dwell hysteresis, plus a cheer stinger; a no-op without a venue pack) and a full-screen overlay drops the bronze stamp with a shine sweep and a confetti burst over whatever screen is active (badges land right after stats:recorded, while the player is still up). Click or wait ~4s to dismiss; prefers-reduced-motion gets the existing chime + notification only. The stamp still slams into the passport book on next open, unchanged.
• Hours-per-genre odometer (career passports) — the app now measures real play time: the stats recorder accrues wall-clock seconds across play/resume ↔ pause/stop/end spans (wall time, not song position — position deltas double-count A-B loops and mis-read seeks; single spans clamp at 2h against suspend/sleep inflation) and piggybacks them as seconds on the POST /api/stats calls it already makes. New additive song_stats.seconds_total column; a seconds-only POST banks time for unscored plays that run to the song's natural end without touching the resume position (and still counts as playing today for the streak). Passports surface it honestly: "14.2 h in Blues" under the badge and on the shelf cover — a true fact that only grows, never a target or a meter.
• Career passport drills, curated — Bronze in blues/rock/metal/funk/jazz now also asks for that genre's signature Virtuoso drill (Blues Shuffle, Power Chords & Backbeat, Gallop Picking, 16th Pocket, Shell Voicings — one per genre, data-driven in passports.json with display labels). Drill lists are per-instrument (virtuoso_nodes: {instrument: [nodes]}; a flat list still means guitar), so a keys passport never demands a guitar drill. A drill counts as cleared on the first real completion artifact — a top-tier clean pass in one key (keysCleared), any depth rung, or mastery — rather than only the maxed-speed depth flips. Genres without a curated drill stay songs-only.
• Career passport visuals pack — earned covers and badge stamps become trading cards (pointer-tracked tilt + light glint, hover-capable devices only); the ghost stamp visibly "carves in" as qualifying songs land (a conic ink fill, no numbers added); the Gold rung preview is a small foil chip with a shimmer sweep, still honestly labeled coming. All theatrics disabled under prefers-reduced-motion.
• Career passports (backend) — the badge-journey layer on top of career stars. New career-plugin endpoints: GET /api/plugins/career/passports (per-instrument passport walls: genre badges computed on read from song_stats × the library's effective genre — Bronze = N genre songs at K★, data-driven in plugins/career/passports.json, default 5 songs at 2★ — plus qualifying-song "ticket stubs", the library genre list, and drill status), POST /passports/commit (instrument commitment), POST /passports/open (open a genre passport), and POST /drill-state (intake for the relayed Virtuoso virtuoso.progress snapshot, so drill requirements can gate badges server-side). Badges are never stored; the only persisted state (commitments, opened passports, drill snapshot) lives under CONFIG_DIR/career/ and rides the settings export/import bundle via settings.server_files. Instruments are attributed via the existing progression arrangement→instrument mapping; non-graded instruments (bass, drums) render shown-not-judged — repertoire without a pass bar, never a false badge denial.
• Career passports (UI) — the Career screen gains a Passports tab beside Venues: a physical per-instrument passport book (embossed leather cover, 3D page-turn) with a wax-seal commitment ceremony (Stage 0), rubber-stamp badge slam with ink bleed and deterministic per-genre jitter, qualifying songs as collected ticket stubs, and unopened genres as an "Explore next" travel-brochure rack (invitations, never greyed-out slots or completion meters). Badge earns chime + notify immediately; the stamp slam plays when the passport is next opened. Four small synthesized sound effects ship as plugin assets. The career screen also relays the Virtuoso virtuoso.progress localStorage snapshot to the drill-state intake on virtuoso:progress bus events (debounced, plus a one-time bootstrap), closing the fires-into-a-void seam without touching the virtuoso plugin.
• CI gate: core must stay faithful to the feedpak spec (feedpak-spec job). feedpak is published as an open format with its own repo, normative spec, JSON Schemas, and reference validator — but nothing stopped core from reading a manifest key the spec never defined, which is exactly what happened with original_audio (#583 → #933). tools/check_spec_conformance.py now enforces four surface properties in CI: (1) key-coverage — every manifest key core reads or writes is declared in the spec's manifest.schema.json, found by walking the AST of lib/sloppak.py, lib/enrichment.py, and lib/songmeta.py, lib/gp2notation.py, and lib/routers/ws_highway.py (writes are gated too — including setdefault() — and reported separately: a key core writes lands in every pack we emit, so an undeclared one seeds the ecosystem with non-spec data; a readers-complete guard fails the build if that module list falls behind the codebase); (2) allowlist-closed — feedpak-spec-exceptions.yml never grows; (3) forward — core's load_song() ingests every example pack the spec ships; (4) reverse — every pack committed here passes the spec's own tools/validate.py (7/7 pass today). The gate verifies against the spec repo's HEAD — the app must conform to the living spec, and the flow is self-serve: a gated PR opens a FEP, the spec PR merges, re-running checks goes green. Nothing to pin, nothing to bump. Each run logs the spec SHA it verified against so results are reproducible. There is no in-repo escape hatch, by design. A blocked PR has exactly one route: land the key in the spec via the FEP process, then re-run the PR's checks — the gate verifies against the spec's HEAD, so it goes green once the key is real. feedpak-spec-exceptions.yml is a closed grandfather list for keys that predate the gate, not a bypass: a fourth check (allowlist-closed) diffs it against the base branch and fails any PR that adds an entry, so it may only shrink. original_audio is grandfathered there against #933 so the gate lands green and starts blocking the next instance immediately; the gate takes no position on how #933 resolves (the expected outcome is removing the key, since the spec already carries the mixdown as a stem — not adopting it). Docs: docs/feedpak-spec-gate.md.

Removed

• The classic v2 UI shell is gone — v3 is the only UI (R3a). static/index.html, the /v2 route, and the FEEDBACK_UI v2/legacy opt-out are deleted; / and /v3 both serve static/v3/index.html, which has been the default since 0.3.0. This is the first step of the core-frontend ES-module migration (R3a): both shells load the same static/app.js, so every subsequent step of that migration 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 the old index() route — 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 is regenerated (the content globs scanned the deleted file, so v2-only utility classes are now purged). Constitution amended to 1.3.0: Principle II's frontend file list now names static/v3/index.html. Migration notes: if you set FEEDBACK_UI=v2 (or =legacy), or bookmarked /v2, there is no longer a classic shell to fall back to — unset the variable and use /. The env var itself is no longer read; the SLOPSMITH_*→FEEDBACK_* compat shim is unaffected. No chart, settings, or plugin data changes, and no plugin API changes: v3 reuses the same engine (app.js, highway.js, playSong, showScreen, the capability registry).

Fixed

• GP8 asset resolution honours the directory the registry named. <EmbeddedFilePath> is matched on filename stem so a format variant of the same recording can win (an .ogg beside the declared .mp3 is copied out losslessly instead of transcoded) — but the search was not restricted to the declared directory, so an unrelated file elsewhere in the archive that merely shared the stem could stand in for the declared asset. That is the exact substitution the registry lookup exists to prevent. Candidates are now confined to the registry path's own directory; a genuinely absent asset falls through as documented.
• Guitar Pro 8: the right backing track is extracted when a file carries more than one. BackingTrack/AssetId is a key into the GPIF's <Assets> registry — <Asset id="0"><EmbeddedFilePath> names the exact path inside the archive — but it was being matched against embedded filename stems. GP8 names embedded audio by hash while ids are small integers, so that match essentially never hit: every such file warned and fell through to "first audio asset". That was silently correct while a file carried exactly one recording — with two, a backing track declaring id 1 resolved to asset 0, i.e. the wrong take. Resolution now reads the registry first (verifying the path is really in the archive, so a stale entry falls through rather than resolving to nothing), then the legacy stem match, then the first asset.
• Guitar Pro import no longer fails on non-ASCII song metadata (Windows). The GP→arrangement-XML writers wrote their output with Path.write_text() and no explicit encoding, so on Windows (cp1252 default) a metadata character like the © in an album name ("Chrysalis©1982") was written as a lone 0xA9 byte — invalid UTF-8 — and import died with not well-formed (invalid token): line N, column 22. All three arrangement XML writes now pin encoding="utf-8".
• 3D Highway: the lane stops at the hit line (#991) — the highway lane, its dividers, and the fret boundary extension lines ran BEHIND seconds past the hit line toward the player. Nothing is ever drawn in that strip (notes and chord frames clamp to Math.min(0, dZ(dt))), so it read as lane with no notes on it. The floor geometry now ends at the hit line; its far edge is unchanged, still -AHEAD*TS at the note horizon.
• Career passports review polish — the passport tabs and book overlay carry proper ARIA semantics (aria-selected/aria-controls/tabpanel; role="dialog" + aria-modal with focus moved to the close button on open and restored on close), and a corrupt stored seen-badges value (e.g. a stray "null") can no longer throw on every passport refresh.
• The packaged desktop app could not start (ModuleNotFoundError: No module named 'appstate'). feedback-desktop's scripts/bundle-slopsmith.sh copies a hardcoded list of core files into the app bundle — server.py, VERSION, lib/, data/, static/, plugins/__init__.py. The root-level appstate.py and routers/ added in R3 shipped correctly in Docker and passed every test, and were then silently dropped from the packaged app, which died at startup. Both now live under lib/ — the one core directory the Dockerfile (COPY lib/), docker-compose.yml, and the desktop bundler (cp -r lib) all copy wholesale, and that all three put on sys.path (on Windows via the embeddable-Python ._pth, where PYTHONPATH is ignored). This needs no change in feedback-desktop and no new release to take effect. Placing them there is also correct under Principle V: with the injection seam, appstate.py constructs nothing and does no import-time IO, and a route module only builds an APIRouter. The Dockerfile / .dockerignore / docker-compose.yml entries added for the root layout are reverted. New tests/test_packaging.py walks server.py's module-level imports and fails if any first-party module resolves outside a directory the packagers copy, so the next root-level module can't ship broken.

Added

• Perf harness now measures 2D-highway frame time (R3c gate). scripts/perf-baseline.mjs gains a --song mode that reports per-frame draw-cost p50/p95/p99 (draw-tagged via highway.addDrawHook), the metric that gates the highway.js split. Maintainer/CI-only; baseline recorded in docs/perf-baseline.md.
• routers/ — extracting server.py's route layer, cheapest-first (R3). Each PR moves a cohesive route group into a fastapi.APIRouter under lib/routers/, mounted with app.include_router(...) at its original site (FastAPI matches in registration order; the full route table stays byte-identical). Bodies are verbatim — only the decorator receiver (@app → @router) and singleton reads (meta_db → appstate.meta_db, resolved at call time) change. So far: audio_effects (5), artist_aliases (5), loops (3), playlists (12 + covers), ws_highway (the 902-line highway chart WebSocket), chart (split/unsplit/work/fileinfo — unblocked by the DLC-path substrate), library_extras, wanted, shop, progression, profile, stats (the /api/stats/{path} catch-all stays registered last so it can't shadow /recent /best /top), version (/api/version; VERSION-file lookup adjusted for the router subdir depth), art (the /api/song/{f}/art* serve/cover-search/candidates/upload/url + /api/art/{f}/override routes; the shared _song_pack_art_exists/_art_override_paths/_art_safe_name helpers stay in server.py for the song/delete routes and are reached through the appstate seam, the CAA/release transport as enrichment.X), and settings (GET/POST /api/settings, /reset, and the two-phase atomic export/import bundle /api/settings/export|import; the shared _default_settings builder stays in server.py and is reached through the appstate seam), and song (upload/delete + the metadata write-back, user-meta, overrides, gap-fill, and per-song info routes; the scan/ingest helpers stay in server.py and are reached through new appstate seams — kick_scan, invalidate_song_caches, stat_for_cache, and a scan_status() getter — the get_song_info catch-all mounts after the art routes so it can't shadow them), and library + collections (the provider list/art/sync endpoints, the library query surface, and collection CRUD → lib/routers/library.py; the LibraryProviderRegistry/LocalLibraryProvider/SmartCollectionProvider classes + shared query/collection helpers move to lib/library_registry.py, and the registry instance + local provider ride the appstate seam — server.py still constructs the singleton and exposes register_library_provider/unregister_library_provider to plugins via plugin_context unchanged), and the enrichment route handlers (/api/enrichment/*: status, kick/cancel, per-song state, the Match-Review queue, and AcoustID identify → lib/routers/enrichment.py; the engine already lives in lib/enrichment.py and is reached as enrichment.X), and media (the file-serving routes — song audio /audio/{f}, the local-audio-path resolver /api/audio-local-path, and raw sloppak-member serving /api/sloppak/{f}/file/{rel} → lib/routers/media.py; the cache/static path seams were already in appstate), and artist (the artist page + external-links payload /api/artist/{name}/page|links|links/refresh → lib/routers/artist.py; MB link enrichment reached as enrichment.X), and diagnostics (/api/diagnostics/export|preview|hardware; the plugins-root lookup adjusted for the router subdir depth, _running_version reached through the appstate seam, pure payload-cap helpers re-exported for the server._diag_* tests), and tunings (/api/tunings; the pure config.json reader moved to lib/appconfig.py, the tuning-provider registry read through the appstate seam so plugin-contributed tunings still merge). The DLC library-path resolution (_get_dlc_dir, pure _resolve_dlc_path) moved to lib/dlc_paths.py, reading paths through the seam; config_dir/dlc_dir/dlc_dir_env now ride the appstate seam (env-derived, so the pop-and-reimport fixtures reconfigure it for free), and the shared request-field sanitizer _clean_str moved to lib/reqfields.py. The next cut is picked by a dependency-closure scan that ranks groups by how many monkeypatch.setattr(server, …) targets they'd drag along.
• routers/ — the first extracted route module (R3). The five audio-effects mapping endpoints move out of server.py into lib/routers/audio_effects.py as a fastapi.APIRouter, mounted with app.include_router(...) at the point in the file where they used to be defined — FastAPI matches routes in registration order, so the mount site preserves it. Verified: the full 143-route table (paths, methods, and order) is byte-for-byte identical to main. Bodies are verbatim; the only edits are the decorator receiver (@app.get → @router.get) and the singleton read (audio_effect_mappings → appstate.audio_effect_mappings, a module attribute resolved at call time). This proves the seam from #833 under a real consumer, including the second slot. The _demo_mode_guard middleware still blocks all four moved write routes with 403, and Query(...) validation still 422s — both checked against a running server. server.py: 9,445 → 9,386 lines.
• lib/enrichment.py — the metadata-enrichment subsystem leaves server.py (R3, move-only). MusicBrainz / Cover-Art-Archive / AcoustID transport, the match-scorer glue, and the background enrichment worker (~930 lines, 61 defs) move out as one cohesive unit. Bodies are verbatim; the only changes are seam reads — meta_db/config_dir/sloppak_cache_dir/art_cache_dir and the two shared art helpers (song_pack_art_exists, art_override_paths, which stay in server.py for the art/delete routes) are reached through appstate at call time, and the User-Agent VERSION lookup is corrected for the module's new depth. server.py drives the worker through the module (import enrichment; the routes + scan lifecycle call enrichment.X); tests that faked the network on server now patch the same names on enrichment (module attribute resolved at call time, so one setattr reaches both the routes and the worker's internal callers). Acyclic — enrichment imports no server. Route table byte-identical; full suite green. server.py: 6,917 → 5,988.
• appstate.py — the router seam (R3). Route modules moving out of server.py need meta_db and friends but must not import server, or the import graph goes circular the moment server imports them back. So server.py keeps constructing its singletons and now injects them once — appstate.configure(meta_db=…, audio_effect_mappings=…) — and a router reads them back as module attributes at call time (import appstate; appstate.meta_db.…). This is the Python analogue of the frontend refactor's injected configureX({…}) seams and of the plugin setup(app, context) contract: dependencies flow one way, server → routers → appstate. Two properties are load-bearing and pinned by tests/test_appstate.py: (1) import appstate constructs nothing and touches no disk, so 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; (2) reads must be late-bound (appstate.meta_db, never from appstate import meta_db), since a from import freezes the binding and defeats both a later configure() and monkeypatch.setattr — the same read-only-binding trap as ES import. configure() rejects an unknown slot rather than silently creating a global nothing reads, and the suite asserts server actually calls it (a seam whose wiring can no-op undetected is worse than no seam). Lives at lib/appstate.py.

Changed

• AudioEffectsMappingDB moved out of server.py into lib/audio_effects_db.py (R3, move-only). The core-owned song/tone → provider routing index follows MetadataDB out of the host file, byte-identical apart from the same constructor seam (__init__ takes config_dir; audio_effect_mappings = AudioEffectsMappingDB(CONFIG_DIR)), so the module does no IO at import. The singleton stays in server.py; no route, no test and no monkeypatch.setattr(server, …) target moves. server.py: 9,705 → 9,433 lines.
• MetadataDB moved out of server.py into lib/metadata_db.py (R3, 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) — now lives in its own flat lib/ module. server.py drops from 14,037 → 9,705 lines and keeps the meta_db singleton, so server.meta_db and server.app resolve exactly as before and every route is untouched. The only non-verbatim change is the seam that lets the class leave server.py: MetadataDB.__init__ now takes config_dir explicitly (meta_db = MetadataDB(CONFIG_DIR)) instead of reading the module-level CONFIG_DIR, which also means lib/metadata_db.py performs no IO at import (Principle V). Logging still goes through the feedBack.server logger, so existing log filters and caplog assertions resolve to the same logger object. tests/test_settings_export_library_db.py now imports _apply_pending_db_restore from metadata_db (the test moved with its subject); no other test changed. Every moved block is byte-identical to its server.py original.

Added

• Plugins can ship an ES-module src/ tree (module-migration rails, R0). The host gains three things so a plugin can move off a single global-scope screen.js IIFE onto native ES modules with no build step: (1) a new sandboxed GET /api/plugins/{id}/src/{path} route that serves a plugin's src/ source subtree, containment-checked by the same safe_join guard as assets/ (traversal/absolute/NUL → 404); (2) the live-edit cache contract — Cache-Control: no-cache + a weak mtime/size ETag + If-None-Match→304 — applied to src/, screen.js, and assets/ (previously screen.js sent no cache headers and assets/ emitted an ETag but never revalidated), so an edited module reloads on refresh while unchanged ones 304; and (3) scriptType/minHost passthrough from plugin.json to /api/plugins, with the loader injecting a plugin that declares "scriptType":"module" as <script type="module"> (its screen.js becomes import './src/main.js'). A <script type=module> fires its load event only after its whole static-import graph evaluates, preserving the loader's completion-by-onload + _loadingPluginId contract. Classic plugins are unaffected; minHost is passthrough-only for now (enforcement deferred). Tests: tests/test_plugin_src_route.py (serve/media-type/traversal/304/no-stale-304/screen.js+assets conditional), tests/js/plugin_loader_script_type.test.js (guarded module injection).
• Module-migration governance & rails (R0). Constitution amended to v1.2.0: Principle II now names native ES modules as a first-class, build-free extension mechanism (the scriptType:"module" load path, both plugins and — over time — core's static/js/), keeping the no-bundler/no-transpiler/source-served rule intact; Operating Constraints gains a "Module load contract" clause (a <script type=module> load event awaits the whole static-import graph, so completion-by-onload is preserved; per-visit re-init comes from the screen:changed event, not screen.js re-execution). Mirrored into CLAUDE.md. New docs/plugin-modules.md (the migration playbook — layering, import-time purity, import.meta.url assets, the ETag live-edit loop) and docs/size-exemptions.md (the signed 1,500-line size-norm register; Byron signs core/bundled rows, Christian the authored virtuoso row). Adds a maintainer/CI-only ESLint gate (eslint.config.js + a lint CI job): max-lines warns at 1,500 as a non-blocking ratchet (ceilings for exempt files mirror the register), and import-x/no-unresolved + import-x/no-cycle hard-error on ES-module graphs — dormant until module code lands, never on the serve/Docker path.
• Perf-baseline harness (R0). scripts/perf-baseline.mjs (maintainer-only, Playwright-driven) captures server p50/p95/p99 latency, cold boot-to-interactive, JS-heap after an idle soak, and the injected plugin-script shape (how many are type=module), so every refactor phase can be checked for "screen-entry and frame-time no worse." Methodology + the R0 baseline live in docs/perf-baseline.md; playback frame-time and chart-loaded screen-entry rows need a seeded library and are re-taken per environment.
• Sort and filter the library by your personal difficulty rating — now visible at a glance, not just in the edit drawer. song_user_meta.user_difficulty (the 1–5 planning rating, settable manually or seeded by a plugin like the community difficulty_tagger) already existed but was only readable by opening a song's per-song details drawer. The library API gains sort=difficulty / sort=difficulty-desc — a correlated subquery over song_user_meta, following the same unrated-rows-sort-to-the-bottom-in-both-directions pattern as the existing mastery sort — and library cards now show the rating as a ◆N badge (v2 grid/tree views and the v3 grid alike), next to the tuning and lyrics badges. The classic tree view's query_artists batch-attaches user_difficulty the same way query_page already did for the grid, so the badge actually renders there too instead of staying dark. Tests: tests/test_library_filters.py::test_difficulty_sort_pushes_unrated_to_bottom, tests/test_library_filters.py::test_tree_view_songs_carry_user_difficulty.
• lib/midi_import.py: convert_midi_tempo_map — MIDI imports can finally carry their bars. The keys/drums note converters always computed a tempo-aware tick→seconds map internally (to bake note times to absolute seconds) and then threw it away — and never read time_signature meta at all — so every MIDI import landed with no measures and an implied 4/4 regardless of what the file said. The new helper extracts the whole grid: tempos ({time, bpm}), time_signatures ({time, ts:[num,den]}, the song-timeline sidecar shape), and a full beats grid on the editor's row shape (numbered downbeats with a den hint, -1 interior beats, eighth-note rows in 6/8 etc.). Event scope mirrors the existing tick map — SMF type 0/1 merge meta across tracks, type 2 reads only the chosen track (independent timelines must never share a grid); mid-bar signature events apply at the next bar boundary; times are computed from absolute ticks through the cumulative tempo table and rounded once at emit, so rounding error never accumulates with song length. Consumed by the editor's upcoming multitrack MIDI import (tempo-seed dialog). Tests: tests/test_midi_tempo_map.py.

Fixed

• Tuner: opening the player screen no longer throws NotFoundError and aborts the player render (feedBack#800). injectPlayerButton() anchored the injected Tuner button with controls.querySelector('button:last-child'), which — unlike a :scope-scoped query — can match a nested button that is not a direct child of #player-controls. controls.insertBefore(btn, nestedButton) then throws NotFoundError (the reference node must be a direct child), and because the injection runs from the tuner's screen:changed → player handler, the throw propagated out of the player-screen transition and stalled its render (surfaced by a headless render of a notation arrangement; the v3 path was already safe via the plugin-control slot, only the classic path had the bad anchor). The anchor is now :scope > button:last-of-type (a direct child only) with a parentNode === controls guard before insertBefore, falling back to appendChild. plugins/tuner → 1.3.4. Tests: tests/plugins/tuner/js/inject_player_button.test.js (nested-last-button repro, direct-child insert, no-button append, idempotency, v3 slot path).
• Auto-sync: DTW step constraint — riff-based songs no longer produce garbage sync points. librosa.sequence.dtw's default step pattern allows unbounded horizontal/vertical path runs, and on music with long self-similar chroma stretches (riff-driven stoner/doom, drone sections) the flat cost surface let the warping path collapse — minutes of score mapped onto a single audio frame, so the per-bar warp imported charts wildly out of sync while reporting success (observed on a real 138 BPM tab: effective displayed tempo 159 BPM, three sync points sharing one audio timestamp). _dtw_align now uses the standard music-sync slope-constrained step pattern ([[1,1],[1,2],[2,1]], local tempo ratio bounded to 0.5x–2x), which makes the degenerate path impossible, with a fallback to unconstrained steps when the global length ratio makes the constrained pattern infeasible (e.g. a tab aligned against a full-concert video). Validated on the failing song: coarse points track the recording 1:1, refined downbeats land on onset peaks at 3.3x background energy.

Added

• 3D Keys Highway: key layout modes, lane-color opacity & octave lines. A new Highway layout settings section rebuilds how sharps/flats and lanes draw on the 3D piano highway. Sharps & flats layout (keys3d_bg_sharpMode) picks between floating (the original raised-sharp look), flat (one plane, zero-overlap piano-shaped tiled lanes with the naturals evened out), and realistic (one plane, bars sized like the physical keys) — default realistic; the geometry lives in pure, unit-tested laneSpanFlat()/laneSpanReal() helpers. Lane color opacity (keys3d_bg_laneOpacity, 0–1, default 0) fades the pitch-class lane tint from full vivid color down to a dark floor with guide lines only at the key-block boundaries (E→F and each octave); the lane strips, per-lane separators and block lines crossfade with the value. Octave separators (keys3d_bg_octaveGaps, default on) and Octave line contrast (keys3d_bg_octaveContrast, 0–1) control the B→C octave divider, which auto-shifts from a dark to a bright layer as lane opacity fades. Settings re-read on init and apply on the next chart build. plugins/keys_highway_3d → 0.2.0. Tests: plugins/keys_highway_3d/tests/fx_settings.test.js (new defaults, sharp-mode setting, lane-geometry tiling/evening for flat, uniform/overlap for realistic, and an active-range boundary case where a white key's edge stays untrimmed when its neighboring sharp falls outside the active range).
• Unmapped-percussion capture now records velocities alongside times. Both drum converters' opt-in out_unmapped reporting (lib/midi_import.py convert_drum_track_from_midi, lib/gp2rs.py convert_drum_track_to_drumtab) gain an index-aligned velocities list next to times, carrying each dropped note's real dynamics (MIDI velocity verbatim; GP velocity with the same 1–127 gate as mapped hits, falling back to the 100 import default). This lets a hand-mapping UI (the editor's unmapped-notes dialog) restore mapped notes at their source dynamics instead of flattening everything to v:100. The GP path's chronological sort now reorders times and velocities in lockstep so multi-voice measures can't silently reassign dynamics. Additive — callers that ignore the new key are unaffected. Tests: tests/test_midi_import_drums.py, tests/test_gp2rs_drums.py.
• Handedness (left-handed) is now a first-class choice in the instrument selector — and surfaced during 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 hit the tour, the tuner and calibration all right-handed first. The v3 instrument badge popover now has a Handedness: Right / Left row alongside Instrument / Strings / Tuning (all player-orientation choices), writing the same lefty preference (highway.setLefty when a live highway exists, else the lefty localStorage key it reads on init; the Settings checkbox stays 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: static/v3/badges.js, static/v3/onboarding-tour.js. Tests: tests/js/badges_handedness.test.js.
• "Colorblind (deuteranope)" highway string-color preset. Adds a one-click preset to the shared "Highway String Colors" picker, sitting 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 (red / yellow-green / blue / orange / teal / deep-purple) and keeps that set's 7/8-string colors, and applies to both the 2D and 3D highways via the shared picker. Frontend-only, additive: static/app.js (HWC_PRESETS).
• lib/gp_autosync.py: piecewise time-warp helpers + a working refine_sync(). auto_sync() has always computed per-bar sync points (DTW), but consumers could only apply the scalar bar-1 audio_offset, so any tempo difference between the recording and the tab's authored tempo accumulated audibly over the song. New librosa-free helpers expose the full mapping: bar_start_times(gp_path) (per-bar score times on the same axis as the sync points — GPIF bar-resolution map for .gp/.gpx, per-tick integration for GP3/4/5), build_warp_anchors(points, bar_starts) (strictly-monotonic (score, audio) anchor pairs), warp_time(t, anchors) (piecewise-linear map with edge-slope extrapolation for count-ins/tails), warp_song_times(song, warp) (retimes a lib.song.Song in place: notes + sustains, chords, beats, sections, anchors, handshapes, per-phrase difficulty levels, tone changes, tempo overrides), and gp_has_expandable_repeats(gp_path) (detects GP3/4/5 repeat/volta/direction markup whose playback expansion the as-written sync points cannot map — callers fall back to offset-only sync). Also implements refine_sync(), which the editor plugin's refine-sync endpoint has imported since the snapshot but which never existed in core (the Refine button 500'd): it densifies the coarse DTW points to every Nth bar and re-times each with a local onset phase sweep (sweep radius clamped under half a beat so periodic material can't lock a full beat off; short scoring grid + median residual snap). Synthetic click-track validation: ~13ms mean / ~40ms max error from ±180ms coarse input across 117–123 BPM recordings of a 120 BPM tab. Tests: tests/test_gp_autosync_warp.py.
• Playlist shuffle. The v3 playlist detail page gains a crossing-arrows shuffle toggle next to Play all / Play album. When on, playQueue.start Fisher-Yates-shuffles the queue once at start (on a copy — the stored playlist order is untouched), swapping any per-slot album arrangements in lockstep so each slot keeps its pinned arrangement. The preference is global and persists in localStorage (v3PlaylistShuffle). Tests: tests/js/play_queue_shuffle.test.js.

Changed

• Player frame-time hotspots removed (trace-backed) + weak-hardware hardening. A Chrome performance trace of a 3D-highway session surfaced two core per-frame layout-thrash sources, now fixed: the highway's visibility check read canvas.offsetParent every rAF frame (forces style/layout recalc — now sampled every 10th frame with a cached value, force-refreshed on init/canvas-replace/resize/override-clear), and the v3 player chrome loop called matches(':hover') per frame and unconditionally rewrote the Up-Next pill's textContent/bar width at 6 Hz (now hover-tracked via mouseenter/mouseleave, DOM writes only on value change, progress bar moved from width to compositor-only scaleX). The 3D highway pre-warms shader programs (ren.compile) and deterministic label textures at init — and chart-dependent chord/section label textures on first draw — so first-appearance shader-compile/texture-upload frame spikes move into the load spinner. For weaker hardware: the per-frame renderer bundle is now a single reused object instead of a fresh ~35-field allocation per frame (object identity is stable and meaningless; array fields still swap reference on chart changes), custom viz get bundle.lowerBoundT/bundle.lowerBoundTime binary-search helpers for visible-window culling, the default 2D highway's beat lines no longer scan every beat in the song per frame, and the 3D highway stops reading localStorage per frame (1 Hz poll) and caches its lyrics text-measurement layout per displayed line instead of re-measuring every syllable every frame. A second, throttled-CPU trace pass additionally removed: shader-program re-resolution churn from label texture swaps (material.needsUpdate is now only set on a null↔texture transition — swapping between two cached label textures never changes the compiled program), the 3D highway's per-frame getBoundingClientRect layout read in its canvas-size self-check (now every 10th frame, still immediate on backing-store change), and the core 60 Hz HUD clock rewriting textContent on every tick (now write-on-change, ~1/s). The dominant residual — steady getParameters shader-program re-resolution (~4% of throttled main thread) — turned out to be Three r158+'s transparent-DoubleSide two-pass rendering, which sets material.needsUpdate twice per object per frame; all 18 of the 3D highway's transparent DoubleSide materials are flat unlit quads (labels, rails, chord frames, lanes), so they now declare forceSinglePass: true, eliminating the recompile churn and halving those objects' draw calls.

Fixed

• playback.loop-api bridge no longer fires dozens of times per second. Every window.feedBack.getLoop() call recorded a full bridge hit — compat-shim bookkeeping, a playback:bridge-hit event, and a diagnostics snapshot rebuild + stringify — so a plugin polling loop state from a HUD tick (note_detect at ~30 Hz) flooded the capability inspector and burned main-thread time even with no song playing. _recordPlaybackBridge now throttles per bridge/surface (5 s window): bridge hits are a "surface still in use" signal, not a call counter. The manual A/B loop buttons (setLoopEnd) also now emit the same loop-set transport event as setLoop(), so plugins can react to loop changes via playback:loop-set / playback:loop-cleared events instead of polling getLoop().
• 3D Highway: recover from a WebGL context loss instead of crashing on alt-tab. Switching the active window / alt-tabbing away from the app (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 torn down with the renderer. plugins/highway_3d → 3.31.3. Tests: tests/js/highway_3d_context_loss.test.js. (The sibling keys_highway_3d / drum_highway_3d renderers share the same gap — tracked as a follow-up in their repos.)
• Guitar Pro 6 (.gpx) import no longer fails on every real file. The GPX BCFS container reader (lib/gp2rs_gpx.py) rejected any file whose final sector wasn't a full 0x1000 block — but a real .gpx's BCFZ-declared decompressed size isn't sector-aligned, so the last (small) container file always lands in a partial trailing sector. The bounds check raised GPX BCFS sector pointer out of range (malformed file) instead of clamping the tail read, so _load_gpif threw before score.gpif could be extracted and no GP6 file could be imported into the song editor (both real test files failed identically — this wasn't file-specific). GP7/GP8 .gp files were unaffected — they take the ZIP path, not BCFS, which is why prior GP-import work didn't surface it. The reader now clamps 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, preserving the malformed-file guard. Verified against two real GP6 files — both now unpack to valid GPIF with all tracks. Tests: tests/test_gp2rs_gpx.py (partial-final-sector round-trip, multi-file container, sector-aligned baseline, and the preserved out-of-range guard).
• v3 Songs grid: fixed the scroll stutter that "skips every so many scrolls," up or down. The virtualized grid rebuilt its entire visible window (grid.innerHTML = … + a full wireCards pass) every time it slid by one row, so each row-boundary crossing was a heavy synchronous frame that stalled the main thread and buffered held-arrow key-repeats into a visible lurch (a tester's "super fast for a second then slowed down") at fixed scroll offsets — in both directions and regardless of whether the page was already loaded (the cost was DOM teardown, not fetching, which is why scrolling back up over cached songs hitched too). 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), keyed by absolute index with a real-vs-skeleton + select-mode signature so hole-fills (after a page fetch) and select-mode toggles still rebuild exactly the nodes that changed. wireCards's data-wired guard then wires only the freshly-built nodes, so per-slide listener churn drops with it. Follow-up to the stage-2 virtualized grid (got-feedback/feedBack#636 item 3). Frontend-only: static/v3/songs.js. Tests: tests/js/v3_songs_window_recycle.test.js (window stays [start,end) contiguous + in-window node identity reused across a down-then-up scroll; select-mode toggle and rail-seek jump rebuild correctly).
• Starter content seeds again (and now ships The Adicts' "Ode to Joy"). _BUILTIN_STARTER_SOURCES still listed beethoven-ode_to_joy.feedpak after that pack was deleted, and never wired up its replacement the_adicts-ode-to-joy_vst_cover.feedpak that landed on disk. The listed-but-missing file made the all-present gate never fire, so no starter songs seeded on first run. Synced the manifest to what's on disk (Für Elise, Star Spangled Banner, The Adicts' Ode to Joy). Tests: tests/test_builtin_starter_seed.py (the present/unlisted guards were red on main).
• Edit Metadata now writes into .feedpak files, not just legacy .sloppak ones. lib/songmeta.py's suffix gate predated the format rename — core reads both suffixes everywhere else (sloppak.SONG_EXTS), but the metadata writer only dispatched on .sloppak, so editing a zip-form .feedpak's title/artist/album/year silently fell back to a DB-only update. That looked fine until the next full library rescan re-derived metadata from the file and reverted the edit (directory-form packages were unaffected — they dispatch on manifest presence, not suffix). The gate now accepts both package suffixes. Tests: tests/test_songmeta.py TestWriteSongMetadata (both zip suffixes, mixed-case suffix, directory form, unknown-suffix fallback).
• 3D Drum & Keys highways now re-frame on fullscreen/layout drift under splitscreen. The guitar/bass highway_3d self-detects when its panel canvas changes size 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 (visible as a too-small, off-center highway after maximizing a split-screen session). Both draw loops now port highway_3d's per-frame drift check: they 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), and reset the tracking 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.
• Tuner: finished the "remove unused settings" cleanup and fixed the sidebar panel position. The Floating Button and Tuning Visibility settings sections were removed, but their config was still live: disabledTunings still filtered the tuner menu (with no UI left to re-enable a hidden tuning — a one-way trap) and showFloatingButton still gated the floating launcher. Both are now fully retired — the enforcement paths in plugins/tuner/screen.js/utils/ui.js and the persistence in plugins/tuner/routes.py are gone (and routes.py strips the retired keys on write, so stale values are purged). The tuner panel opened from the v3 sidebar Plugins rail popover now anchors beside it via the host's stable plugin-control slot API (falling back to the popover id), is clamped to the viewport so it can't open off the right/bottom edge on narrow/short windows, and re-anchors on window resize. plugins/tuner → 1.3.3.

Added

• Host theme read surface — window.feedBack.theme + always-present --fbv-* tokens — so a plugin feature can render correctly under any theme instead of binding to whichever one the developer happened to see. The cosmetics applier (static/v3/theme-core.js) previously only applied themes and emitted --fbv-* vars only while a theme was equipped (nothing for a plugin to read in the default, un-themed state) with no read/capability API — so plugins reinvented their own theming and a new visual device (a glow, a gradient) silently bound to one look. It now: (1) emits the default fb palette as always-present --fbv-* on :root (additive — the un-themed look is unchanged; the fb-* utilities still use their compiled defaults; this only hands plugins a stable host token to read + derive surfaces from), plus two keystone ROLES the palette lacked — on-accent (a foreground legible on the accent fill — the missing piece behind white-on-accent contrast bugs) and focus-ring; (2) adds window.feedBack.theme — get() → {id, isThemed, tokens}, capabilities() → {glow, gradients, motion} (the device-affordance signal a feature reads to choose a glow vs. a solid device; recolor-only themes report defaults, a theme may opt out via a capabilities block in its payload, and motion is additionally reduced-motion-gated), and prefersReducedMotion() (one central matchMedia wrapper); and (3) emits a normalized theme:changed event ({id, isThemed, tokens, capabilities}) from the single apply() chokepoint. All additive + feature-detected (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). First slice of the host theme contract (got-feedback/feedBack#644) — the framework fix so a plugin UI feature can't accidentally carve itself into a single theme; see docs/host-theme-contract.md. Verified by a headless render (apply/unequip intact, defaults present + restored, capability opt-out honored, event payload correct). Tests: tests/js/v3_theme_read_api.test.js.
• 3D Keys Highway: audio-reactive background ambience + score effects (parity slice 4 — completes the keys side of the visual-parity epic). The gradient sky behind the highway gains the guitar's background ambience styles — drifting Particles, pitch-class-colored pulsing Stage lights, wireframe Geometric shapes, or Off — driven by the shared audio-analyser bridge (stems-first on sloppaks, one-shot #audio fallback; bass/mid/treble bands, 5 ms cache) with an Ambience intensity slider and an Audio-reactive toggle. And the score talks back: a score-FX overlay canvas draws rising “+1” pops off each scored key, an expanding ring every 10-combo tier, milestone bursts at 25/50/100 streak, and a brief red flicker when a 3+ streak breaks (wrong notes and swept misses both count). All settings-gated and on by default (keys3d_bg_*), pooled, cleared when idle, torn down with the scene. Butterchurn/image/video remain out of scope. The #audio analyser tap is also shared across visualizers now (window.__feedBackAudioTap — whoever taps first publishes, everyone else adopts, highway_3d included), so switching between or splitting the guitar/drum/keys highways can't strand a permanently non-reactive backdrop, and the tap is never created before the page has user activation (a suspended AudioContext would silence live playback). Tests: bg-style id validation + FX defaults (30 total).
• 3D Keys Highway: the anti-plastic pass — lacquered note gems, glossy piano-black keys, a studio environment, scene themes and a gradient sky (parity slice 3). The note gems move to MeshPhysicalMaterial with a full clearcoat (roughness 0.32, clearcoat 1.0/0.18, envMapIntensity 0.9): a sharp lacquer highlight over the colored body instead of the old dead matte surface — glass, not plastic. What sells it is image-based lighting: the same procedural PMREM "studio" environment as the drum highway (dark room + cool overhead / warm+cool side light strips, no addon dependency) feeds scene.environment, so the black keys finally read as glossy piano black (roughness 0.55 → 0.22, envMapIntensity 1.3) with visible strip reflections, whites keep an ivory sheen (0.42/0.55), and the highway floor gets a stage sheen (roughness 0.9 → 0.55, metalness 0.15). The flat background becomes a vertical gradient (lighter above the horizon → theme color → darker toward the keyboard), and the guitar highway's 11 scene themes arrive (same names/values — your look carries across instruments; default preserves the original keys palette; pitch-class note/key colors are never themed — themes own the scene, Synthesia colors own the notes). Plus Cinematic lighting (ambient 0.55/key 1.3, on by default) and a Glow strength slider multiplying the note glow, key approach-glow and the sustain consume-flash (0.5 = stock). All live-applying from the Graphics settings (keys3d_bg_theme + keys3d_bg_*); the PMREM target and gradient texture are disposed with the scene. Tests: theme-table id parity + default-look preservation + fallbacks (28 total).
• 3D Drum Highway: audio-reactive background ambience + score effects (parity slice 4 — completes the drum side of the visual-parity epic). The empty fog band behind the kit gains the guitar highway's background ambience styles: drifting Particles, palette-colored pulsing Stage lights, and slowly-tumbling wireframe Geometric shapes (plus Off) — driven by the same audio-analyser bridge the guitar uses (prefers the stems plugin's per-song analyser on sloppaks, falls back to a one-shot #audio tap; bass/mid/treble bands with a 5 ms cache), with an Ambience intensity slider and an Audio-reactive toggle (off = the styles animate on time only; a permanently-tapped #audio in a mixed split degrades the same way). The guitar's butterchurn/image/video styles are deliberately out of scope (vendored megabytes / upload plumbing; the style enum is extensible). And your combo finally talks back: a score-FX overlay (2D canvas over the WebGL scene, guitar drawScoreFx adapted to this plugin's internal scoring) draws rising “+1” pops off each scored lane, an expanding ring pulse every 10-combo tier, milestone particle bursts at 25/50/100 streak, and a brief red flicker when a 3+ streak breaks. Everything is settings-gated (Background ambience dropdown + intensity + reactive, Score effects toggle — all on by default, live-applying, drum_h3d_bg_* keys), pooled (zero per-frame allocation), and torn down with the scene across kit changes. Tests: bg-style id validation + FX defaults (15 total).
• 3D Drum Highway: real materials + scene themes (parity slice 3). The scene gets image-based lighting: a procedural PMREM "studio" environment (dark room + three emissive light strips — cool overhead key, warm/cool side fills; no vendored-addon dependency) feeds scene.environment, so the cymbals' metalness finally reads as metal (retuned to roughness 0.2 / metalness 0.85 / envMapIntensity 1.2 — the old 0.7-metalness look was matte because there was nothing to reflect), drumheads get a satin sheen, and the floor (roughness 0.95 → 0.7) catches the strips without turning into a mirror. Scene themes arrive — the same 11 theme names as the guitar highway (Midnight, Charcoal, Deep Purple, Forest, Warm Slate, Deep Focus, Deep Sea, Cathode, Cathode Green, Hearth) retint the background/fog, floor and lane stripes so your look carries across instruments; default preserves the original drum palette byte-for-byte, and piece colours stay with the existing Palette picker (themes own the scene, palettes own the kit). Plus Cinematic lighting (dimmer ambient / stronger key, on by default), a Glow strength slider (0–1, 0.5 = stock) multiplying every emissive base — notes, hit line, snare wires — and a Lane vibrancy slider driving stripe/halo/ghost-ring strength (the hit-FX approach highlight stacks on top). Everything applies live from the plugin settings (drum_h3d_bg_theme + drum_h3d_bg_* keys); the PMREM render target is rebuilt across kit-change renderer recreation and disposed in both teardown paths — and the floor/hit-bar geometry+materials that previously leaked on every kit change are now tracked and disposed too. Tests: theme-table parity with the guitar ids + default-look preservation + fallbacks (13 total).
• 3D Drum Highway: hit FX — sparks, timing-colored lane flashes, kick camera pulse, approach glow, and open hi-hat notation (parity slice 2). Striking a pad now feels struck: a pooled additive spark burst fires at the lane (ported from the guitar highway's Points-cloud system, pool 160), colored by timing — on-time green, early cyan, late amber (same _timingHex vocabulary as highway_3d, classified against the ±50 ms hit window with the inner 40% reading as on-time); with Streak feedback on, bursts grow with your combo. The lane flash feedback that was removed when note-recoloring landed is resurrected properly: pooled additive quads with a soft gaussian falloff light up the struck lane at the hit line (timing-colored; red for wrong-pad hits), and a kick hit fires triple amber bursts across the bar plus a subtle camera dip + amber floor wash that decays exponentially. Lanes also glow ahead of time: each stripe brightens as its next note approaches the hit line, so the eye is led to where the next hit lands. Open hi-hat finally renders distinctly — hh_open chart hits get a thin warm ring around the cymbal gem (standard notation's "o"), closing the long-standing TODO; the flag is orthogonal to accents/ghosts/flams so combined cues stack. All of it is settings-gated (Graphics → Hit sparks / Timing colours / Streak feedback / a 0–1 Hit feedback intensity slider driving flashes, approach glow and the kick pulse; everything on by default, drum_h3d_bg_* keys, live-applying) and GPU-frugal: every new visual is pooled or shares geometry/materials — zero per-note allocation on top of the per-frame notes rebuild, all registered in both dispose paths (kit-change renderer recreation included). Tests: timing-classifier boundaries + FX defaults added to plugins/drum_highway_3d/tests/data_layer.test.js (10 total).
• 3D Keys Highway: hit FX — vibrant note gems, timing-colored sparks, and a hit-line that reacts to your playing (parity slice 2). The washed-out note look is gone: gem opacity is now driven by a Note vibrancy slider (default 0.85 → opacity 0.92, up from a fixed 0.8; lane guides scale with it too, live-applying without a chart rebuild) and the resting emissive glow rises 0.08 → 0.22, so the falling notes finally read saturated against the dark floor. Scored key presses fire a pooled additive spark burst at the struck key (guitar-highway port, pool 96) colored by timing — on-time green, early cyan, late amber, classified against the ±100 ms window with the inner 40% reading as on-time (the timing delta is recovered from the matched note's key, so judgeHit's tested contract is untouched); the per-pitch-class flame sprite keeps its identity color so pitch and timing stay separate signals. With Streak feedback on, bursts grow with the combo. The hit line kicks brighter for a beat on every scored press (exponential decay, scaled by a 0–1 Hit feedback intensity slider). All new controls live in the plugin's Graphics settings (on by default, keys3d_bg_* keys, live-applying), and the spark pool is disposed with the scene like every other GPU resource. Tests: timing-classifier boundaries, the noteKey time round-trip that the delta recovery relies on, and the new FX defaults (26 total).
• 3D Drum Highway: bloom glow + adaptive-resolution support — the first slice of visual parity with the guitar highway. The drum highway now renders through the same post-processing path as highway_3d: an UnrealBloomPass (strength 0.65, radius 0.5, threshold 0.82 — high, so only emissive/bright surfaces bleed) on a multisampled HalfFloat target with ACES filmic tone mapping, so the white hit-line bar and proximity-lit notes get a real glow instead of a flat emissive tint. On by default, with a new Graphics → "Glow (bloom)" toggle in the plugin settings (drum_h3d_bg_bloom, applies live, no reload); if the vendored postprocessing addons can't load (older self-hosted core), the plugin silently falls back to the direct render path. The plugin also now honors the host's adaptive render scale (bundle.renderScale — the Quality/"Min res" controls that the guitar highway already respected), multiplying it into the device pixel ratio, and caps DPR at 1.25 when more than one viz instance is live (splitscreen) so two panels don't double the GPU fill cost. Groundwork for the rest of the parity series: an FX-settings scaffold (FX_DEFAULTS/readFxSettings/window.drumH3dSetFx, drum_h3d_bg_* localStorage keys) that the sparks/themes/backgrounds PRs extend, plus a first node test suite for the plugin (plugins/drum_highway_3d/tests/data_layer.test.js — vm-loaded like the keys plugin's, covering the hit-variant precedence, the Auto-mode steal-guard predicate, and FX defaults; 8 tests, runs in CI via the plugins/*/tests/*.test.js glob).
• 3D Keys Highway: sharp HiDPI rendering, bloom glow, a live combo HUD, and a graphics settings panel — the first slice of visual parity with the guitar highway. The biggest single fix is resolution: the plugin never called setPixelRatio, so on HiDPI/retina displays (and Windows display scaling) it rendered at CSS resolution and was upscaled — soft and aliased. It now multiplies the device pixel ratio (capped at 2, or 1.25 when two viz panels are live in splitscreen) with the host's adaptive render scale (bundle.renderScale, the Quality/"Min res" controls), exactly like highway_3d. On top of that: the same bloom post-processing path as the guitar highway (UnrealBloomPass 0.65/0.5/0.82 on a multisampled HalfFloat target + ACES tone mapping — the cyan hit-line, hit flames and the sustain "consume" glow finally bleed light instead of reading flat), on by default with a graceful direct-render fallback when the vendored addons can't load. The plugin gains its first settings panel (settings.html, Settings → graphics category, "settings" block in plugin.json) with a live-applying "Glow (bloom)" toggle (keys3d_bg_bloom), plus the FX scaffold (FX_DEFAULTS/readFxSettings/window.keys3dSetFx, keys3d_bg_* keys) the later parity PRs extend. And the score state the plugin was already tracking is finally visible: a combo / accuracy / best-streak HUD overlay (drum-highway pattern), shown only while a MIDI keyboard session is wired so it never renders a frozen 0× combo. Tests: plugins/keys_highway_3d/tests/fx_settings.test.js (defaults, localStorage overrides + type coercion, setter persist/dispatch/unknown-key guard; 3 tests alongside the existing 20).
• The 3D Drum Highway and 3D Keys Highway are now bundled core plugins (plugins/drum_highway_3d/, plugins/keys_highway_3d/), imported from their former standalone repos (feedBack-plugin-drum-highway-3d, feedBack-plugin-keys-highway-3d, now archived) via git subtree so their history is preserved. They join the other in-tree plugins-as-plugins: the loader treats them identically to user-installed ones, both are marked "bundled": true in their manifests, and .gitignore gains the matching !plugins/<id>/ exceptions. This puts all three 3D highways (guitar, drums, keys) in one repo ahead of a visual-parity pass that ports the guitar highway's polish (bloom, sparks, themes, reactive backgrounds) to the other two — shared helper code and theme tables can now be reviewed and kept in sync in a single place. The keys plugin's existing node test suite is wired into CI (the JS test step gains a plugins/*/tests/*.test.js glob, +20 tests), and static/tailwind.min.css is regenerated since the core Tailwind build scans plugins/**. One deliberate behavior change ships with the bundling: the drum highway's Auto-mode predicate is narrowed (it used to claim any pack with has_drum_tab — a pack-level flag — which, now that the plugin ships to everyone and sorts before highway_3d in first-match-wins Auto order, would have stolen full-band packs from the guitar highway even on Lead/Bass arrangements; it now claims only drum arrangements, or packs nothing more specific can render). Picking the drum highway manually from the viz picker is unchanged.
• The tuner now tracks what tuning your instrument is actually in, so it prompts you to retune in BOTH directions — down to a song's tuning, and back up when the next song needs it. The coverage check used to compare each song against your fixed instrument-profile tuning, so it only ever prompted you away from "home" (e.g. E → Drop C#) and stayed silent coming back (Drop C# → E), even though you'd physically retuned. It now reads the host's live per-instrument working tuning (window.feedBack.workingTuning) — what your selected instrument is currently in — so coverage is measured against your actual tuning and fires both ways. When you clear an auto-opened tuner, the tuner publishes that song's tuning as your instrument's live working tuning (assumed — an explicit "I tuned / Skip" refines it in a later PR), so the next song is judged against where you now are. Per-instrument — your guitar's and bass's tunings are tracked separately (keyed like the selector), so switching instruments uses the right one. Feature-detected: on a host without the working-tuning capability it falls back to the static /api/settings tuning (today's behavior). plugins/tuner/screen.js (_playerTuning reads workingTuning keyed by the selected instrument; _publishWorkingTuning writes on clear). Builds on the host workingTuning foundation (PR 1 of the series) + the instrument→chart routing (PR 2). Tests: tests/js/tuner_auto_open.test.js (both-directions coverage via a live Drop-D working tuning; publish-on-clear targets the right instrument slot) — 29 pass.
• .jsonc support for feedpak data files (feedpak-spec §8, FEP #3 / PR #13). Hand-edited packs may now use the .jsonc extension (JSON with C-style // line and /* */ block comments) for any data file the manifest points at — arrangements, notation sidecars, drum_tab, song_timeline, lyrics, and keys. New shared lib/jsonc.py provides parse_jsonc(text) + load_json(path) (auto-detects .jsonc by suffix, string-aware so comment-like text inside JSON string values is preserved) and is now used by every reader in lib/sloppak.py (six side-file sites) and scripts/lift_keys_notation.py (three arrangement / song_timeline read sites). The strip regex mirrors the reference validator in feedpak-spec/tools/validate.py. This is an additive (MINOR) change: .jsonc is opt-in, so any pack that keeps its data files as .json is unaffected and needs no regeneration. Note that a .jsonc file containing real comments only loads on a reader that implements §8 — a pre-this-change reader calls bare json.loads and fails on the comments rather than ignoring them, so don't hand out .jsonc packs to older hosts. Tests: tests/test_sloppak_jsonc_load.py (covers all six side-file types, the lift helper, and the string-boundary preservation rule end-to-end).
• The highway now loads the part that matches your selected instrument — a bass player gets the Bass arrangement, not the default Lead/guitar chart. When you open a song without an explicit arrangement, the WebSocket handler (server.py highway_ws) reads your selected instrument from config.json (the same file it already reads for your default-arrangement preference) and routes to the matching part: bass → the Bass arrangement; guitar — and any unknown/future instrument (drums, keys) — falls through to the existing preference/most-notes default, which already lands on a guitar part. Previously the instrument selector only fed the tuner, so a bass player was handed a guitar chart (and a tune/coverage check then compared a 4-string bass against a 6-string part). An explicit arrangement request always wins (a manual arrangement switch is untouched), and a bass player's saved default-arrangement preference is still honored within the bass parts (so a preferred Bass 2 / Alt. Bass wins over the canonical Bass), so this only changes the default part chosen on load. Server-only — every launch path already flows through the WS, so there's no client change. This is the instrument↔chart-routing piece the working-tuning series leans on (otherwise coverage compares across instruments). Tests: tests/test_highway_ws_instrument_routing.py (bass→Bass, bass-honors-pref, bass-no-bass-part→guitar, guitar→default, explicit-wins).
• Host "working tuning" — a live, app-wide record of what tuning your instrument is actually in right now (foundation; no behavior change yet). Introduces window.feedBack.workingTuning, a host-owned, session-lived state distinct from any one song's tuning and from a soft opt-in default: the offsets + string-count + reference pitch the player's instrument is currently in, plus an assumed/verified provenance flag. It's per-instrument — your guitar's current tuning and your bass's are kept separately (keyed like the instrument selector, e.g. guitar-6 / bass-4), so switching instruments surfaces that instrument's own remembered tuning and you only ever deal with the one you've selected. It exists so a retune — or an instrument swap mid-session — is reflected everywhere (the highway, the library/song-picker, and plugins like the tuner, Virtuoso, and the minigames) instead of being re-derived per surface or wrongly assumed from a fixed profile. Modeled on the shipped tuning capability + the feedBack.theme read-API: a synchronous get(instrument?) (returns the selected instrument's state, defaulting to the seed until known), a set(state, {provenance, instrument}) mutator (the tuner becomes the sole writer in the next change), setCurrentInstrument() for the selector, resetToDefault(), and a working-tuning-changed event that fires on every change and once on hydration (carrying which instrument changed) so a late-mounting consumer is never stuck on stale state. State is in-memory, seeded from /api/settings on boot and reset on restart — a stale "you're in drop-A" assumption is worse than re-asking. Registered as a separate working-tuning exclusive-owner capability (tuner = writer, the rest = requesters). This is the foundation (plumbing only — nothing writes to it yet) of the working-tuning series, which fixes the tuner gate only ever prompting away from a fixed "home" tuning (never back) and makes the current tuning a first-class signal the whole app shares. Offsets use the same per-string semitone vocabulary as song tunings, so fully custom/extended tunings (e.g. a drop-A 8-string) are first-class. Frontend-only: new static/capabilities/working-tuning.js, loaded from static/index.html + static/v3/index.html.
• The v3 Songs grid is now DOM-virtualized — card-node count stays bounded no matter how big the library is or how far you scroll. The grid used to append every scrolled page and never let go, so a 2000-song library grew the DOM from 24 → 624 → 2001 card nodes as you scrolled (layout/memory cost scaling with depth). It now renders only the visible window of cards (± a small overscan); a sizer element sized to the whole library (ceil(total/cols) × rowH) gives the scrollbar its full geometry while the grid is absolutely positioned to the first visible row. state.songs is a sparse, absolutely-indexed store fetched a page at a time on demand — using the stage-1 keyset cursor for contiguous forward scroll (O(page)) and falling back to OFFSET page= for jumps/restore/non-keyset providers (collections, remote). Verified bounded (~60 nodes for a 2001-song library while the count still reads "2001 songs"). The A–Z rail now seeks directly: sort_letters gives a letter's first-row index (cumulative of prior buckets), converted to a scrollTop in O(1) — no more paging through every intervening row (a bounded forward scan covers the rare legacy provider without sort_letters). Select-mode selections, accuracy badges, the ⋮ card menu, plugin card actions, scroll-restore (now scrollTop-based, since geometry is stable), and the tree/folder views all survive cards leaving and re-entering the DOM. Plugins that decorate cards get a stable window.v3Songs.visibleCards() accessor + a v3:library-window-rendered event instead of assuming every card is present (the highway-stutter lesson). Stage 2 of the virtualized-grid project (got-feedback/feedBack#636 item 3), building on the stage-1 keyset data layer below. Frontend-only: static/v3/songs.js, static/v3/v3.css. Tests: tests/browser/v3-grid-virtualization.spec.ts (bounded-DOM invariant across a 2001-song scroll + direct rail jump), updated tests/js/v3_az_rail.test.js + tests/js/v3_songs_scroll.test.js.
• Keyset (cursor) pagination for the library grid — the data layer for an upcoming virtualized grid, and a latent paging bug fixed along the way. Every library sort now carries a unique filename tiebreak, making the order total — which fixes a latent bug where rows sharing a sort key (e.g. two songs by the same artist) could be skipped or duplicated across OFFSET pages. GET /api/library gains an opaque after cursor + a next_cursor in the response: passing the cursor back fetches the next page with a WHERE-seek instead of OFFSET, so deep paging is O(page) regardless of depth. The seek is NULL-aware and exactly OFFSET-equivalent (verified across artist/title/recent, ascending + descending, including the legacy dir=desc shape and NULL sort keys); unknown/compound sorts and bad cursors fall back to OFFSET, and only the local provider is handed a cursor (collections/remote page by OFFSET). New composite (artist NOCASE, filename) / (title NOCASE, filename) / (mtime, filename) indexes cover the order. This is stage 1 of the virtualized-grid project (got-feedback/feedBack#636 item 3); the DOM-recycling render window builds on it next. Tests: tests/test_library_keyset.py (keyset==OFFSET parity, stable tiebreak, dir=desc, NULL keys, cursor fallback).
• Smart collections — save a set of library filters as a live, auto-updating source. A collection is a saved /api/library query (e.g. "Drop-D tunings", "sloppak only", "recently added") that stays live: it's registered as a library provider, so it shows up in the v3 Songs source picker and inherits the whole grid UI — paging, stats, the A–Z rail, art — for free, with no new screen. Storage reuses the playlist subsystem (a playlists.rules JSON blob = a smart collection; membership is the live filter result, not stored songs, and collections are excluded from the manual-playlist list + read-only to playlist mutations). New GET/POST/PUT/DELETE /api/collections; a per-collection SmartCollectionProvider delegates query_page/query_stats/query_artists to the local DB with the stored rules applied; providers are re-registered from a boot scan so collections survive a restart. Rules mirror the raw /api/library query params (unknown keys dropped, never 500). Frontend: a "＋ Save as collection" action in the v3 filter drawer (shown when filters are active) names the current filter set and switches to it. The charrette's "the homelab primitive FeedBack was missing" pick (got-feedback/feedBack#636 item 2); richer rule fields (accuracy, genre, difficulty) follow as the metadata work lands. Tests: tests/test_collections_api.py, tests/js/v3_collections.test.js.
• The settings backup now includes your library database + custom art — your scores, favorites, playlists, and play history are no longer the one thing a backup can't save. GET /api/settings/export gains an additive core_server_files section carrying a consistent snapshot of web_library.db (taken via the SQLite online-backup API, so it's a complete single file even while the server is running) plus any custom playlist covers and avatar (CONFIG_DIR/playlist_covers/, CONFIG_DIR/avatars/). On POST /api/settings/import the database is staged to web_library.db.restore rather than written over the live, open DB; it's swapped in at the next startup (_apply_pending_db_restore, before the connection opens), which also clears the old WAL sidecars so a stale -wal can't be replayed onto the restored file — the import response sets restart_required: true and warns accordingly. Custom art is written immediately. The bundle stays backward-compatible (older servers ignore the new section). Came out of the library design charrette (dev-ops lens's top "protect irreplaceable data" pick, got-feedback/feedBack#636). Known gap: custom uploaded song art is still commingled with the rebuildable thumbnail cache in art_cache/, so it isn't bundled yet (a tracked follow-up). Tests: tests/test_settings_export_library_db.py (snapshot consistency, staged-not-live restore, sidecar clearing, traversal rejection, full round-trip).
• A persisted wishlist — keep a list of songs you want but don't own yet. New wanted table + GET/POST/DELETE /api/wanted give FeedBack the *arr-style "Wanted/Monitored" primitive it was missing: an entry is a not-owned song (artist/title/source/source_ref/note), so it lives in its own table rather than the playlist subsystem (which references owned local files). The API is idempotent on identity (case-insensitive artist+title, plus source+source_ref), so a producer — the find_more ownership-diff, or a manual add — can re-post without duplicating. Newest-first. Backend primitive for the charrette's wishlist finding (got-feedback/feedBack#636 item 4); the consuming UI lives in the producing plugin. Tests: tests/test_wanted_api.py.
• Practice-aware library home — a "Repertoire" meter + a "Keep practicing" shelf on the v3 Songs page. The library opened cold into a flat sorted grid; now the unfiltered grid front door leads with two practice-aware surfaces built entirely from data already on hand (no new endpoints or stored state). A Repertoire meter shows how much of your library you can actually play — "Repertoire: 12 of 80 songs · 7 in progress" with a progress bar — counting songs at or above the same mastery threshold the green accuracy badge uses (≥ 90% best accuracy) over the unfiltered library total. A "Keep practicing" shelf is a horizontal row of your recently-played-but-not-yet-mastered songs (newest first, click to play) — the practice-accuracy-driven "continue" rail a media server can't do. Both reuse /api/stats/best (already loaded for the card badges) + /api/stats/recent; they show only on the grid view when you aren't searching/filtering/selecting, refresh after a song is scored, and collapse to nothing on an empty library. Soft-gamification only — descriptive encouragement (goal-gradient / endowed-progress), never content-gating, decay, or nagging. Frontend-only: static/v3/songs.js (renderLibraryHome/_repertoireCounts), static/v3/v3.css. Came out of the library design charrette (the UX + gamification lenses' top pick). Tests: tests/js/v3_keep_practicing.test.js.
• A–Z fast-scroll rail on the v3 Songs grid. A vertical letter rail (Plex/Radarr/iOS-contacts pattern) pinned to the right edge next to the scrollbar lets you jump the library to a starting letter — tap a letter, drag to scrub with a live letter bubble, or arrow-key between letters. It shows only for the grid view + alphabetical (artist/title) sorts, and only offers letters actually present in the current sort and filter set, so a tap always lands on a real card (absent letters are dimmed + non-interactive). Because the grid is forward-only, server-paged infinite scroll, a jump pages through to the target card and scrolls to it (a newer jump supersedes an in-flight one); a keyset-seek + virtualized window is the noted scaling follow-up for very large libraries. Backend: /api/library/stats now accepts sort and returns an additive sort_letters map (songs-per-first-letter of the active sort column — artist or title), filter-synced; the legacy letters (distinct-artist) field is unchanged for the dashboard + classic tree. Frontend: static/v3/songs.js (refreshRail/jumpToLetter, cards tagged with data-letter), static/v3/v3.css (.v3-azrail). The classic (v2) tree already had letter selection; this brings the new grid to parity. Tests: tests/test_library_filters.py (sort_letters artist/title + song-vs-artist counting), tests/test_library_providers.py (sort forwarded to providers), tests/js/v3_az_rail.test.js.
• Playlists get content-dependent covers + custom art. Playlist cards were a tiny 🎵 emoji on an empty square. Now a playlist's cover reflects its contents: empty → the icon, a few songs → the first song's album art, 4+ songs → a 2×2 art mosaic. You can also upload a custom cover (a "Cover" button in the playlist detail view → image picker; "Remove cover" reverts to the content view). MetadataDB.list_playlists() now returns each playlist's first few song art_urls; GET /api/playlists and GET /api/playlists/{id} add cover_url when a custom cover exists. New routes POST / GET / DELETE /api/playlists/{id}/cover store a small PNG thumbnail under CONFIG_DIR/playlist_covers/ (PIL-converted, like song-art upload); the cover is removed with the playlist. Frontend: playlistCoverHtml(p) in static/v3/playlists.js. Tests: tests/test_playlists_api.py (art_urls + cover roundtrip / reject-non-image / delete-cleanup), tests/js/v3_playlist_cover.test.js.
• v3 Songs: "Add to playlist" is now on each song's ⋮ "More" menu. Previously a song could only be added to a playlist through select-mode (the checkbox → batch bar). The per-card overflow menu now has an Add to playlist row that targets that one song, reusing the same picker (choose a listed number or type a new name to create it). The select-mode batch flow and the single-song menu now share one extracted addFilenamesToPlaylist(filenames) helper in static/v3/songs.js (both grid and tree rows, since they share openCardMenu). Tests: tests/js/v3_add_to_playlist_menu.test.js.
• Resume where you left off — leaving a song now snapshots your place so an exit is recoverable, not a restart-from-zero. Exiting the player (showScreen() teardown, before audio unload) writes {song, arrangement, position, speed} to localStorage (feedBack.resumeSession), and a non-blocking "Resume practice" pill offers it back on the next non-player screen (and on the next app launch). Clicking Resume re-enters the song, restores the arrangement + playback speed, and seeks to the saved position via the existing _audioSeek funnel; playSong() gains a { resume: {position, speed} } option that arms a song:ready-consumed restore instead of the normal autostart, so the two never fight over playback. The snapshot is deliberately conservative — ignored for a song you barely started (< 3s) or had basically finished (within 5s of the end), cleared on natural song-end and once consumed, and expired after 24h. The pill is self-contained (inline-styled, body-appended, works identically in the classic and v3 shells with no Tailwind rebuild), never blocks, and a dismiss forgets the current snapshot for the session. This pairs with the Escape focus fix: now that Escape reliably leaves regardless of focus, an accidental exit is one tap to undo. Public surface: window.resumeLastSession() / window.feedBack.resumeLastSession. (The broader nav-state work — returning to a song after wandering into Settings → Tone Builder — is a separate, larger track; this lands the player-session slice.) Tests: tests/browser/resume-session.spec.ts (snapshot guards, staleness, pill show/hide/dismiss, resume consumption).
• Optional "Ask before leaving a song" confirm (Gameplay tab, default OFF). A new client-only toggle (confirmExitSong in localStorage, in the v3 Gameplay settings + the Gameplay "Reset" set) for players who want a guard against an accidental exit. Off by default — Escape leaves instantly, zero change for everyone else. When on, a user-initiated exit (the player-scope Escape shortcut, or the player's ✕) opens a small true-modal confirm instead of leaving; auto-exit on song-end and a results screen's own Close are unaffected (they call closeCurrentSong() directly, which stays the unguarded actual-exit). The confirm honors the team's refined asks: opening it pauses the song (so it isn't running or being scored behind the prompt) and Stay resumes exactly what was paused; Escape = Stay — the dialog's capture-phase handler dismisses it (now consistent with every other modal and the generic _confirmDialog's Esc=cancel), so a second Escape returns you to the (resumed) song rather than leaving; Space/Enter (or click) Leave by natively activating the default-focused "Leave" button ("just get me out"). Pause/resume run through the canonical togglePlay() path (HTML5 + _juceMode), guarded so a count-in, an already-paused song, or a teardown/seek/end behind the modal can't mis-resume. It's a real modal (role="dialog" aria-modal="true" / .feedBack-modal) with Tab trapped inside it and a backdrop click that also Stays, so the Escape/Space focus carve-outs treat it as a trap and don't fire player-back / play-pause behind it. The player Escape shortcut and the v3 ✕ route through a shared window.requestExitSong() gate (the ✕ also becomes origin-aware, matching Escape). Tests: tests/browser/exit-confirm.spec.ts (default-off instant exit, confirm-on opens + stays, second-Escape stays, backdrop stays, Stay/Leave, Enter-leaves); the audio pause/resume is verified manually on web + desktop (the mock song has no backing track).
• Folder Library — a bundled core plugin (plugins/folder_library/) that browses the DLC library by its on-disk folder tree. Surfaces top-level folders → subfolders → songs (root-level songs land in (Unsorted)), with in-app folder management (create / rename / delete nested folders), song moves via dialog or drag-and-drop, and sort/filter that mirrors the host library's filter state. Wired into both the classic (v2) library toolbar and the v3 Songs page as a third Folders view alongside grid/tree; the plugin's screen.js is loaded once by the host and reused (idempotent IIFEs). Supersedes the former standalone "Folder Organizer" community plugin (removed from the README list). Backend (routes.py) registers /api/plugins/folder_library/{tree,folder/create,folder/rename,folder/delete,song/move}; all filesystem mutations are confined to DLC_DIR and validated against path traversal (per-segment name validation plus a resolved-containment check on song/move), and folder deletion relocates every song — de-duplicating colliding names — so a name clash never destroys a song. A two-level cache keeps re-opening folders fast. Tests: tests/plugins/folder_library/test_routes.py (path-safety helpers + move-traversal and delete-no-data-loss end-to-end).
• Full-screen (immersive) plugin screens — opt-in via "fullscreen": true in plugin.json. DAW-style plugin UIs (e.g. a practice studio) need the whole viewport, not a scrolling content page below the topbar — embedded in the v3 shell they get cut off at the bottom with dead space up top. A plugin can now declare a top-level "fullscreen": true; plugins/__init__.py surfaces it as the fullscreen boolean on /api/plugins (mirroring the settings_category plumbing). When such a plugin's screen is active, static/v3/shell.js toggles html.fb-immersive from syncActive() (so it tracks every navigation incl. deep-link), and static/v3/v3.css hides the topbar, collapses the sidebar to a functional icon rail (kept reachable — Escape is bound only on player/settings scopes, so a fully-hidden sidebar would trap the user), and lets the active plugin screen fill #v3-main. Mirrors the existing ss-follower-pre chrome-hide pattern. Additive + opt-in: plugins without the flag are unaffected. Tests: tests/test_plugins.py::test_fullscreen_flag_parsed_from_manifest.
• Achievements wall sync — background drain worker (epic PR3, client side). The bundled achievements plugin gains a dead-letter sync worker that POSTs queued Feat unlocks (and removals) to the hosted feedback-achievements wall service (separate repo). Idle unless a wall URL is configured (FEEDBACK_ACHIEVEMENTS_WALL_URL); uses requests with the baked-in client-token header, mirroring lib/lyrics_transcribe's outbound pattern (explicit timeout, no raise on non-2xx). Dead-letter, never drop (pure engine.drain_decision): network error / 429 / 5xx → keep pending (retry); other 4xx → dead_letter (diagnosable, replayable); 2xx → delete on server ack. A row leaves the queue only on ack or a user opt-out. remove-me now enqueues a wall removal keyed by the reused player_hash. Verified by an end-to-end staging round-trip (earn a Feat → drains onto the wall with name + short hash → remove-me → wall empties) with no IP in tables or access logs. Tests: tests/plugins/achievements/test_sync.py (decision table + ack/retry/dead-letter retention + four-field payload on the wire). The hosted service itself (FastAPI + SQLite-on-disk, Feats-only, hidden-until-first-global-unlock, profanity filter, in-memory rate limit, Render blueprint, migration tool) lives in the new feedback-achievements repo.
• Achievements wall — opt-in, privacy controls & data-minimization gate (epic PR2). Sharing earned Feats on the (forthcoming) public wall is strictly opt-in. A new onboarding step (static/v3/profile.js, inserted after song-directory / before instrument paths — the wizard is now five steps) presents a plain-language card: it publishes only your display name and the Feats you earn, never songs/skills/scores, and is off by default. The bundled plugin's Settings panel (plugins/achievements/settings.html, mounted under the System tab via settings.category) carries the same toggle plus a "Remove me from the wall" button (POST /api/plugins/achievements/remove-me — wipes local synced state offline + enqueues a wall removal). Core adds achievements_enabled (bool, default false) to _default_settings() + the /api/settings validation block + _RESETTABLE_SETTINGS_KEYS in server.py, mirrored to localStorage in app.js loadSettings(). Data-minimization contract (binding, code-enforced): every outbound payload is built by a single explicit-dict serializer (engine.build_wall_payload, never dict(row)/**model) whose key-set is exactly {display_name, player_hash, achievement_id, unlocked_at} with achievement_id always a Feat id — a unit test asserts the four-field set and goes red on a fifth. Enqueue is doubly gated: it happens only when opted-in and a profile identity (name + the reused player_hash) exists; competency unlocks never enqueue (integration law). Tests: tests/plugins/achievements/test_datamin.py (key-set, opt-out/identity/competency gating) + tests/test_settings_api.py (flag persists/validates/resettable).
• Achievements & Feats of Power — local engine + tabbed Profile (epic PR1). The Profile screen (static/v3/profile.js) becomes tabbed exactly like the v3 Settings page (.fb-tabbar / .fb-tab[data-tab] / .fb-tabpanel[data-tab], active-tab persisted in localStorage 'v3-profile-tab'): a Profile (main) tab carrying the existing header + best-scores cards plus a new Feats of Power trophy shelf mount (#v3-profile-feats-slot, earned-only / hidden-until-earned), and an Achievements tab with a plugin mount (#v3-profile-achievements-mount) + [data-empty-for] empty note. Core dispatches a new v3:profile-rendered event after every render (mirrors v3:settings-rendered) so the plugin re-injects on each profile entry. A new bundled plugins/achievements/ plugin owns the engine: SQLite under <config_dir>/achievements/achievements.db (unlocks / counters / comp_ledger / sync_queue), pure threshold/criterion math in the testable sibling engine.py (P-V), and routes under /api/plugins/achievements/ (activity, report-unlock, report-criterion, catalog, earned, feats, remove-me). Two surfaces, one engine, structurally separated (integration law): Feats (activity/volume — Note Hunter, Marathon, Untouchable, Road Warrior, Time Served, Encore, two 🥚 secrets) read activity counters only, evaluated from a batched song:ended activity POST (notes only when notedetect is present — graceful degradation, no fake progress); competency Achievements (baseline: First Steps / Ascendant / Steady Hands / Renaissance + per-instrument Apprentice·Journeyman·Master / Personal Best / Challenger) are evaluated from progression events only and never re-derived from activity. The Achievements catalogue is always shown (locked = greyed), grouped by a secondary pill row over the real progression paths (Global / Guitar / Bass / Drums / Keys — auto-extends to new paths) with a per-category "X / Y earned" badge, defaulting to the player's primary path. Source plugins contribute their own competency defs and report unlocks through a versioned window.feedBack.achievements API (register/registerAll/unlock/progress), load-order-safe via the window.__feedBackAchievementsPending queue + an achievements:ready event (minigames pending-queue pattern); an absent source contributes nothing (no dead greyed rows). Opt-in publishing to a hosted Feats wall, the Settings privacy toggle, and the data-minimization gate land in epic PR2/PR3. Tests: tests/plugins/achievements/test_engine.py + test_routes.py (incl. the integration-law assertion that a competency unlock never reaches the Feats shelf).
• v3 settings page redesigned as a tabbed, card-row layout. The single long scrolling settings screen becomes a horizontal tab bar (Gameplay / Audio / Graphics / Keybinds / Progression / Mic / Plugins / System) over card rows — each a leading icon + title + description with the control (toggle/dropdown/slider) on the right, plus a per-category "Reset" action. The markup lives in static/v3/index.html (so existing element ids keep hydrating through the unchanged app.js loadSettings()/persistSetting() path); a new static/v3/settings.js owns tab switching + active-tab persistence (localStorage 'v3-settings-tab'), the per-category reset, and a read-only Keybinds reference built from the live shortcut registry (window.getAllShortcuts()); styling is plain CSS in static/v3/v3.css (no Tailwind rebuild). Plugins choose their settings tab via a new optional settings.category field in plugin.json (plugins/__init__.py surfaces it as settings_category; app.js mounts each plugin's <details> panel into #plugin-settings-<category>, falling back to the generic Plugins tab) — highway_3d ships category: "graphics"; the out-of-repo notedetect/progression plugins should declare "mic" / "progression". New gameplay settings: Countdown before song (a four-beat count-in before playback, wired end-to-end via the existing count-in engine + the song-start autostart path; key countdown_before_song, default off); Miss penalty (miss_penalty) and Fail behavior (fail_behavior) are persisted now but not yet consumed by scoring (shown with a "Not yet active" badge). "Note highway speed" surfaces the existing master_difficulty and stays in sync with the player-popover difficulty slider. New POST /api/settings/reset clears chosen keys back to defaults. Tests: tests/test_settings_api.py (new keys + reset), tests/test_plugins.py::test_settings_category_parsed_from_manifest, tests/browser/settings-tabbed.spec.ts.
• Full-mix audio exposed alongside stems for the stem mixer's auto-switch. lib/sloppak.py::load_song now parses the optional manifest original_audio: key (the single pre-separation mixdown, e.g. original/full.ogg) into a new LoadedSloppak.original_audio field, with the same path-traversal guard and permissive "missing → disabled" posture as the drum_tab loader. The highway WS song_info frame additively carries three new fields next to stems: original_audio_url (served by the existing /api/sloppak/{filename}/file/{rel_path} endpoint, None when the pack ships stems only), has_original_audio, and has_stems (mirroring the has_drum_tab/has_keys flag convention). The stems plugin consumes original_audio_url to play the untouched single file while every stem slider is at unity and switch to the separate stems the moment one drops below 100%. Migration notes: the song_info message shape is a stable contract — these are purely additive; all existing fields are unchanged. audio_url still points at stem[0] when stems exist (it is only the degraded native fallback); the one behavioural change is that a stem-less, full-mix-only sloppak now sets audio_url to the full mix instead of emitting audio_error, so it plays natively.
• Autoplay & auto-exit — a global "click it, it plays; finish, you're back at the menu" option (default ON). New single Settings toggle (autoplayExit in localStorage, surfaced in both the v3 and classic settings screens; absence of the key = enabled) that closes the friction at both ends of the play loop. Autoplay: playSong() previously loaded a chart paused, requiring a Play press; a one-shot flag armed per fresh load is now consumed by the next song:ready (highway.js) to auto-start via the existing togglePlay() path (HTML5 + _juceMode + count-in). Arrangement switches / seeks reuse the same song:ready event but never arm the flag, so they don't auto-restart. Auto-exit: on song:ended, core returns to the launching menu after a short grace delay — unless a visible full-screen results/dialog overlay is on top (detected via [role=dialog][aria-modal] / .fixed.inset-0 with a getClientRects() visibility test that works for position:fixed), in which case the return is deferred so that score screen's own Close button (calling window.closeCurrentSong()) drives the exit. A plugin can also defer explicitly via the new window.feedBack.holdAutoExit() (called synchronously from its own song:ended handler — core's listener runs first). Both paths mean no external plugin PR is required for a results screen to be respected. Context-aware destination: the player's remembered origin (_playerOriginScreen) now honours any real launch screen instead of clamping to library/home/favorites, and a one-shot window.feedBack.setReturnScreen(id) override lets the lessons catalog (static/v3/lessons.js) send a finished lesson back to the lessons screen — not the song library — even though the external tutorials plugin owns the playSong call. Also exposes a read-only window.feedBack.autoplayExit getter for plugins. Songs and lessons share the same playSong → highway path, so both inherit the behaviour. Core-only (static/app.js, static/v3/lessons.js, both index.htmls); the end-of-song score screen itself remains a plugin. Optional polish (not required — the overlay heuristic already covers it): external scoring/note-detection plugins (e.g. SlopScale) may call holdAutoExit() + closeCurrentSong() for an exact, heuristic-free handoff.
• "Song Editor" promoted to a first-class v3 sidebar item. The editor plugin (id: editor) now gets its own dedicated sidebar entry — under the Library group, just below Songs — via the existing PROMOTED_PLUGINS mechanism in static/v3/shell.js, instead of being reachable only through the generic Plugins gallery. Gated on the plugin actually being installed (renderPromotedNav checks /api/plugins), so it appears only when the editor is loaded. The displayed label comes from the plugin's manifest nav.label.
• Guitar Pro → notation importer (lib/gp2notation.py) (feedBack#825 WS4b, epic #828). Piano/keys tracks imported from Guitar Pro (GPIF: .gpx GP6 / .gp GP7-8) now produce real Sloppak Notation Format data (sloppak-spec §5.3) alongside the midi = string*24 + fret guitar wire encoding. gp2rs_gpx.convert_file writes a <stem>.notation.json sidecar next to each keys arrangement XML (best-effort — a notation bug never breaks the RS-XML conversion), and gp2notation.attach_notation_to_sloppak() is the assembly-side helper that renames it into notation_<id>.json + adds the per-arrangement notation: manifest sub-key. Voice→staff routing salvages the logic from PR #703 (whose stf wire-field approach this supersedes): GP voice position 0 → rh staff (G2), positions ≥ 1 → lh (F4); a forced-LH track (the merged Piano LH partner from _find_piano_pairs, or a standalone track named … LH) routes everything to lh — preserving authored hand crossings instead of inferring hands from pitch. Emits measures with absolute t from the bar-indexed tempo map, change-only ts/tempo/ks, and beat_groups for compound/irregular meters (6/8 → [3,3], 9/8 → [3,3,3], 5/8 → [2,3], 7/8 → [2,2,3] — cf. the feedBack#261 denominator pitfalls); beats carry dur/dot/tu/rest from GP rhythms and notes carry absolute midi (String+Fret resolves via the string template's concert pitches, Tone+Octave via (octave+1)*12 + step) with tied continuations kept as real beats (engraving needs the tied notehead — unlike the RS-XML walk, which drops them and extends sustain). Timing reuses the gp2rs_gpx machinery (bar-indexed tempo map, per-beat rhythm durations, _note_midi) so notation lines up with the RS XML the highway plays — with one deliberate divergence: double dots advance time ×1.75 (vs. the RS-XML walk's single-dot ×1.5 approximation) so a written dot: 2 agrees with the emitted beat times; sharing the walk itself stays tracked in feedBack#618. Tests: tests/test_gp2notation.py.
• Legacy keys → notation lifter (scripts/lift_keys_notation.py) (feedBack#825 WS4c, epic #828). One-time batch converter that lifts existing directory-form piano/keys sloppaks from the legacy guitar wire encoding (midi = s*24 + f) into real Sloppak Notation Format files (sloppak-spec §5.3). Candidates are arrangements whose name matches \b(keys|piano|keyboard|synth)\b (case-insensitive); each gets a notation_<id>.json plus the per-arrangement notation: manifest sub-key. Measures derive from the song-level beats downbeats (measure >= 0; song_timeline.json preferred, first-arrangement fallback), with per-measure tempo from downbeat spacing (emitted only on a > 1 BPM change). Durations come from the wire sustain (sus, legacy l alias) when present, else the gap to the next onset in the same hand — quantized to the nearest plain/single-dotted {1,2,4,8,16,32} denominator at the local tempo, floored at a 32nd. Hands are split heuristically: onsets within 10 ms form a group; a group spanning > 12 semitones splits at its largest internal interval gap (low side → lh), otherwise the whole group goes by mean pitch vs middle C — single-staff output when everything lands on one hand. Idempotent (arrangements already carrying notation: are skipped; an orphan notation_<id>.json without the manifest key is refused, not overwritten) with --dry-run support; every payload is checked via notation.validate_notation before write. Honest caveat: the manifest is round-tripped through PyYAML (safe_load + safe_dump(sort_keys=False)) — key order survives, YAML comments/custom formatting do not (the script warns when comments are present). Zip-form .sloppak files are reported and skipped. Tests: tests/test_lift_keys_notation.py.
• Notation schema v1 freeze — completeness batch (feedBack#822, epic #828). Adds the low-hanging-fruit fields ahead of content production: top-level credits rights/lyricist/arranger; measure pickup (anacrusis); beat arp (arpeggiate), ferm (fermata), and typed grace notes — grace: "a" (acciaccatura, MusicXML grace/@slash=yes) / "p" (appoggiatura); note stem ("up"/"down" force). Pedal is settled as the existing spd/sph/spu trio with a documented MusicXML <pedal start|change|stop> mapping — no separate ped field. A new "v1 non-features" spec subsection pins the accepted limitations (microtonal, figured bass, mid-measure key/time/clef changes, ott/barline/ornaments/trem/glis) as additive-v1.x territory. lib/notation.py gains the GRACE_TYPES, STEM_DIRECTIONS, and DYNAMICS vocabularies; the validator stays permissive by design.
• Notation format — standard musical notation as a first-class sloppak type. Promotes keys, piano, violin, and any other staff-notation instrument out of the guitar wire format and into their own data structure, following the same promotion path used for drums (feedBack#344). New lib/notation.py defines the canonical vocabulary (CLEFS, DURATIONS, SCHEMA_VERSION), a permissive validate_notation() check, and measures_to_wire() / measure_to_wire() wire helpers. lib/sloppak.py::load_song reads a new per-arrangement notation: sub-key from each arrangement entry in the manifest (Option B: per-arrangement, not song-wide), applies path-traversal guards, validates the parsed JSON via validate_notation(), and surfaces all notation payloads on LoadedSloppak.notation_by_id (a dict[str, dict] keyed by arrangement id). A failed or missing notation file for one arrangement does not abort or skip the arrangement itself — partial-failure isolation mirrors the drum tab loader. file: is now optional when notation: is present: the loader creates a minimal stub arrangement so a notation-only arrangement entry does not require a guitar wire format JSON. /ws/highway/{filename} gains two new message types — notation_info (staves, instrument, total measure count) and chunked notation_measures (32 measures per chunk) — streamed after sections and before anchors; song_info carries a new has_notation: bool flag so viz pickers can auto-activate the notation plugin regardless of arrangement name. The notation file schema is measure-structured (measure → staff → voice → beat → note), uses MIDI for pitch (no string/fret/tuning indirection), and carries the full set of effects that alphaTab can render. See docs/sloppak-spec.md §5.3 for the full schema. Open questions resolved per the piano/keys epic (feedBack#828 / #822): Option B (per-arrangement notation: sub-key) and file:-optional-when-notation:-present are the endorsed design.
• song_timeline.json — beats and sections as a top-level file. A new optional top-level file pointed at by a new manifest key (song_timeline: song_timeline.json) provides the correct home for song-wide beats and sections, replacing the legacy convention of embedding them in the first arrangement JSON. The loader in lib/sloppak.py reads and validates the file (must be a dict with beats and sections as lists), clears and repopulates Song.beats / Song.sections from it when present, and stores the raw dict on LoadedSloppak.song_timeline. The existing arrangement-JSON fallback is fully preserved: all existing sloppaks that omit song_timeline: continue to load without any change. This is a prerequisite for notation-only sloppaks, which may have no arrangement JSON at all and therefore no carrier for beats/sections data. New sloppaks should put beats/sections in song_timeline.json only. See docs/sloppak-spec.md §2 and §5.3.
• note-detection capability domain promoted — control plane (spec 009) (feedBack#727/#728, epic #828). New core host static/capabilities/note-detection.js: provider registry (kinds midi/engine/js, primitives pitch.estimate/verify.target), requester-owned context-scoped detection bindings (open-binding/close-binding/set-target/clear-target — each binding carries its own redacted tuning context, independent of the host's loaded song, per spec-009 FR-003), and hit/miss/verdict observability events (consumers own judgment). The legacy chart-coupled highway.setNoteStateProvider surface keeps working and is wrapped for compatibility-shim hit accounting. Diagnostics (feedBack.note_detection_capability.v1) carry provider/binding summaries and bounded outcomes — no raw audio, device labels, or song identity. Migrating the chart path, Step Mode verify, minigames YIN, and the engine verifier onto bindings is the remainder of the spec-009 slice.
• visualization capability domain promoted (cap:6) (feedBack#828). New core host static/capabilities/visualization.js registers a provider-coordinator owning the highway renderer surface: commands inspect / list-providers / select-renderer / clear-renderer (selection delegates to the existing picker so persistence, WebGL2 gating, and fallback stay single-sourced), events providers-refreshed / renderer-changed / renderer-ready / renderer-failed. Legacy discovery (type: "visualization" manifests, window.feedBackViz_* globals) keeps working unchanged and is accounted as compatibility shims with hit counts. static/app.js attributes every renderer change (auto-match / user-select / fallback) and auto-match outcomes into the domain. Diagnostics (feedBack.visualization_capability.v1) carry provider ids/labels/context types, active renderer + selection source, last auto-match outcome, and last failure — no song filenames/titles. Per-panel (splitscreen) selection is a tracked follow-up.
• Viz picker routes notation arrangements (feedBack#826, epic #828). window.feedBack.currentSong gains hasNotation (sibling of hasDrumTab) from the song_info frame's has_notation flag, so notation viz plugins (Staff View, Keys Highway 3D) can gate matchesArrangement on data presence instead of arrangement-name heuristics. When a notation-only arrangement (no wire notes — file: omitted per sloppak-spec §5.3) falls through Auto with no notation plugin installed, the built-in highway still takes the canvas but the Auto label reads "no notation view installed" and a one-shot dismissable hint points at the visualization picker — never a silently blank board.
• Keys instrument path in progression (feedBack#828). New data/progression/paths/keys.json (5 levels / 15 challenges at parity with the guitar path) plus keys-flavoured daily/weekly quest pool entries (d.keys-one "Ivory Tower", w.keys-three "Grand Recital"). lib/progression.py::instrument_for_arrangement() now attributes type: piano|keys arrangements — and names matching keys/piano/keyboard/synth on a word boundary — to the new keys instrument, so scored keys runs advance the path automatically. Purely content + attribution: no schema or API changes.
• v3 library: exact artist/album filters + scroll/page-depth restore (feedBack#857). The v3 Songs toolbar gains Artist and Album dropdowns (Album populates from the selected artist and stays disabled until one is chosen), backed by new exact, case-insensitive (COLLATE NOCASE) artist / album query params threaded through MetadataDB._build_where → query_page / query_artists / query_stats and the /api/library, /api/library/artists, /api/library/stats endpoints (the free-text q search stays fuzzy and composes with the exact filters). The artist/album catalog is fetched independently of the active artist/album selection so the dropdowns always list the full set for the current provider/search. The toolbar is now sticky so filter controls stay reachable when browsing deep libraries, and returning from the player restores the previous scroll position and the loaded infinite-scroll page depth via a sessionStorage snapshot keyed by a filter/sort/view state hash (invalidated whenever those change, so a filter change still resets to the top). Tests: tests/test_library_filters.py (backend artist/album filters), tests/js/v3_songs_scroll.test.js (state-hash + snapshot helpers).

Fixed

• GP8 multi-staff (piano/keys) tracks now import both hands — the bass stave was being silently dropped, and hand-splits landed on the wrong hand. A GP8 grand-staff keyboard part is one <Track> with two <Staff> entries, and MasterBar/Bars lists one bar id per stave, not per track (lib/gp2rs_gpx.py). Two bugs fell out of assuming one stave per track: (1) the bar-column lookup used a raw enumerate(Tracks) index, so every track after a multi-stave track read the wrong column; (2) the string-tuning parse scanned all .//Property descendants and let the last stave's <Tuning> overwrite the first, so a treble note indexed against the 5-entry bass tuning fell out of range in _note_midi and was dropped without a trace. The importer now advances a bar-column counter by each track's stave count, reads tuning per stave (with a per-staff fall-back to the track-level property so an untuned staff never yields empty pitches), and folds every extra stave's notes into the arrangement (not just stave 1), keeping the note_count import-preview honest. A grand-staff track is now classified as keys end-to-end so the stave-0 and folded stave-1+ notes share one encoding. Separately, notation_lift.split_hands no longer forces a hard middle-C split when doing so produces a physically unplayable hand (e.g. a bass note under an Em7-shape voicing dipping below C4 would put a 19-semitone span in one hand) — it uses the middle-C boundary only when both resulting hands are within HAND_SPLIT_SPAN_SEMITONES, else falls back to the largest-gap heuristic. The GPX LH/RH pair merge and the GP8 stave fold now share one _collect_column_notes / _merge_lh_notes pair so the two formats can't drift in tie/timing/dedup handling. Companion editor change: got-feedback/feedBack-plugin-editor#38. Tests: tests/test_gp2notation.py (grand-staff fold + bar-column offset), tests/test_notation_lift.py (both middle-C split cases). Follow-up: lib/gp_autosync.py still carries the pre-fix bar-column + tuning logic (CLI/tests only, no production caller).
• Tuner auto-open is now opt-in and persists instead of flashing open-then-shut. When you entered a song (or switched arrangement) whose tuning differed from the last, the tuner auto-opened and — for some testers — vanished ~1s later (reported macOS+Windows, 0.3.0). Root cause: the tuner closes itself on song:play (plugins/tuner/utils/ui.js — you don't tune while playing), so a song switch fired autoplay → song:play → the just-auto-opened tuner closed; an arrangement switch (which never arms autoplay) had no song:play, so it stayed open — exactly why two testers saw opposite behaviour (it wasn't the mic). Now: (1) the feature is a new opt-in setting ("Auto-open on tuning change", in the tuner's Settings panel, persisted as autoOpenOnTuningChange, default OFF); (2) an auto-opened tuner persists — it ignores the autoplay song:play, stray outside-clicks, and same-screen re-emits, closing only via the new in-panel × / "Skip" buttons or when you leave the song. A manually opened tuner keeps its classic click-away / play-to-close behaviour. The panel previously had no in-box close at all; this adds one (× + contextual Skip). All in the tuner plugin (routes.py config, screen.js gate + persist, utils/ui.js buttons + song:play guard, settings.html toggle) — no core app.js changes. Tests: tests/js/tuner_auto_open.test.js (opt-in gate, { auto: true } persist mode, play/click-proofing). Default (opt-in vs opt-out) is teed up for Byron to decide — flip one boolean.
• Tuner auto-open is now tuning-coverage-aware — extended-range players aren't nagged for songs their instrument already covers. With the opt-in auto-open on, it now prompts only when your current physical tuning (from your instrument selection in Settings) doesn't already cover the song. FeedBack is tune-to-song — the highway draws tab in the song's tuning — so the check aligns the song's open-string tuning string-for-string against your instrument: an 8-string F♯-standard player gets no prompt for a 6- or 7-string standard song (its top strings already match those tunings), while a song needing an open string you don't have (e.g. a Drop-A 7-string, whose low A isn't an open string on an F♯ 8-string) still prompts. A whole-instrument reference difference also prompts — A440 vs A432, or an octave-down centOffset (which the auto-open now accounts for; it was previously ignored). The player's instrument is read from core /api/settings (the v3 instrument selector — a stable physical reference, not the tuner's song-tracking selection); when nothing's declared or the lookup is unavailable it falls back to a conservative prompt, so a real retune is never silently skipped. v3-only (the instrument selector is v3). All in the tuner plugin (plugins/tuner/screen.js) — no core changes. Tests: tests/js/tuner_auto_open.test.js (covered vs uncovered, the Drop-A case, reference-pitch mismatch, contiguous alignment). Follow-up (E1.6): a passive "different tuning" badge cue that names the string(s) to retune, plus the splitscreen / no-usable-input guards.
• The tuner badge now passively flags when a song needs a different tuning — and names the retune. Building on the coverage check: when you enter a song your current instrument doesn't cover, the topbar tuner badge gets an amber ring and a tooltip that names the change — e.g. "retune B→A" for a Drop-A song on an F♯ 8-string, or "the reference pitch" for an A440-vs-A432 mismatch. It's purely advisory (it never auto-opens the panel — tap the badge to tune), recomputed on song:ready and cleared when a new song loads or you leave the player. The retune diff comes from the tuner plugin's coverage report (window._tunerAutoOpen.coverageReport → { covered, retune: [{ from, to }], reference, cantCover }); the cue is CSS-free (an inline ring + native tooltip — no Tailwind rebuild) and no-ops when the tuner plugin isn't installed. v3-only. Touches static/v3/badges.js (the cue) + plugins/tuner/screen.js (the report). Tests: tests/js/tuner_auto_open.test.js (the report names the strings; reference mismatch; the badge wiring). (The splitscreen-suppress and no-usable-input guards move to the playback-gate stage, where they matter for its no-trap rule.)
• Tuner auto-open can now gate playback until you've tuned — the "tune before you play" model — via a new core holdAutoplay() hook. With the opt-in auto-open on, when a song needs a retune the tuner opens and playback waits for your choice — Skip (you've tuned → play, and record the song's tuning as your instrument's current working tuning), Back to library / Esc (leave the song; a gated retune is never a one-way trap), or press Play (always wins). For an auto-open the in-panel × is dropped — Skip / Back to library / Esc are its dismiss surface. Previously the song played with the tuner overlaid; now it holds — which also definitively kills the original flash, since autoplay's song:play can't fire while playback is held. Implemented as a small core hook window.feedBack.holdAutoplay() (mirrors the existing holdAutoExit()): a plugin claims it synchronously on song:loading (so it beats the song:ready autostart), and release() — or a 12-second fail-open backstop — runs the deferred start. Generation-guarded (a new song invalidates a stale hold) and fail-open (a wedged or crashed plugin can never permanently strand a song); manual Play always wins (it doesn't flow through the autostart path). The tuner claims the gate only when the feature is on, and releases it the instant it decides not to open (song already covered / tuning unchanged) or when you Skip. Touches core static/app.js (the hook + an autostart refactor) and the tuner plugin (plugins/tuner/screen.js — the claim/release; plugins/tuner/utils/ui.js — the Skip / Back-to-library buttons, × dropped on auto-open); the hook is generic and shell-agnostic (a test asserts app.js still doesn't reference the tuner's internals). Tests: tests/js/tuner_auto_open.test.js (claim on song:loading, release on dismiss, feature-off no-claim, the core hook + fail-open backstop, the Skip / Back-to-library / Esc escape-hatch) + a speed_reset.test.js stub. ⚠️ Needs a manual smoke-test before shipping — this is a core playback change; verify on desktop that the tuner mic doesn't contend with note_detect's scoring input (ASIO/exclusive mode), per the design charrette.
• v3 Songs List View: favoriting a song now turns the heart red immediately (no re-search needed). In the tree / "List View" (Songs → List → expand an artist), clicking the heart flipped the glyph ♡→♥ but it stayed dim grey until you re-searched the library — reported on macOS + Windows, open since 0.3.0 / 2026-06-25. One shared wireCards() [data-fav] handler (static/v3/songs.js) serves both the grid card and the List-View row, but the two 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 the row kept text-fb-textDim alongside the freshly-added text-fb-accent, and the dim class won by CSS source order (glyph changed, colour didn't). Each heart now declares its idle colour via a data-fav-idle attribute and the handler swaps exactly that class, so only one colour class is ever present; the handler also 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.
• v3 Songs A–Z rail: taps now land reliably, a drag releases exactly on the let-go letter, and the rail is large enough to hit on hi-res displays. Follow-up to the rail's debut (#634); three bugs reported on macOS + Windows (0.3.0, 2026-06-29): a tap often did nothing ("clicked O, nothing happened"), a drag "got you kind of there but where you release isn't where you get sent," and the rail was "way too small" at 1440p and didn't scale with resolution. Root causes & fixes, all in static/v3/songs.js + static/v3/v3.css (bindRailOnce/jumpToLetter/.v3-azrail): (1) taps — 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 → no-op. The jump is now driven from pointerdown itself (seek on press); the click handler is reduced to keyboard activation only (e.detail === 0, Enter/Space). (2) drag precision — every letter crossed fired jumpToLetter with behavior:'smooth'; stacked smooth-scroll animations over the virtualized grid lagged and settled short of the release. jumpToLetter(letter, smooth) now scrolls instantly while scrubbing ('auto') and only animates discrete taps/keyboard jumps, so the grid tracks the finger and the release lands on the let-go letter. (3) size — the letters were a fixed .62rem glued at right:2px (~13px-tall target on the screen edge); 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 + the present-letter gating are unchanged. Reported by =Scr4tch= and MajorMokoto. Tests: tests/js/v3_az_rail.test.js (pointerdown-seek, keyboard-only click guard, instant-vs-smooth scroll).
• v3 player: opening another rail popover now closes the Section Practice popover (no more two stacked popovers). Opening the Practice pill's popover and then clicking a different player-rail icon (e.g. Plugins) left the Practice popover open underneath the new one — looked broken (reported on macOS, 0.3.0 / 2026-06-28). The rail icons call e.stopPropagation() in their click handler (static/v3/player-chrome.js), which killed bubbling before it reached the Practice popover's outside-click dismiss bound on document. The dismiss (_installSectionPracticeDismiss in static/app.js) now binds in the capture phase, which runs before the target's handler so a descendant's stopPropagation() can't swallow it — mirroring how the audio-mixer popover already dismisses. Esc handling stays bubble-phase (the player's Escape-to-exit ordering is unchanged). v2 shares app.js and is only hardened (no rail stopPropagation there). Tests: tests/js/section_practice_dismiss.test.js.
• v3 UI no longer lets you accidentally text-select the chrome. Dragging or double-clicking across the interface used to marquee-highlight buttons, labels, the sidebar, the transport, and the note-highway HUD — which looks broken (reported on Mac + Windows). The v3 shell now defaults to user-select: none on html (static/v3/v3.css), then opts content back in — so chrome is non-selectable but the text you actually copy still works. Decided by a 4-lens panel (UX / accessibility / dev-ops / plugin-ecosystem); the guardrails are deliberate: form fields are always re-enabled (never break the caret / IME — no * { user-select:none }, which trips a WebKit input bug); plugin screens (.screen[id^="plugin-"]) stay selectable by default so a plugin's copyable text (lyrics, chord names, results) — including community plugins that don't know about this — isn't silently locked; and core read-only content opts back in by container via a new hand-authored .fb-selectable class — applied to the whole Settings panel (paths, device names, version, diagnostics, About — answering "is settings still copyable?": yes), the now-playing song metadata (with pointer-events re-enabled so the HUD text is actually reachable), and the focused modals / dialogs / toasts / scan banner that carry copyable errors, IDs, paths, and file names. It's cosmetic only (it protects nothing) and never used to lock copy-worthy text — errors, IDs, paths, versions, and metadata stay selectable per WCAG 2.2 (copy-paste as a permitted mechanism). Dense card lists (library grid, dashboard, profile) stay non-selectable by design — making them selectable would reintroduce the marquee-mess across cards. v3-only (v2 unchanged); plain CSS, no Tailwind rebuild; no desktop changes (standard OS-framed window). Plugin authors: .fb-selectable is documented in CLAUDE.md for re-enabling copyable content rendered outside a plugin screen. Tests: tests/js/v3_user_select_policy.test.js.
• Input-setup wizard no longer collapses an audio device's driver-type variants into one entry. On Windows the desktop engine enumerates the same interface once per host API (ASIO / Windows Audio / DirectSound), and the wizard's audio picker (plugins/input_setup/screen.js) de-duped the source list by display label — so the variants (which share a name) collapsed to a single choice, silently keeping whichever sorted first (often not the low-latency ASIO one the player wants). The audio-input capability already collapses true duplicates by logicalSourceKey (_visibleInputSources in static/capabilities/audio-session.js), and the variants each have a distinct key, so the wizard's extra label-collapse was redundant for real dupes and destructive for these — it also could drop the variant that was actually selected. Removed it; the picker now lists every selectable input. Pairs with feedBack-desktop's change to label each source with its driver type (e.g. "Focusrite (ASIO)") so the now-distinct entries are legible.
• 3D Highway FPS counter no longer hides behind the v3 "Up Next" pill. The on-highway FPS readout (Settings → Graphics → 3D Highway → Show FPS counter) is pinned to the top-right of the highway overlay — the same corner the v3 player chrome stacks its persistent Up Next pill and live-performance HUD into, on a higher layer that paints over the canvas. So the readout sat behind that chrome and couldn't be read — precisely when a tester had turned it on to judge performance (it also made the separate "Up Next won't turn off" complaint worse, since the default-on pill covered the counter regardless). The counter now stays top-right but drops just below whichever of that chrome is showing: highway_3d's screen.js measures the lowest visible top-right v3 HUD element (#v3-upnext / #v3-live-performance-hud / #hud-time) and floors the FPS box's Y beneath it. Element refs are resolved once and cached (no per-frame querySelector, per the plugin perf rules) and only consulted while the counter is actually drawn; gated on window.feedBack.uiVersion === 'v3' so the classic (v2) UI is byte-for-byte unaffected. plugins/highway_3d/plugin.json version → 3.30.1 (cache-buster). (For reading raw perf numbers unobstructed, the core perf HUD — localStorage.highwayPerfHud='1' — still renders above all chrome and additionally shows the adaptive render-scale.)
• 3D Highway fret-number row no longer clips off the bottom edge when the camera zooms in on a centred span. The heat-coloured fret-number row is drawn as a band below the board (sY(lowest) − S_GAP*1.4), but the camera's self-correcting framing only anchors the board centre to the lower third of the screen — it reserved no headroom for that row. So a tight zoom on a centred active span (worst around mid-neck; fine when the span sits at either end of the neck, which is why testers saw it "only when centered" and "not every song") dropped the numbers past the bottom edge. Tilt can't fix it there (it would only trade a bottom clip for a top clip), so camUpdate() now dollies the camera back just enough to bring the row back into frame: it projects the row band with the final camera and, when it falls below a safe NDC line (FRET_ROW_FIT_NDC_MIN), raises a capped, hysteretic _fretRowFitBoost applied to the curDist lerp target (the span-driven zoom still owns zooming in). The boost rises promptly (proportional to the deficit), relaxes lazily past a deadband, and is capped (FRET_ROW_FIT_BOOST_MAX, +60%) so the zoom can't pop or hunt; it cooperates with the tilt loop (pull-back shrinks the scene, tilt keeps the centre anchored) and yields entirely to the Camera Director free-cam. Surgical: passages where the row is already visible never trigger it, so framing is unchanged everywhere it already worked. plugins/highway_3d/plugin.json version → 3.30.2 (cache-buster). Tests: tests/js/highway_3d_camera_framing.test.js (guard constants, the boosted curDist lerp, the projected-row hysteresis, free-cam yield).
• v3 Songs grid now refreshes after a Settings rescan / DLC-folder change — no app restart needed. On a fresh install, pointing at a DLC folder in Settings and running a scan left the Songs section empty until a restart (the scan did populate the library — _background_scan re-reads config.json fresh — but the v3 grid never reloaded). The Settings Rescan / Full Rescan handlers only refreshed the classic (v2) library via loadLibrary(); the v3 grid (static/v3/songs.js) had no listener for a scan it didn't start itself (only its own upload path self-refreshed via watchUploadScan), so its cached, pre-DLC (empty) DOM/snapshot survived a sidebar return until a full reload. The rescan handlers now emit a library:changed event (static/app.js); the v3 grid listens and reloads if it's the active screen, else marks itself dirty so the next entry does a full re-fetch instead of restoring the stale snapshot (a _libraryDirty short-circuit ahead of every cached-DOM fast-path in onV3SongsScreenEnter). Tests: tests/js/v3_library_refresh.test.js (the emit + the reload/dirty wiring).
• Edit Metadata modal: the Year is now editable. You could set a year when authoring a pak but the Songs → Edit Metadata modal had no Year field, so it could never be changed afterward. The backend (POST /api/song/<f>/meta) already accepted and normalized year (writes it into the file via songmeta, survives a rescan) — only the UI omitted it. Added a Year input to openEditModal() (populated from the song's existing year) and included year in saveEditModal()'s POST body (static/app.js). Both the v3 card menu and the legacy edit button already pass the year through, so both surfaces get the field.
• Edit Metadata modal no longer closes when a click-drag is released on the backdrop. Selecting text inside a field and releasing the mouse past the modal's edge dismissed the form without warning (the click event's target resolved to the backdrop), discarding the edit. Backdrop dismissal now requires the mousedown to have started on the backdrop too — tracked per-modal and decided by a new pure _editModalShouldClose(clickTarget, modalEl, downOnBackdrop) helper (static/app.js). Cancel / ✕ still close on a normal click. Tests: tests/js/edit_metadata_modal.test.js (year in the POST body + the backdrop-close decision table).
• Built-in diagnostic sloppak rebranded "Slopsmith" → "FeedBack" in the song name. PR #586 renamed the file to feedBack-diagnostic-basic-guitar.sloppak but never regenerated the archive, so the manifest inside still carried title: Slopsmith Diagnostic — Basic Guitar / artist: Slopsmith (and the same heading in DIAGNOSTIC.md) — the stale name testers saw in the library/player and the onboarding calibration step, even though the build script, server, and docs all already say "FeedBack Diagnostic — Basic Guitar". Regenerated docs/diagnostics/feedBack-diagnostic-basic-guitar.sloppak from docs/diagnostics/build_diagnostic_basic_guitar.py so the committed artifact matches its source generator (title/artist/heading now "FeedBack"; chart, stem, and diagnostic: metadata unchanged). No code change — the rename in #586 just needed the rebuild.
• v3 song/lesson accuracy badges now refresh on the first return from a song — no restart needed. PR #574 added a stats:recorded → in-place badge repaint, but the repaint never matched a card. The event (like song:loading) carries the filename encodeURIComponent'd — exactly as playCard hands it to playSong (the highway WS decodeURIComponents it back) — whereas library cards key on the decoded localFilename (data-fn), and /api/stats/best is server-canonicalized to that same decoded key (server.py _canonical_song_filename). So repaintAccuracy's data-fn !== key check rejected every card and state.accuracy[encoded] was undefined, leaving the just-earned badge stale until a full render() (app restart / search / re-enter the screen) — which is why it "came back after a restart." static/v3/songs.js now decodes the stats:recorded filename back into the card / state.accuracy key space via a small decFn helper before marking dirty and repainting (idempotent for already-decoded names; falls back to the original on malformed input so a real filename containing a literal % is never corrupted), so both the immediate repaint and the onV3SongsScreenEnter deferred path land on the right card. Tests: tests/js/v3_songs_score_badge_refresh.test.js.
• Escape now exits a song (and leaves Settings) even when a transport/rail control button holds keyboard focus. Clicking a player control (Play / FF / RW / Restart) left that <button> focused, and _shortcutDispatchBlocked() in static/app.js treats any focused INPUT/SELECT/TEXTAREA/BUTTON as an "interactive control" and bails before the shortcut registry runs — so the player-scope Escape → Back shortcut never fired until the user clicked empty canvas to blur the control ("Escape in song not consistent"). Space already had a player-screen carve-out (#593) that let it fire through a focused control; Escape did not. Generalized that carve-out to Escape, scoped to the player and settings screens (both register an Escape = Back shortcut, and settings had the identical latent bug). The earlier guards are preserved and still win: text inputs are exempted first (Escape there clears/blurs the field), the Section Practice popover already claims Escape before the carve-out, and a true modal layered over the screen ([role="dialog"][aria-modal="true"] / .feedBack-modal) still traps Escape so it closes the modal rather than ejecting past it. Escape becomes a reliable, focus-independent "Back" — making it monotonic groundwork for an optional exit-confirm. Plugins that register a player-scope Escape shortcut benefit identically (they were broken the same way). Tests: tests/browser/keyboard-shortcuts.spec.ts (focused-button repro, text-input no-exit, no-escape-past-modal, Section Practice popover, settings twin-bug).
• The v3 "Up Next" pill can now be turned off — new "Show 'Up Next'" gameplay toggle (default ON). The v0.3.0 player chrome's persistent upcoming-section pill (#v3-upnext, drawn by static/v3/player-chrome.js's updateUpNext()) shipped with no off switch, so it always showed during playback whenever a section was upcoming — overlapping the top-right FPS HUD and ignoring the 3D-highway "Show 'Up Next' section card" checkbox (a different, in-canvas widget that was demoted to default-off precisely because this pill is the canonical readout). Users reading the pill as the same setting saw "disabled in settings but still there." Adds a real core toggle following the autoplayExit idiom: a client-only showUpNext localStorage pref (absence = enabled), a Show "Up Next" switch in the Gameplay settings tab (static/v3/index.html), reader/writer + loadSettings() hydration + a read-only window.feedBack.showUpNext getter in static/app.js, and a gate at the top of updateUpNext() that hides the pill when off. Disabling mid-playback hides it immediately; re-enabling re-shows it on the next chrome tick (~6 Hz). Added to RESET_MAP.gameplay.local in static/v3/settings.js so the Gameplay "Reset" restores the default-on state. Default ON = zero change for existing users. No Tailwind rebuild (plain markup + existing classes).
• v3 list/tree view brought to parity with the grid: select mode, parts chips, and song actions — plus a stale-CSS Docker fix. Re-lands a previously-reverted change. Frontend (static/v3/songs.js): entering select mode no longer collapses the tree — loadTree() now captures the expanded artist groups (details[open] keyed by data-artist) before the "Loading…" wipe and restores them on rebuild, so toggling select mode (which re-renders via reload()) keeps groups open and selection usable; tree rows gain a display-only checkbox + selection ring, the same fav / save-for-later / overflow-menu cluster as the grid card (always shown, all bound by wireCards()), and a capture-phase select guard mirroring the grid so clicking a row or arrangement chip in select mode selects instead of playing (<summary> headers sit outside [data-fn], so native expand/collapse is untouched). Docker fix (static/tailwind.min.css): the committed Tailwind stylesheet was stale — .sm\:flex (and the other utilities behind #582's hidden sm:flex arrangement chips and the new action cluster) were never compiled in, so they rendered display:none on the Docker build (which serves the committed CSS as-is; Desktop rebuilds from source so it looked fine). Regenerated with the pinned tailwindcss@3.4.19 via scripts/build-tailwind.sh so Docker matches Desktop and #582's chips render on every Docker deploy. Regression tests: tests/browser/v3-tree-select.spec.ts.
• Space bar now plays/pauses on the player screen even when a sidebar nav link or rail button has focus. When any <button> in the player rail (viz, audio, mixer, lyrics, plugins, advanced), a sidebar nav link, or a popover control held keyboard focus, pressing Space was swallowed by _shortcutDispatchBlocked → _isInsideInteractiveControl (which treats BUTTON/A as interactive), so the Space shortcut never reached the dispatcher and togglePlay() never ran. _shortcutDispatchBlocked (static/app.js) now extends the same carve-out already used for the Section Practice bar: while the player screen is active, Space is always routed through the shortcut system — the dispatcher calls e.preventDefault() before invoking the handler, so the focused element does not also activate. Text inputs (_isTextInput) remain exempted first, so typing space in a search/input field still works normally, and focus inside a true modal dialog (role="dialog" aria-modal="true" / .feedBack-modal) layered over the player is also exempted so Space reaches the modal's focused control (e.g. its Close button) instead of toggling playback behind it — non-modal player popovers/toasts (loop A/B, arrangement pin) stay covered. Regression tests in tests/browser/keyboard-shortcuts.spec.ts cover the focused-rail-button play/pause, the text-input exemption, and the modal-dialog exemption.
• A song's accuracy badge now updates on its library card right after you play it — no restart needed. The v3 library (static/v3/songs.js) loaded the best-accuracy map (/api/stats/best) once into state.accuracy at render time and only ever refreshed it on a full re-render; the play→return flow takes the screen-entry fast-path that restores the cached grid DOM without re-fetching, so a just-earned score stayed invisible until the next restart re-ran render(). The stats-recorder now emits a stats:recorded event (carrying filename/arrangement) once the scored POST /api/stats resolves on the server — the correct moment, since song:stop fires before the POST completes. songs.js listens: if the library is the active screen it re-fetches /api/stats/best and patches the affected card/row badge in place; otherwise it marks the filename dirty and onV3SongsScreenEnter applies it on return (a failed fetch keeps the entry dirty to retry). Badge markup was factored into a shared accuracyBadge(filename, variant) (grid pill + tree-row percentage, both tagged .fb-acc-badge) so the in-place repaintAccuracy can find and replace them without a full list re-render (scroll/pagination preserved). The old empty song:stop "refresh lazily next render" placeholder is replaced.
• Changing Settings → 3D Highway → Fret spacing no longer ejects you to the home screen. The highway_3d plugin's h3dSetFretSpacing was the lone 3D-highway setting that called location.reload() to apply — and since the SPA boots with #home as the active screen (index.html .screen.active), the reload dropped the user out of Settings onto the homescreen. It now applies live like every other 3D-highway setting: it rebinds the module-scope _h3dFretUniform flag (so panels mounted later this session pick up the new mode), recomputes the two fretX-derived scalars that were baked at init (_fretLabelScaleRefW for fret-label sprite scaling, FRET_WIDTH_MID for camera hysteresis), and broadcasts a fretSpacing change over the existing _bgEmitChange pub-sub so every mounted panel rebuilds its board via buildBoard(). Per-frame note geometry already reads fretX live and needs no rebuild. No page reload, so the Settings screen stays put. Source-level regression tests in tests/js/highway_3d_fret_spacing.test.js now pin the no-reload / live-rebuild behavior.
• v3 library scroll-restore no longer breaks the classic v2 UI or drops off-screen searches (feedBack#857). Two regressions in the scroll-restore work above: (1) playSong remapped home-launched songs to return to the #v3-songs screen unconditionally, but static/app.js is shared with the v2 UI (served at /v2 / FEEDBACK_UI=v2) where that screen does not exist — Esc-from-player then called showScreen('v3-songs'), which threw on the missing element and stranded the user on a blank screen with playback still running; the remap now applies only when #v3-songs is present. (2) The Songs screen-entry fast-path skips reloading to preserve scroll, but the global topbar search routed through it, so once Songs had been visited, searching from another screen navigated there without applying the new query; the screen now tracks the state hash each fetch reflects and refetches when it has drifted, keeping the scroll-preserving no-op only when nothing changed.
• An active custom highway renderer is no longer starved of draw() when it hides the canvas (#819). The per-frame draw gate in static/highway.js bailed on if (!_lastVisible) return, which conflated two different "hidden" states: a genuine off-screen canvas (offsetParent === null — navigate-away / display:none splitscreen panel, #246) versus a renderer-set override-hide (setVisible(false), where an opaque overlay covers the canvas but the active renderer keeps painting its own surface). The gate now only pauses everything for the off-screen case (and still pauses the default 2D renderer on an override-hide); the active custom renderer keeps receiving draw() through its own override-hide. The highway:visibility event still fires before the gate, so sibling overlay renderers (e.g. 3D Highway's .h3d-wrap) still pause. This is the core-side root cause behind the Tab View cursor freezing in single-player (feedBack#734; worked around plugin-side in feedBack-plugin-tabview#25).
• Screensaver no longer kicks in during windowed-mode playback (#686). While a song is playing, static/app.js now holds a Screen Wake Lock (navigator.wakeLock.request('screen')) so the OS display/screensaver stays awake even though only audio + the highway animation are active and the keyboard/mouse are idle. The lock is acquired on song:play/song:resume and released on song:pause/song:ended/song:stop (kept only while actually playing), and re-acquired on visibilitychange when the tab refocuses (the API auto-releases a lock whenever the page is hidden). Both the HTML5 <audio> and JUCE desktop playback paths emit the same song:* events, so the fix covers both. In feedBack-desktop (Electron), where navigator.wakeLock is unreliable, it also drives a native powerSaveBlocker bridge via the optional window.feedBackDesktop.power.setScreenAwake hook when present; both calls degrade silently where unsupported. Note: the browser Wake Lock API is secure-context only, so in a plain browser this is active on localhost / HTTPS only — a session opened over plain HTTP to a LAN IP (e.g. http://192.168.1.100:8000) won't keep the screen awake; front it with HTTPS or use the desktop app (see README → reverse-proxy notes).

Changed

• Practice plugin first-class sidebar slot now points at Virtuoso. The bundled practice plugin was rebranded/re-homed from the SlopScale fork (id: slopscale) to got-feedback/feedBack-plugin-virtuoso (id: virtuoso); the desktop bundle swap is feedBack-desktop#31. static/v3/shell.js still promoted slopscale, whose id no longer ships — so renderPromotedNav() (gated on the plugin appearing in /api/plugins) would have found no match and the dedicated sidebar slot would have gone dark, dropping Virtuoso to the generic Plugins gallery. Update the NAV entry + PROMOTED_PLUGINS slot slopscale → virtuoso (screen: plugin-virtuoso, label "Virtuoso - Practice", same FeedBarcade anchor + target icon) so the practice plugin keeps its first-class entry. Also clear the now-dead slopscale id from the Plugins-gallery curated category map (static/v3/plugins-page.js) and add virtuoso: 'practice' as a defensive fallback (the manifest's category: "practice" is authoritative, so it lands on the practice board regardless), and refresh the stale SlopScale references in README.md + docs/plugin-capability-inventory.md. Must land with the bundle swap or the practice plugin regresses in the UI.
• 3D highway: realistic curved metal frets. The fret wires are now bowed TubeGeometry (the middle strings push away from the camera so the row of frets reads as wrapping a cylindrical neck — a depth cue) rendered with a lit MeshStandardMaterial instead of the old flat, straight MeshBasicMaterial boxes, so the scene's ambient + directional light glints across the rounded surface for a polished-steel look. The existing per-frame highlight is preserved unchanged: frets inside the active anchor still turn gold (0xD8A636), which under the metallic shading reads as brass. Metalness is kept moderate (0.4, not full-metal) because the scene has no envMap — a PBR full-metal surface would reflect black — with a dim emissive floor so frets stay legible down the fogged neck. Backported from the highway_babylon plugin's "hit-zone fret bars". All knobs (FRET_BOW_DZ, metalness/roughness/emissive) are tunable constants. plugins/highway_3d v3.25.0.
• 3D highway: section + tone HUD cards now default OFF. The v0.3.0 player chrome carries a persistent "Up Next" pill, making the in-canvas section card redundant by default (it doubled the readout, feedBack feedback); the tone HUD follows the same less-is-more default. Both remain available in Settings → 3D Highway (visibility/position/size unchanged); users who previously toggled either explicitly keep their stored preference — only the untouched default flips. plugins/highway_3d v3.24.1.
• Perf: replace runtime Tailwind Play CDN with a prebuilt static stylesheet (static/tailwind.min.css). The Play CDN's runtime JIT scanned the DOM ~1.8x/sec on the main thread (~37 ms blocking spans), dropping ~26% of frames in long playback sessions with the 3D highway as default. Theme extensions (dark/accent/gold colors, Inter font) move to tailwind.config.js; regen via bash scripts/build-tailwind.sh. No runtime build step — the generated CSS is committed. Fixes feedBack-desktop#110.
• Perf: reduce per-frame allocations in the 2D highway chord + lyric render paths. _ensureChordRenderCache now also caches sortedNotes / nonZeroNotes / nonZeroFrets / allMuted / hasMultipleNotes (computed once per chord, invalidated on src / _inverted / chordTemplates change — the third key catches a stale isOpen-derived classification when the WS chord_templates message lands after the final chords chunk), so drawChords no longer re-sorts / re-filters / spreads min-max per visible chord per frame. The in-chord unison bend classification is folded inline (no chordPositions.filter × 2 per frame). drawLyrics memoizes ctx.measureText results in a two-level Map<fontSize, Map<text, width>> so cache hits don't allocate a composite string key. Lit-sustain shimmer in drawSustains swaps the 4 per-note-per-frame Math.random() calls for a 64-entry precomputed jitter LUT (xorshift32-seeded — the LUT contents are reload-stable and test-reproducible; rendered shimmer is deterministic per createHighway() instance, since the seed includes that instance's _frameIdx) indexed by (frameIdx + n.s + ⌊n.t·60⌋), visually indistinguishable and allocation-free.
• Perf: the load-adaptive render scale (_adaptRenderScale, #654) no longer visibly hunts up/down on passages that hover near the frame budget (testers saw "quality going up and down" with the 3D highway). Downscaling stays prompt to protect the frame rate, but upscaling is now lazy: a smaller step (×1.06 vs ×1.1) on a longer cooldown (_AUTO_UPSCALE_COOLDOWN_MS 2500 ms vs the 600 ms adjust cooldown), reset on any downscale, and gated by a predictive guard — it only upscales when the projected cost after the step (≈ cost × step², since draw cost tracks the pixel count) still clears the high budget. The scale therefore settles just inside the 7–12 ms deadband instead of oscillating across it. No new public API; the _autoScaleMin "Min res" floor is unchanged.

Removed

• c library hotkey ("Convert to .sloppak") removed from core. Core hardcoded a plugin-specific shortcut: a documentation-only registerShortcut({ key: 'c', scope: 'library' }) no-op plus a c → button.sloppak-convert-btn entry in the library keydown handler that fired the Sloppak Converter plugin's button. Per the plugins-own-their-behavior principle, core no longer ships this hotkey — the convert button still works by click, and the Sloppak Converter plugin can register its own c shortcut via window.registerShortcut() if keyboard access is wanted. The f (favorite) and e (edit) library hotkeys, which drive core buttons, are unchanged. Help-modal/registry tests in tests/browser/keyboard-shortcuts.spec.ts updated to drop the c assertions.

Added

• Player progression: Mastery Rank, instrument-path challenges, daily/weekly quests, Decibels currency, cosmetics shop (spec 010). Onboarding gains two steps: pick one or more instrument paths (Guitar / Bass / Drums — data-driven, more can ship as content) and a calibration challenge offer (play the bundled FeedBack Diagnostic with note detection at 100% accuracy — or skip; either way you reach Mastery Rank 1, and a skipped calibration can still be completed later from the Progress screen). Each path levels by completing a content-defined number of challenges (any order) from that level's set; Mastery Rank = onboarding rank + the sum of path levels, starting at 0 on a fresh install. The existing unified XP backend is untouched but the frontend renames it to Decibels (dB) — a spendable currency earned ONLY by playing (songs, FeedBarcade rounds, quest rewards; no real-money path exists or may be added) — with spend tracked in a separate wallet so lifetime earnings stay monotonic. Rotating daily/weekly quests (deterministic per period, lazy instantiation, local-midnight / Monday resets) award dB and feed quest_completed challenges. A new Progress screen (rank hero, per-path checklists, quest countdowns, add-a-path) and Shop screen (themes via CSS-variable swaps under html[data-fb-theme], avatar frames; atomic balance-checked purchases — 402 on insufficient dB, 409 on re-buy) join the v3 nav, and the topbar badge now shows Rank + challenge-set progress + dB balance. All definitions live in data/progression/ JSON (paths/levels/challenges, quest pools, shop catalog) — adding a rank, challenge, quest, or cosmetic is a content edit + restart, never code; invalid content degrades to logged warnings. New tables (additive + idempotent): progression_state, player_paths, challenge_progress, quest_state, wallet, shop_owned, shop_equipped. New endpoints: GET /api/progression, POST /api/progression/paths|onboarding|events (events whitelists minigame_run; song_completed stays server-derived inside POST /api/stats, which now resolves the instrument server-side and reports an additive progression outcome key), GET /api/shop, POST /api/shop/buy|equip; equipped cosmetics ride along on GET /api/profile. A new progression capability domain (core-owned, kind: command, safety: safe — inspect, record-event, list-shop, buy-item/equip-item gated on user action) emits challenge-completed/quest-completed/path-level-up/rank-changed/db-changed/calibration-completed/cosmetic-equipped, mirrored as progression:* window events, with a redaction-safe diagnostics contributor; backend plugins get the symmetric record_progression_event context hook (the bundled minigames hub reports runs through it, guarded for standalone). Spec: specs/010-progression-domain/. Tests: tests/test_progression.py, tests/test_progression_api.py. Migration notes: existing XP totals carry over as lifetime dB (balance = lifetime − spent); resetting a per-source XP contribution (e.g. a minigames profile reset) after spending can clamp the spendable balance to 0 until new dB is earned; drums-path v1 content uses currently-satisfiable goals (arcade rounds, quests, any-instrument plays) until drums scoring lands.

• 3D highway score FX (notedetect game-scoring layer). The bundled highway_3d renderer now visualizes the scoring layer shipped in feedBack-plugin-notedetect ≥1.13: floating "+N" score pops above each judged gem (sourced from the note-state provider's new { points, mult, popKey } verdict fields — chord members share the chord-level popKey, so a chord pops once, not once per string), plus session-level FX from the new notedetect:fx event — a particle burst at the strike line on streak milestones (25/50/every 100), an expanding ring pulse on multiplier tier-ups (×2/×3/×4), and a brief red wash when a ≥10 streak breaks. Colors and the pop font follow the user's notedetect scoring-UI skin (feedBack_notedetect_skin: neon/esports/metal, refreshed live on the notedetect:skin bus event). Everything renders on the existing 2D overlay canvas from fixed-size slot pools — no Three.js geometry, no text-sprite cache traffic, near-zero cost when idle — and degrades to a silent no-op with older notedetect builds (the new fields/events simply never arrive). Splitscreen panels scope FX to their own detector instance via the bubbling per-panel notedetect:fx dispatch. plugins/highway_3d v3.24.1.

• 3D highway: slide direction arrows + gem-follow animation. Slide notes now show a ›/‹ arrow indicating which way the slide goes — on the note/gem itself, as an early preview on the neck before the note arrives, and (optionally) chained further ahead for multi-leg slides — each independently toggleable in Settings → 3D Highway (slideArrowApproachVisible, slideArrowNeckVisible, slideArrowChainPreviewVisible). The note gem also now visually glides from its starting fret to the slide's destination over the note's sustain and holds there through the brief post-sustain linger, instead of snapping back to the starting fret — most noticeable on unpitched "slide to nothing" notes. plugins/highway_3d v3.25.2.

• 3D highway: up to 3 upcoming-note ghost previews per string, with fade-in/grow. Each string now previews up to 3 upcoming notes (was 1) on a fixed 0.6 s fade-in/grow ramp, so tight same-string runs no longer pop in at full size right before impact and the player can read note order ahead of time. isBlocked (the pre-impact ghost suppression in a note's last 150 ms) is now scoped to chord notes only — for lead notes it had been blinking the ghost out right before each sustained note in dense runs. (Slide notes stay excluded too, per the slide-arrow work above, since their gem glides off the start fret.) plugins/highway_3d v3.26.0.

• Enable/disable plugins from the v3 Pedalboard (footswitch backend). Every /api/plugins entry now carries an enabled boolean (default true), and a new POST /api/plugins/{plugin_id}/enabled endpoint ({"enabled": <bool>} → {"id", "enabled"}) persists the choice to CONFIG_DIR/plugin_state.json (only non-default enabled:false entries are stored; a missing/corrupt file is tolerated and never crashes startup). The loader skips disabled plugins at startup — no requirements install, no routes.setup(), no screen/nav/capabilities — while still surfacing them in /api/plugins as a disabled entry (status:"disabled", enabled:false) so the UI can show an "off" pedal you can switch back on. Toggling persists immediately and flips the in-memory flag so the next /api/plugins reflects it at once (a runtime-disabled plugin's already-mounted routes/screen remain until the next restart; re-enabling a startup-skipped plugin mounts on restart). A disabled plugin is excluded from the capability pipeline — its capability metadata is emptied in /api/plugins. Guard rails keep capability_inspector and app_tour_* always enabled (disable → 400); unknown id → 404; missing/non-boolean enabled → 400. Backend only; the v3 Pedalboard frontend consumes this contract. Docs: docs/plugin-v3-ui.md.

• fee[dB]ack v0.3.0 rebrand + UI redesign (opt-in, isolated). The visible product is being renamed from FeedBack to fee[dB]ack (the [dB] is a decibel pun on the practice "feedback" loop) alongside a full dashboard-style UI redesign. Rebrand scope is the app + docs wordmark only — the repository, Python package, ghcr Docker image, CONFIG_DIR, and FEEDBACK_* env vars all keep the feedBack name, so existing deployments and data are unaffected. The redesigned UI is additive and served behind a feature flag: FEEDBACK_UI=v3 flips the / route to the new static/v3/ shell, and GET /v3 always serves it; the default / stays byte-identical to 0.2.9 until 0.3.0 flips the default. This release adds the static/v3/ scaffold (navy app shell + styled fee[dB]ack wordmark, brand SVG + favicon + PWA manifest with 192/512 icons), an additive fb Tailwind color palette (legacy dark/accent/gold retained) with static/v3/** in the content globs, and the regenerated static/tailwind.min.css. Vanilla JS, prebuilt Tailwind, no Play CDN (Principle II). Shell wiring, screens, profile/scoring backends, and capability-runtime integration land in subsequent v0.3.0 changes.

• fee[dB]ack v0.3.0 app shell (sidebar + topbar + routing). The v3 shell (static/v3/index.html) is now a re-chromed copy of the legacy app: the new left sidebar (HOME / LIBRARY groups) and topbar (secondary nav, search, Support, badge-cluster mount points) replace the hidden legacy navbar, and new #v3-* screens (dashboard/plugins/profile/playlists/saved) are added — while all legacy screens (#home library, #favorites, #settings, #player, #audio, plugin nav containers) are kept verbatim so static/app.js boots unmodified and the whole engine (player/highway, plugin loader, capabilities, audio, library, settings) is reused as-is. Navigation is the shared window.showScreen across #v3-*, reused legacy, and #plugin-* screens, with a responsive hamburger and a localStorage/v3:-namespaced shell. Plugin nav is mirrored into the sidebar from /api/plugins (UI placement is a deferred capability domain, so this uses the legacy loader, not capability dispatch). static/v3/shell.js wraps window.showScreen via the idempotent rehydration pattern to keep sidebar/topbar active-state in sync.

• fee[dB]ack v0.3.0 player profile + first-run onboarding + unified XP + streak. Adds a single-user core profile (profile/profile_progress/xp_profile tables in web_library.db, additive + idempotent): display name + avatar, a stable player_hash (SHA-256 of the first name + a once-generated salt — stable across later renames; a future-leaderboard label, never auth), and a streak (any session on a calendar day keeps it; a missed day resets to 1). New endpoints: GET/POST /api/profile, POST /api/profile/avatar (base64, re-encoded to a ≤512px PNG under CONFIG_DIR/avatars/), GET /api/profile/avatar/{name} (safe-joined), GET /api/profile/avatars (bundled defaults under static/v3/avatars/), GET /api/profile/progress (one call for the badge), and POST /api/xp/award. Unified XP: lib/xp.py is the single XP curve (same math the minigames plugin shipped); the core xp_profile store is the one source of truth the profile badge reads, exposed to plugins via context["award_xp"]/get_xp_progress/seed_xp. The bundled minigames plugin now delegates XP to the core store (seeding once from its existing profile.json so earned levels carry over) — so song-play, minigames, and tutorials all feed one level. Frontend: a blocking first-run onboarding overlay (name + avatar grid + upload), the topbar profile badge (avatar, 🔥 streak, level + XP bar), and the #v3-profile screen. Tests: tests/test_xp.py, tests/test_profile_api.py.

• fee[dB]ack v0.3.0 song-stats store (best score + accuracy, plays, resume position). A core song_stats table (web_library.db, additive + idempotent, PK (filename, arrangement)) records per-song/arrangement best/last score + accuracy, play count, and last position. Endpoints: POST /api/stats (scored session → plays += 1, best_* = max, last_* = new, plus unified-XP award xp_for_run(score) and a streak bump, both behind try/except so a side-effect failure never drops the stat write; or position-only lastPlayPosition → resume touch with no plays change), GET /api/stats/{filename} (aggregated across arrangements), GET /api/stats/recent (joined to song title/artist/art for "Jump back in"). Scoring stays frontend-driven: static/v3/stats-recorder.js tallies the note:hit/note:miss events the optional feedBack-plugin-notedetect already emits (and also accepts an explicit note_detect:session-ended summary), then POSTs on song end; it also persists resume position on pause/stop. No note-detect edit required — note-detection is a deferred capability domain, so the recorder uses those legacy events and degrades to "no accuracy" when the plugin isn't installed. Score/accuracy math is shared with the server via lib/song_score.py. Tests: tests/test_song_score.py, tests/test_song_stats_api.py.

• fee[dB]ack v0.3.0 playlists, Saved for Later, and Continue-Playing. Core playlist management (playlists + playlist_songs tables in web_library.db, additive + idempotent): create/rename/delete, add/remove/reorder songs, plus a reserved Saved for Later system playlist (created on first use; protected from rename/delete). Endpoints: GET/POST /api/playlists, GET/PATCH/DELETE /api/playlists/{id}, POST /api/playlists/{id}/songs, DELETE /api/playlists/{id}/songs/{filename}, POST /api/playlists/{id}/reorder, POST /api/saved/toggle, and GET /api/session/continue (derives the resume song + last position from song_stats, no new table). Frontend static/v3/playlists.js renders the #v3-playlists list + detail (drag-reorder, play, remove) and #v3-saved, and exposes window.v3Saved.toggle() for a "Save for later" affordance on song cards. Favorites reuse the existing favorites screen/API. Core REST, no capability domain. Tests: tests/test_playlists_api.py.

• fee[dB]ack v0.3.0 Dashboard / Home. The #v3-home dashboard (matching the v0.3.0 design target) composes the new backends: a "Welcome back, {name}!" banner with a patch-notes link (/api/version), a hero card (Start Playing / Create Lobby), a Continue-Playing card (/api/session/continue → art, tuning chip, 4-segment progress; click resumes via playSong + best-effort seek), a stats row (audio-routing widget placeholder until prompt 18, library count from /api/library/stats, plugins count from /api/plugins where status==="ready"), and a Recently Played grid (/api/stats/recent) with per-song accuracy badges (good/mid/low ramp). Each widget fetches + renders independently and degrades gracefully (missing/empty endpoint → placeholder, never blocks first paint). static/v3/dashboard.js; re-renders on return to Home and on profile update.

• fee[dB]ack v0.3.0 tuner + instrument topbar badges. The topbar gains an instrument selector (guitar/bass + string count + tuning + reference pitch) persisted via additive /api/settings fields (reference_pitch clamped 430–450, instrument, string_count 4–8, tuning name or semitone offsets); changing it emits instrument:changed so the note_detect scorer can re-tune (consumed once the external plugin adopts it). A live tuner badge stays idle until the user enables the mic (explicit gesture; getUserMedia), then shows a YIN note readout with a cents needle (green within ±5¢) using a new dependency-free static/v3/tuner-core.js (YIN + frequency→note/cents, honoring the reference pitch); clicking opens the full feedBack-plugin-tuner screen when installed. CPU-friendly (~20 Hz, paused when the tab is hidden, respects prefers-reduced-motion). Tests: tests/test_settings_instrument.py, tests/js/tuner_core.test.js.

• fee[dB]ack v0.3.0 audio-routing widget (dashboard). The dashboard's audio stat tile now reads the live audio session through the capability runtime — audio-mix inspect (route + faders + required kinds), audio-input list-sources (selected/available input), audio-monitoring inspect — and renders Audio Input → VST/NAM/IR → Audio Output with per-node state dots and a Connected/Not Connected line. It never touches audio-mixer.js internals or nam_tone routes directly; "Not Connected" is the honest browser default (no native route), and it degrades on no-owner/no-handler/failed or absent capabilities. Refreshes on instrument:changed, play/stop, capability audio events, and each Home visit. static/v3/audio-routing.js.

• fee[dB]ack v0.3.0 Plugins page. The #v3-plugins screen renders the enriched /api/plugins: a "{N} active" header (status==="ready"), a card grid per plugin (icon, name, version, status pill with the error on failed, capability summary badges — declared domains / validation warnings / unsupported versions / shim hits / bundled / type), an Open → action that navigates to the plugin's injected #plugin-<id> screen, and All/Bundled/Visualizations filters. Surfaces a deep-link to the bundled Capability Inspector rather than re-implementing the graph. No new backend. static/v3/plugins-page.js.

• fee[dB]ack v0.3.0 Songs / Library screen (#v3-songs). A native vanilla-JS library browser over the existing /api/library* endpoints: provider selector (via the library capability, not DOM scraping), grid + tree views, sort, format filter, a tri-state filter drawer (arrangements / stems / lyrics / tunings), topbar-driven search (debounced), infinite scroll, fb song cards with accuracy badges (good/mid/low ramp, batched via a new GET /api/stats/best), favorite + save-for-later affordances, and upload (reuses the existing uploader). The "Songs" sidebar nav now opens this screen. No regression to /api/library*. static/v3/songs.js.

• ui.library-card-injection capability + native song-card actions (fee[dB]ack v0.3.0). New core capability (static/capabilities/library-card-actions.js, owner core.ui.library-card-injection, exposed as window.feedBack.libraryCardActions) lets plugins register per-song library-card actions (id, label, placement, applicability, enabled state, run handler) with action-registered/action-result events — replacing the legacy .song-card DOM-injection pattern (roadmap domain #9, now delivered as a frontend host). The native Songs grid renders registered actions in each card's "⋮" menu; the built-in Edit metadata and Convert to E Standard (retune) actions ship through it (static/v3/card-actions-core.js, calling the existing openEditModal/retuneSong globals). Songs cards also gain arrangement chips (play a specific arrangement) and a multi-select mode with batch Add to playlist / Save for Later. Recipe in docs/capability-recipes.md; tests in tests/js/library_card_actions.test.js. Migrating the external card-action plugins (Sloppak Converter, Find More, editor) onto register(...) is a follow-up.

• centOffset exposed via getSongInfo() — the arrangement <centOffset> field (float, cents) is now parsed from all chart sources (loose folder XML, sloppak wire format) and sent as centOffset in the song_info WebSocket message. Plugins can read getSongInfo().centOffset to obtain the arrangement's pitch-shift offset — commonly -1200.0 for extended-range bass (one octave down) or a small non-zero value for true-tuned content (e.g. A443 ≈ +11.8 cents). Defaults to 0.0 when absent.

• highway.getPhrases() and highway.getMastery() public plugin API — exposes phrase timing windows ([{ index, start_time, end_time, max_difficulty }]) and the current mastery slider value (0..1) as documented, stable plugin API. Both values were already in memory and reachable via internal names; this surfaces them with intent so plugins can implement section-aware logic (e.g. tracking accuracy per phrase, suppressing difficulty changes during a hard solo) without reaching into undocumented internals. Returns null when the song has no phrase data (GP imports, single-difficulty charts). Pair with the existing hasPhraseData() to gate phrase-aware code paths.

• Tailwind freshness guard + wider plugin scan. A new tailwind-fresh CI job (.github/workflows/tests.yml) rebuilds static/tailwind.min.css with the pinned tailwindcss@3.4.19 and hard-fails on any diff, so the committed prebuilt stylesheet can no longer silently lag source (after PR #411 removed the runtime Play CDN, a stale file shipped unstyled elements with no guard). The tailwind.config.js plugin content glob is widened to ./plugins/**/*.{js,html}, which also scans non-screen.js plugin JS (e.g. plugins/app_tour_*/script.js) that was previously invisible to the build. Regenerating under the wider glob is a no-op for runtime behaviour — it only adds classes that were already used in source. Groundwork for the plugin styles capability (constitution 1.1.0, Principle II): runtime-installed plugins ship their own compiled CSS rather than relying on core's build-time scan.

• Plugin capability pipelines — adds the first versioned capability coordination layer for plugin authors and support tooling. /api/plugins now exposes validated capability declarations, validation warnings, unsupported-version metadata, UI/runtime domain declarations, and compatibility shim summaries for legacy nav / screen / settings / routes / visualization surfaces. The browser runtime now tracks manifest participants separately from live handlers, explicit dispatch outcomes (no-owner, no-handler, unsupported-command, incompatible-version), claim lifecycle cleanup, manual override precedence, deterministic ownership conflicts, multi-provider ordering, shim hit counts, and a redaction-safe diagnostics snapshot capped at 64 KB. A bundled Capability Inspector plugin shows the live graph, and new docs cover the manifest schema, recipes, safety matrix, lifecycle cleanup, and diagnostics contract.

• Audio graph/session capability slice — promotes audio-mix, audio-input, audio-monitoring, and coordinated stems diagnostics into the capability runtime. The new audio session host records song route/fader state, redaction-safe input sources, monitoring lifecycle outcomes, stem automation claims/overrides/orphans, and compatibility bridge hits for legacy faders, song volume, Stems master volume, 3D Highway analyser taps, audio startup barriers, and input source handoffs. core.audio.session coordinates stems without replacing the Stems plugin as the owner of actual stem playback/state.

• Audio-mix control plane — makes audio-mix the player mixer source of truth. Core now exposes list-faders, get-fader-value, set-fader-value, inspect-route, and inspect-analyser through the capability runtime, routes native and compatibility-backed fader provider operations with a 2-second timeout, reports committed values back to the mixer UI, suppresses matching legacy faders when a native participant owns the same logical control, and expands audio-session diagnostics/Capability Inspector rendering for fader availability, source modes, bridge hits, route/analyser summaries, and timeout failures.

• Audio-input control plane — makes audio-input the redaction-safe source of truth for instrument input discovery and lifecycle. Core now exposes list-sources, select-source, open-source, and close-source through the capability runtime, persists selected logical sources, keeps inspect/list/select prompt-free, routes provider source.open/source.close operations with bounded outcomes, shares compatible open sessions across requesters, suppresses compatibility-backed duplicate sources when a native provider owns the same logical key, and expands audio-session diagnostics/Capability Inspector rendering for selected input, open sessions, bridge hits, storage status, and permission/device failures without exposing raw device labels or live audio handles.

• Audio-monitoring control plane — makes audio-monitoring the shared live-monitoring coordinator. Core now exposes provider registration/list/selection, explicit user-action start, requester-counted stop, prompt-free inspect/monitoring.status, and set-direct-monitor through the capability runtime. Monitoring starts integrate with selected audio-input readiness, background requesters can only attach to active compatible sessions, active sessions survive song/playback stops without auto-resuming after reload, native providers suppress compatibility-backed legacy monitor paths, and diagnostics/Capability Inspector now show providers, sessions, requesters, direct-monitor state, bridge hits, and distinct safe outcomes (provider-selection-required, user-action-required, incompatible, unavailable, stopped, etc.) without exposing raw audio/device data.

• Playback control plane — promotes playback to an active core capability domain for song transport, timing, loop, route, requester/observer, bridge, and diagnostics state. Core now exposes inspect, user-authorized start, pause, resume, stop, seek, set-loop, and clear-loop through the capability runtime while static/app.js keeps raw <audio>/JUCE handles private behind a redaction-safe adapter. Playback diagnostics use pseudonymous targets in exported bundles, local display labels only in the Capability Inspector, bounded recent outcomes/events, and bridge accounting for window.playSong, legacy song:* events, window.feedBack transport helpers, loop helpers, and browser/native route handoff.

• 3D highway — Tone HUD, fret dividers, chord-diagram toggle, FPS counter. The bundled plugins/highway_3d gains an amber Tone-change HUD (shows the active tone and the next scheduled tone change; position / size / visibility configurable in settings), a fret-dividers toggle (vertical dividers on the highway, on by default, via h3dBgSetFretDividersVisible), a chord-diagram visibility toggle (h3dBgSetChordDiagramVisible), and an FPS counter setting migrated to BG_DEFAULTS.fpsVisible (drops the legacy h3d_showFps localStorage key). Chord-diagram position is restricted to tl/tr; legacy bl/br values are coerced on load. Perf: accent-halo shell descriptors are pre-built per string in initScene() and the chord-verdict cache key is encoded as a number, eliminating per-frame allocations in the drawNote() and chord hot paths.

• Sloppak assembly preserves a short preview clip. When a source chart carries a separate short browser-preview audio clip alongside the full song, the sloppak assembler now decodes it to preview.ogg at the sloppak root and records it under a new top-level preview: manifest key (POSIX relpath, same shape as lyrics/cover). A failed preview decode is logged at debug and skipped without aborting the overall build. Sources with no separate preview are unaffected. Older sloppak readers ignore the unknown preview key, so the change is purely additive (sloppak-spec.md §5.5 backward-compat). Documented in docs/sloppak-spec.md §2 alongside the other optional top-level keys. Enables feedBack-plugin-song-preview to render hover-to-listen previews for sloppaks without seeking into the full audio.

• Generic plugin asset route — GET /api/plugins/{plugin_id}/assets/{path} serves arbitrary static files a plugin bundles under its own assets/ directory (AudioWorklet modules, WASM, images, etc.), so plugins can self-host browser-fetchable assets without a CDN (Principle II). Containment is enforced by lib/safepath.safe_join against <plugin>/assets/, so .. traversal, absolute paths, and NUL bytes cannot escape assets/ to reach a plugin's Python modules. .js is served as application/javascript. First consumer: the stems plugin's pitch-preserving time-stretch worklet.

• Minigames framework — bundled as a core plugin (plugins/minigames/). Promotes the upstream feedBack-plugin-minigames repo into the core bundle so every FeedBack install gets the framework out of the box (same promotion path used for highway_3d). The plugin adds a top-level Minigames nav link (alongside Library / Favorites / Upload — not buried in the Plugins dropdown), a library-style card grid of installed minigame plugins, and a shared profile layer (XP, level, per-game leaderboards, cross-minigame unlocks) persisted under CONFIG_DIR/minigames/ and opted into the settings export. Other plugins that want to ship a minigame add a minigame block to their plugin.json and call window.feedBackMinigames.register(spec); the SDK exposes scoring (createContinuous runs a self-contained YIN tracker; createDiscrete / createChord wrap note_detect's createNoteDetector), HUD primitives, run persistence, and a scheduler so individual minigames don't need their own DSP or backend. Backend endpoints live under /api/plugins/minigames/{runs,profile,registry}. The framework is plugin-shaped (not core code) per Principle III, but bundled so it ships with every install. First consumer: feedBack-plugin-flappy-bend, shipped separately.

• Alpha-build heads-up banner — when /api/version reports a version string containing "alpha" (case-insensitive), an amber banner appears at the top of the library section warning users that the build is in active development and may have bugs or breaking changes. The banner stays hidden on stable / beta / RC builds. No persistence or dismiss state — it's a passive notice, not a modal.

• Drum vocabulary expanded to 18 pieces — adds stack (MIDI 30, from GM's extended-percussion range, unused by real drum-kit MIDIs) and bell (MIDI 80 "Mute Triangle", also unused in real drum-kit MIDIs) to lib/drums.py PIECES. Inserted in the iteration order so the editor / highway lane ordering is hi-hat → stack → crash → … → ride bell → bell. Both are cymbals; default shape circle_jagged (stack) / circle_dot (bell). Old drum tabs round-trip unchanged — the schema is permissive and existing piece-ids are untouched.

• GP / MIDI drum import surfaces unmapped notes — convert_drum_track_to_drumtab (lib/gp2rs.py) and convert_drum_track_from_midi (lib/midi_import.py) gain an optional keyword-only out_unmapped parameter. Callers that pass an empty dict receive a per-MIDI record of every silently-skipped percussion note ({midi: {"count": int, "times": [float, ...]}}, times capped at 100 samples per note). This lets the editor plugin show a warning + manual-mapping UI on import instead of silently dropping unmapped notes. Default behavior unchanged for callers that don't opt in.

• Drum support from scratch — drums are now a first-class arrangement type with their own JSON payload on disk and their own WS stream to the highway. New lib/drums.py defines the closed piece-id vocabulary (kick, snare, snare_xstick, hh_closed/open/pedal, tom_hi/mid/low/floor, crash_l/r, splash, china, ride, ride_bell), default GM-MIDI mappings, three preset lane configurations, and a permissive drum_tab.json validator. lib/sloppak.py::load_song reads the manifest's optional top-level drum_tab: key, parses + validates the JSON, and surfaces it on LoadedSloppak.drum_tab; the load stays permissive so a missing or malformed tab silently disables drums rather than failing the sloppak load. /ws/highway/{filename} gains two new message types — drum_tab (metadata + kit legend) and chunked drum_hits (500 hits per frame, same chunking as notes) — exposed to renderers via bundle.drumTab. song_info carries a has_drum_tab flag so viz pickers can auto-activate the drums highway regardless of which guitar arrangement is selected. lib/gp2rs.py::convert_drum_track_to_drumtab converts a Guitar Pro drum track to a drum_tab.json dict, preserving velocity verbatim, mapping hi-hat openness through the canonical piece-ids, and flagging flam / ghost / cymbal-choke articulations from GP effects. lib/midi_import.py gains list_drum_tracks + convert_drum_track_from_midi (channel-9 only) with heuristic flam-collapse (≤30 ms same-piece) and choke detection (cymbal note-off ≤120 ms). docs/sloppak-spec.md §5.3 promotes drum_tab from worked-example to canonical with the closed piece-id table and wire format. Sloppaks without a drum_tab are unaffected; legacy drums-as-guitar-notes sloppaks keep playing via the drums plugin's fallback decoder.

• Loose folder support — a directory containing an audio file + arrangement XMLs, with optional manifest.json and album art, is now discovered, indexed, and playable as a first-class library format alongside Sloppak. The scanner walks DLC_DIR for non-preview audio files and treats each parent directory that also contains XMLs as a loose song. Metadata follows a manifest.json → XML tags → folder-name priority chain (see lib/loosefolder.py). Songs are tagged format: "loose", render an amber FOLDER badge in the library, and are filterable via the new "Folder" option in the format dropdown. Audio uses the shared vgmstream/convert_wem pipeline, cached under AUDIO_CACHE_DIR. The chart <offset> from the first non-vocals XML is now propagated to the frontend via song_info.offset and applied in highway.setTime() so loose folders authored against non-silence-padded audio stay in sync. Pairs with the companion feedBack-plugin-loosefolder plugin which adds an in-player Fix Sync UI for nudging and saving offset corrections.

• Highway note-state hook (#254). New highway.setNoteStateProvider(fn) lets a scorer plugin publish a per-note judgment ('hit' / 'active' for a sustain currently held correctly / 'miss', or { state, alpha, color }) so the renderer lights up the gem itself on a correct hit and keeps a sustain trail glowing while it's still being played right — instead of a separate overlay ring near the note. The built-in 2D highway honors it in drawNote / drawSustains / the chord-frame path (bright string colour + additive halo on hits, bright vs dim sustain trail, faint red wash on misses); the bundled 3D highway reads the same data via bundle.getNoteState (bright string-tinted outline + bright body + glowing sustain on hit/active, red outline + suppressed body on miss). Custom renderers opt in by calling bundle.getNoteState(note, chartTime). note_detect registers the provider (and still owns its HUD / diagnostic miss markers / "currently detected" indicator); renderers that ignore the hook simply don't light gems. On a confirmed hit/active the renderers add a contained "sparkle/sizzle" on the note — the 2D highway: additive throbbing halo + flickering hot core + crackling spark lines (+ an expanding shockwave ring on a fresh strike) on the gem and a glowing/jittery sustain trail; the 3D highway: a few twinkling bright dots and short crackling arc segments hugging the note's rectangle (no bloom past the note), drawn on its overlay and projected through the camera so they ride the note. Also adds highway.isDefaultRenderer() so overlays that position with the 2D-highway helpers (project / fretX) can skip rendering when a custom renderer is active — fixes note_detect's miss markers appearing in random places over the 3D highway. New 3D-highway setting Show note preview on the fretboard (on by default) toggles the board-projection ghost — the translucent preview of the upcoming note on the fretboard surface. (Note: the companion change in the note_detect plugin repo turns its full-screen green/red edge flash off by default and adds a toggle to re-enable it — ships separately with note_detect, not in this feedBack release.)

• Diagnostic bundle export (#166). New "Export Diagnostics" + "Preview Bundle" buttons in Settings produce a single redacted zip combining server logs (tail of LOG_FILE), system info (Python/OS/version), hardware probe (CPU model + cores + freq + RAM, GPU via nvidia-smi/rocm-smi/system_profiler, container/Electron/bare runtime detection), full plugin inventory with git SHA + remote URL (read directly from .git/HEAD so it works in minimal runtime images without git installed) + orphan/failed-to-load detection, the browser console transcript (all levels: log/info/warn/error/debug + window.onerror + unhandledrejection, 500-entry ring buffer), browser hardware (WebGL/WebGPU adapter info, navigator + userAgentData), filtered localStorage, and per-plugin contributed diagnostics. Top-level manifest.json lists every file with its versioned schema id (system.hardware.v1, client.console.v1, etc.) so AI agents can dispatch by schema. Redaction is on by default: DLC paths, song filenames (<song:HASH8> stable per-bundle), IPv4/IPv6 addresses, bearer tokens, and key=/token= query strings are replaced. Plugins opt their backend diagnostics in via a new diagnostics manifest field (server_files allowlist mirroring settings.server_files semantics, plus an optional callable: "<module>:<function>" resolved lazily via load_sibling). Frontend plugins push diagnostics via window.feedBack.diagnostics.contribute(plugin_id, payload). Three new endpoints: POST /api/diagnostics/export, GET /api/diagnostics/preview, GET /api/diagnostics/hardware. Full bundle format spec in docs/diagnostics-bundle-spec.md.

• Structured logging bootstrap (phase 1 of #155). Three new environment variables control server log output: LOG_LEVEL (default INFO), LOG_FORMAT (text for coloured console, json for one-JSON-object-per-line suitable for Loki/ELK/Promtail), and LOG_FILE (optional path, rotated at 10 MB with 5 backups). HTTP responses now include a X-Request-ID correlation header (via CorrelationIdMiddleware); the same request ID appears as request_id in structured log lines emitted via the stdlib logging / structlog APIs during that request.

• Structured logging migration completed (phase 2 of #155, #159, #242). The 42 print() calls and 6 traceback.print_exc() calls across server.py and lib/ have been migrated to levelled feedBack.* loggers. Silent except: pass blocks in lib/sloppak.py and lib/sloppak_convert.py now surface as log.warning / log.debug with the exception attached. WebSocket handlers (highway_ws, ws_retune) bind a ws_conn_id contextvar at accept time so every log line within a session carries a connection ID. A CI grep guard in .github/workflows/tests.yml fails the build if either print( or traceback.print_exc( reappears in server.py or lib/.

• Lyrics Karaoke plugin — end-to-end karaoke setup for Sloppak songs in one workflow. The setup screen shows a per-song checklist (vocals stem / synced lyrics / per-syllable pitch) and a single "Build Karaoke" button that runs whatever's missing: Whisper alignment of pasted lyric text against the vocals stem, then librosa.pyin pitch extraction. Both artifacts persist inside the Sloppak (lyrics.json, vocal_pitch.json). In the player, a "Karaoke" toggle swaps the text-lyrics overlay for a horizontal pitch ribbon (one bar per syllable, vertically positioned by pitch, sweeping playhead).

• Settings export/import (#113). Two buttons on the Settings page bundle server config, browser localStorage, and opted-in plugin server-side files into a single versioned JSON file for backup, migration, or sharing a calibrated setup. Server-side import is all-or-nothing for safety-critical failures: phase-1 validates the entire bundle (schema, path-traversal, encoding) before any disk writes; phase-2 commits each file via temp+rename. Plugin-state mismatches between export and import are handled leniently: files referenced for a plugin that isn't loaded are skipped with a warning, files referenced for a plugin whose manifest no longer declares them are skipped with a warning, and localStorage is merged (not cleared) so first-run defaults from plugins installed after the export are preserved. Path-traversal, absolute paths, schema mismatch, and decode failures remain hard refusals. Plugins opt their server-side files in by declaring settings.server_files in plugin.json (list of relpaths under CONFIG_DIR; trailing / denotes a directory).

• Library filtering by parts present or missing (#129, #69). New right-side Filters drawer (single button next to the format/sort row, with active-filter count badge and dismissible chips below) lets you require or exclude arrangements (Lead/Rhythm/Bass/Combo), specific stems on Sloppaks (drums/bass/vocals/piano/other), lyrics, and tuning. Multi-select within an axis is OR (Lead OR Rhythm); cross-axis is AND. State persists across reloads. New endpoint GET /api/library/tuning-names returns distinct tunings present in the library, ordered by musical distance.

• Sort library by year (#128). Two new options in the sort dropdown: "Year (newest)" and "Year (oldest)". Songs without a year are pushed to the bottom for both directions.

• highway.getLyrics() accessor. createHighway() now exposes the parsed timed lyric syllables ([{t, d, w}]) via getLyrics(), mirroring getBeats()/getSections(), so overlay plugins can render karaoke without opening a second highway WebSocket. Pure accessor; no behavior change.

Changed

• Perf (3D highway, feedBack#226): pre-warm plugins/highway_3d/screen.js object pools at board init. Previously the pool factory grew lazily on first .get() past the high-water mark, allocating a fresh T.Mesh mid-rAF on dense 7/8-string charts and stalling those frames; the meshes were then permanently added to noteG (the pool only hides on reset(), never removes), bloating the scene graph for the rest of the session. Pre-warming spends the cost up front. Fold the per-frame updateStringHighlights() per-string loop with the post-call mGlow/mAccentCore emissive writes — one walk over the per-string scratch arrays instead of two. Replace longestConsecutiveRun's per-call array allocations with a {start, len} index pair (trades two per-call sub-array allocations for one small 2-key object — net reduction in per-visible-chord allocation churn). Opt-in perf bench harness via ?h3dbench=1 URL param: console.log p50/p95/max for six update() segments every 5 seconds; when the URL flag is absent the mark helpers are bound to empty functions at renderer-instance init (each createHighway() panel re-checks the flag), so the hot-path calls are no-ops with negligible overhead (typically JIT-inlined).
• License: Relicensed to AGPL-3.0-only. Prior versions claimed MIT in the README, but the bundled desktop build statically links JUCE 8 (AGPL-3.0), so AGPL terms have effectively governed the desktop distribution since JUCE was added. AGPL-3.0-only is now the canonical license for the project — see LICENSE and CONTRIBUTING.md (DCO sign-off + plugin licensing policy). Bundled and vendored third-party code keeps its original license.
• Tuning sort is now ordered by musical distance from E Standard (#22) instead of alphabetical: E Standard first, then Drop D / F Standard at distance 2, then Eb Standard / F# Standard at distance 6, etc. Within a magnitude tier, down-tuned variants come before up-tuned, then alphabetical.
• Settings page restructured into separate "FeedBack" (core) and "Plugins" sections, with each plugin's settings rendered as a collapsible panel (collapsed by default). "Plugin Updates" moved into the Plugins section.
• Lyrics Sync is now a redirect stub. Its alignment + save endpoints moved into the new Lyrics Karaoke plugin alongside the pitch extraction. Existing nav entries and bookmarks land on a "moved" page that auto-redirects to the merged plugin.

Security

• Path traversal in archive extractors and library path resolution. lib/sloppak.py::_unpack_zip and server.py::_resolve_dlc_path previously concatenated attacker-controlled entry names or filenames directly onto the extraction or library directory, so a crafted sloppak zip member or library filename with .. segments, an absolute path, or backslash separators could write or read outside the intended directory. Any code path that unpacks a user-supplied archive (library upload, click-to-play, retune) or resolves a library path was reachable. Both locations now delegate to a new lib/safepath.py::safe_join helper that resolves each destination once and rejects entries that don't fall under the target directory; rejected entries are logged and skipped, the rest of the archive still extracts. The stem-split paths in lib/sloppak_convert.py::split_stems and scripts/split_stems.py previously called ZipFile.extractall() directly on user-supplied sloppaks; both now delegate to the same hardened lib/sloppak.py::_unpack_zip so every sloppak-unzip site in the codebase shares one containment guarantee. Tests in tests/test_archive_traversal.py and tests/test_safepath.py pin the contract for ../, deep traversal, absolute paths, mixed subdir/../../ forms, Windows-style separators, NUL bytes, names that resolve to the unpack root, and symlinked roots.

Fixed

• E Standard retune now stays metadata-consistent across a chart's arrangement files (feedBack-plugin-notedetect#50). Previously the retune path could shift the audio and update manifests while leaving some arrangement metadata untouched, so load_song() later exposed the original tuning at runtime. lib/retune.py now updates every arrangement's tuning metadata consistently before applying the E Standard tuning, and raises on a partial update instead of silently packing split tuning metadata. EStd files generated before this fix should be re-converted so their metadata is consistent.
• Keyboard shortcut help now opens from the Player/3D Highway context when Linux/Electron reports Shift+Slash as key="/", including while player controls such as the visualization picker are focused (#598).
• 3D Highway left-handed mode now has regression coverage for fret-axis mirroring, board rebuilds on runtime lefty changes, and mirrored camera state including the lookahead target and shoulder offset; the maintainer guide no longer claims the renderer ignores bundle.lefty (#321).
• Chord-level fretHandMute is now parsed into each note's fret_hand_mute (wire fhm) instead of being folded into mute (mt), matching _parse_note and preserving wire-format fidelity for both the template-expanded (synthetic-note) and explicit-chordNote paths. The 3D highway renders the fret-hand-mute X for mt or fhm notes, so the muted-chord overlay still shows. Also fixes the per-note fret-connector label vanishing exactly at the hit line (the fade now holds full opacity through dt = 0).
• gp2rs now respects the time-signature denominator when emitting ebeat subdivisions, fixing misaligned beat grids in 6/8 and other non-quarter-note meters.
• Settings dropdowns (Default Arrangement, Platform Filter) now persist immediately when changed. Previously a dropdown selection was only written to config.json when an unrelated "Save" button (Library Folder or Demucs Server) was clicked, so picking a default arrangement and navigating away silently discarded it. Both <select> controls now POST the single changed field on change via the partial-merge /api/settings endpoint, matching the auto-save behaviour of the A/V Sync Offset and mastery sliders. The text inputs (Library Folder Path, Demucs Server URL) keep their explicit Save buttons. Autosaves are sent through a single client-side queue (one request in flight at a time, in selection order), and the POST /api/settings handler now serializes its read-modify-write of config.json under a lock so concurrent partial updates can no longer overwrite each other and drop a key. The config write is also atomic (temp + rename) and /api/settings/import shares the same lock, so readers never observe a half-written file and a settings import can't race a concurrent partial save.
• Demucs stem split failing on Windows desktop with OSError: Could not load this library: libtorchcodec_core4.dll or ImportError: TorchCodec is required for save_with_torchcodec. The demucs subprocess now bootstraps a torchaudio.save → soundfile.write shim before importing demucs, sidestepping the torchcodec dependency entirely. The override stays in place across torchaudio versions — soundfile's WAV writes are behaviorally equivalent for demucs's float32 outputs.
• Splitscreen pop-out windows briefly flashed the library/song grid before showing the popped panel. A popup loads the full app (whose default screen, #home, is the library) and only swaps to the player once the splitscreen plugin loads; app init now detects ?ssFollower=1 and switches to the player screen up front, so the popup shows player chrome the whole time.
• Sloppak assembly dropped all tone data — affected sloppaks showed no signal chain in the Tones plugin and no tone-change markers on the highway. The assembler (lib/sloppak_convert.py) now lifts each arrangement's tones from the source chart via the new lib/tones.py helper and embeds them inline in the arrangement JSON under a tones key (base, changes, definitions — see docs/sloppak-spec.md §3.9). The highway WebSocket reads base/changes for sloppaks, and the Tones plugin (≥ 1.1.0) reads definitions to render the gear chain. Sloppaks built before this release carry no tone data and must be rebuilt from their source chart to gain it.
• Tab View (feedBack-plugin-tabview ≥ 3.0.1): the bottom row of tablature was permanently hidden behind the player controls bar (#336). The overlay reserved 60px at the top (clearing the transparent HUD) and extended all the way to the bottom of #player, where the opaque #player-controls (z-index 10) drew over the last row. The overlay now measures #player-hud and #player-controls dynamically and insets both edges; a ResizeObserver on the controls bar re-runs the inset when it wraps to a second row on narrow viewports.
• Tab View (feedBack-plugin-tabview ≥ 3.0.1): the cursor highlight led playback by roughly one beat (#336). alphaTab snaps tickPosition to the start of the next beat, so the cursor would race ahead by 500ms+ at typical tempos. The plugin now sends tickPosition one beat earlier so the snap lands on the current beat, and the highlight overlay tracks the bar cursor (.at-cursor-bar) instead of the next-beat cursor (.at-cursor-beat).

Migration notes

• Constitution amended to 1.1.0 (Principle II — Vanilla Frontend). Prebuilt Tailwind (static/tailwind.min.css) is now codified as non-negotiable: no Play CDN / runtime CSS JIT anywhere, core or plugin. Plugin authors: a plugin that uses Tailwind classes not guaranteed in core — especially arbitrary values like w-[37px] — MUST ship its own compiled stylesheet via the new styles manifest key, built with corePlugins.preflight = false. Plugins that use only core-guaranteed utilities, or that ship no Tailwind at all, need no change. Contributors: after adding any Tailwind class to core or a bundled plugin, run bash scripts/build-tailwind.sh and commit the regenerated CSS, or the tailwind-fresh CI job fails.
• The library filters depend on three new columns (stem_ids, tuning_name, tuning_sort_key) that are populated as songs are scanned. If filters look empty after upgrading, run Settings → Full Rescan to repopulate; alternatively the periodic background rescan picks them up over time.

[0.2.4] - 2026-04-22

Added

• Version badge in navbar (/api/version endpoint + VERSION file)
• CHANGELOG.md and semantic versioning
• Step Mode plugin
• gp2midi improvements and expanded test coverage
• Note Detection plugin factory-pattern refactor with multi-instance/splitscreen support
• Per-panel note detection in Split Screen plugin with M/L/R channel routing for multi-input interfaces

Fixed

• SLOPPAK_CACHE_DIR moved to CONFIG_DIR for AppImage compatibility
• Improved error message when plugin requirements fail to install