Default lookahead 8s -> 4s: don't hang unsung lines through gaps

Field report ("Marks Of The Evil One", authored syllable-timed lyrics
with short lines around ~6s instrumental gaps): with an 8s lookahead the
banner no longer hid during those gaps — it sat there showing the next
dim lines while nothing was being sung, which reads as "the lyrics are
out of sync". The highlight clock was never wrong (invariant-tested);
the preview policy was.

4s keeps the full upcoming-context win during dense singing (next lines
start within a couple of seconds) while instrumental gaps go blank like
they used to. Still live-tunable via highway.setLyricsDisplay(). New
regression test pins the mid-gap hide + within-lookahead return.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Signed-off-by: topkoa <topkoa@gmail.com>

.github/workflows/content-packs.yml

@@ -1,90 +0,0 @@
-name: Content packs
-
-# Build & publish opt-in career venue packs as per-pack, versioned, immutable
-# releases (convention: tag `venue-<id>-v<N>`, asset `<id>-pack-v<N>.zip`),
-# then open a PR bumping venues.json url/sha256/bytes. This is automation so
-# publishing packs is never a person's manual job (SLIM-NIGHTLY item 1b).
-#
-# Immutable tags → publishing is a deliberate, versioned act, so this runs on
-# manual dispatch (not push): a media change means a new version, a human call.
-on:
-  workflow_dispatch:
-    inputs:
-      venues:
-        description: "Space-separated venue ids to (re)publish, e.g. 'club arena'"
-        required: true
-        default: "club"
-      version:
-        description: "Pack version N (tag venue-<id>-vN). Bump for new media."
-        required: true
-        default: "1"
-
-concurrency:
-  group: content-packs
-  cancel-in-progress: false
-
-permissions:
-  contents: write
-  pull-requests: write
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        # Media lives in-tree today; add `lfs: true` once SLIM-NIGHTLY item 4
-        # moves venue-packs/** to Git LFS.
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-
-      - name: Build & publish packs
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          # Never interpolate dispatch inputs straight into the shell — a crafted
-          # value would execute on the runner with this job's write token. Pass
-          # via env, validate the formats, and use a Bash argument array.
-          VENUES: ${{ github.event.inputs.venues }}
-          VERSION: ${{ github.event.inputs.version }}
-        run: |
-          set -euo pipefail
-          [[ "$VERSION" =~ ^[1-9][0-9]*$ ]] || { echo "::error::version must be a positive integer"; exit 1; }
-          [[ "$VENUES" =~ ^[a-z0-9][a-z0-9-]*(\ [a-z0-9][a-z0-9-]*)*$ ]] || { echo "::error::venues must be space-separated venue ids"; exit 1; }
-          read -r -a venues <<< "$VENUES"
-          dirs=()
-          for v in "${venues[@]}"; do
-            dirs+=("plugins/career/venue-packs/$v")
-          done
-          python tools/content_packs.py "${dirs[@]}" \
-            --version "$VERSION" \
-            --publish \
-            --manifest /tmp/packs-manifest.json
-          cat /tmp/packs-manifest.json
-
-      - name: Apply url/sha256/bytes to venues.json
-        run: |
-          python - <<'PY'
-          import json, pathlib
-          manifest = json.load(open("/tmp/packs-manifest.json"))
-          vpath = pathlib.Path("plugins/career/venues.json")
-          data = json.loads(vpath.read_text())
-          for v in data["venues"]:
-              m = manifest.get(v["id"])
-              if m and v.get("pack"):
-                  v["pack"].update(url=m["url"], sha256=m["sha256"], bytes=m["bytes"])
-          vpath.write_text(json.dumps(data, indent=4) + "\n")
-          PY
-
-      - name: Open manifest-bump PR
-        uses: peter-evans/create-pull-request@v6
-        with:
-          commit-message: "career: refresh venue pack manifest (v${{ github.event.inputs.version }})"
-          title: "career: refresh venue pack manifest (v${{ github.event.inputs.version }})"
-          body: |
-            Automated by the content-packs workflow after publishing
-            `${{ github.event.inputs.venues }}` v${{ github.event.inputs.version }}
-            to their `venue-<id>-v${{ github.event.inputs.version }}` releases.
-            Bumps `venues.json` pack url/sha256/bytes to match the uploaded zips.
-          branch: content-packs/manifest-bump
-          delete-branch: true

CHANGELOG.md

@@ -8,52 +8,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
-- **Opt-in career venue packs (#122)** — higher-tier venue crowd media
-  (`club`, `arena`) is no longer bundled; the app downloads each pack on demand
-  from its release when you reach the venue (sha256-verified), keeping the
-  starter `bar` venue bundled for offline play. Trims ~678 MB from the desktop
-  download; an unpublished pack shows "coming soon" and plays on the standard
-  stage until its release lands.
-- **Session-sync relay WebSocket — `/ws/sync/{session_id}` (#1030).** A
-  deliberately dumb JSON fan-out room: a text frame received from one client is
-  forwarded verbatim to every other client on the same session id; the server
-  interprets nothing (message schemas are owned by consumers). Rooms are created
-  on first join and garbage-collected when the last socket leaves — no history,
-  no replay, no persistence, so a host that crashes and rejoins the same id
-  resumes publishing to reconnecting subscribers with no server-side
-  coordination. Session ids are client-generated (`[A-Za-z0-9_-]{4,64}`); DoS
-  hygiene for a LAN-exposed port via frame-size (16 KB), per-room (16 sockets),
-  total-room (32), and per-socket rate (120 msg/s sustained, 240 burst) caps —
-  over-limit sockets are closed with a policy code and the room carries on, and
-  a peer that dies — or stalls: fan-out sends are bounded by a 5 s timeout —
-  mid-fan-out is dropped without disturbing delivery to the rest. `main.py`
-  also caps inbound WS frames at the transport (`ws_max_size=64 KB`, down from
-  uvicorn's 16 MB default) so oversized frames never materialize server-side. First consumer: splitscreen's "pop out to LAN" follower mode
-  (feedBack-plugin-splitscreen#21), which relays playhead/playstate/song-change
-  frames from a host window to view-only followers on other LAN devices.
-  Implementation in `lib/routers/ws_sync.py`; tests in `tests/test_ws_sync.py`.
-- **Drum-part picker (feedpak 1.17.0 "drums as arrangements").** When a song
-  carries several drum charts, a **Drum part** selector appears beside the
-  arrangement switcher (advanced settings) so a player can choose which drummer
-  to play. Selecting one re-streams that part's tab over the highway WS
-  (`?drum_part=<id>`, mirroring the arrangement switch); the choice persists
-  across an arrangement change, and the picker reflects the server's
-  authoritative part (unknown/absent selection falls back to the primary). The
-  row hides for single-drum and non-drum songs, so nothing changes there. Builds
-  on the loader below; no plugin change needed — the drum renderer just draws
-  whatever tab streams.
-- **Multiple drum parts (feedpak 1.17.0 "drums as arrangements").** The sloppak
-  loader now reads `type: drums` arrangement entries carrying per-arrangement
-  `drum_tab` file pointers — a song can ship several drum charts (a second
-  drummer, an aux-percussion layer). Parts surface as `LoadedSloppak.drum_parts`
-  (primary first; the entry aliasing the song-level `drum_tab:` key is the
-  primary and is never loaded twice), the highway WS `song_info` gains a
-  `drum_parts` name list, and `?drum_part=<id>` on the WS URL selects which
-  part's tab streams (`drum_tab` messages carry `part_id` when multiple parts
-  exist; unknown ids fall back to the primary). Pointer entries are **never**
-  loaded as fretted arrangements — the loader's file/notation gate keeps a drum
-  part out of the fretted pipeline (and out of note-detection grading), pinned
-  by test. Legacy single-drum packs read exactly as before, as a one-part list.
 - **`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
@@ -125,9 +79,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   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. The whole group also greys out while the Venue scene
-  override is active, since none of the three controls reach a mounted style
-  in that mode.
+  renderer is selected.
 
 ### Changed
 - **`GET /api/song/{f}?stems=1`** (new, opt-in) — returns the pack's playable stem
@@ -183,11 +135,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
     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).
-- **Folder Library previews on hover, like the grid and list views.** The Folders
-  view's cards and rows now carry the standard `data-fn` / `data-v3-play` markup,
-  so the existing **Song Preview** plugin previews them on hover exactly like the
-  other views (same audio, same behaviour) — Folder Library ships no preview code
-  of its own.
 
 ### Added
 - **Genres fall back to MusicBrainz enrichment** — the effective genre now

lib/routers/ws_highway.py

@@ -26,7 +26,6 @@ from fastapi import APIRouter, WebSocket, WebSocketDisconnect
 
 from song import (
     anchor_to_wire,
-    arrangement_is_bass,
     arrangement_string_count,
     base_open_string_midis,
     chord_template_to_wire,
@@ -144,21 +143,9 @@ def _sanitize_authors(manifest: dict | None) -> list[dict]:
     return out
 
 
-def _drum_part_id_for_wire(drum_parts: list[dict] | None, selected_id: str | None) -> str | None:
-    """Expose a part id only when the pack genuinely has multiple parts."""
-    return selected_id if selected_id is not None and len(drum_parts or []) > 1 else None
-
-
 @router.websocket("/ws/highway/{filename:path}")
-async def highway_ws(websocket: WebSocket, filename: str, arrangement: int = -1,
-                     naming_mode: str = "legacy", drum_part: str = ""):
-    """Stream song data for the highway renderer over WebSocket.
-
-    `drum_part` selects WHICH drum part's tab streams when the pack carries
-    several (feedpak 1.17.0 "drums as arrangements") — a part id from
-    song_info's `drum_parts`. Empty / unknown ids fall back to the primary,
-    so a stale or mistyped selection degrades to today's behavior instead of
-    silencing drums."""
+async def highway_ws(websocket: WebSocket, filename: str, arrangement: int = -1, naming_mode: str = "legacy"):
+    """Stream song data for the highway renderer over WebSocket."""
     await websocket.accept()
     structlog.contextvars.bind_contextvars(ws_conn_id=uuid.uuid4().hex[:8])
 
@@ -274,8 +261,9 @@ async def highway_ws(websocket: WebSocket, filename: str, arrangement: int = -1,
                 bass_idxs = [
                     i
                     for i, a in enumerate(song.arrangements)
-                    if arrangement_is_bass(a)
+                    if getattr(a, "path_bass", False)
                     or (smart_names[i] or "").lower().startswith("bass")
+                    or "bass" in (getattr(a, "name", "") or "").lower()
                 ]
                 if bass_idxs:
                     # Among the bass parts: (1) honor the saved default-arrangement
@@ -576,15 +564,6 @@ async def highway_ws(websocket: WebSocket, filename: str, arrangement: int = -1,
             "has_drum_tab": bool(
                 is_slop and loaded_slop is not None and loaded_slop.drum_tab is not None
             ),
-            # The song's DRUM PARTS (feedpak 1.17.0 "drums as arrangements"),
-            # primary first — names only; the selected part's payload streams
-            # as the `drum_tab`/`drum_hits` messages below. Always a list
-            # (empty when the pack has no drums, and a single entry for a
-            # legacy one-drum pack), so a part picker can bind unconditionally.
-            "drum_parts": [
-                {"id": p["id"], "name": p["name"]}
-                for p in (loaded_slop.drum_parts or [])
-            ] if is_slop and loaded_slop is not None else [],
             "has_notation": bool(
                 is_slop
                 and loaded_slop is not None
@@ -608,36 +587,18 @@ async def highway_ws(websocket: WebSocket, filename: str, arrangement: int = -1,
         # client-side drums plugin keeps a fallback decoder for them.
         if is_slop and loaded_slop is not None and loaded_slop.drum_tab is not None:
             dt = loaded_slop.drum_tab
-            # Multiple drum parts: `?drum_part=<id>` picks which part's tab
-            # streams; the default (and any unknown id) is the PRIMARY —
-            # exactly the pre-parts behavior, so legacy clients notice nothing.
-            _dt_part_id = None
-            if loaded_slop.drum_parts:
-                _dt_part_id = loaded_slop.drum_parts[0]["id"]
-                if drum_part:
-                    for _p in loaded_slop.drum_parts:
-                        if _p["id"] == drum_part:
-                            dt = _p["drum_tab"]
-                            _dt_part_id = _p["id"]
-                            break
             kit = drums_mod.normalise_kit(dt.get("kit"))
             hits_wire = drums_mod.hits_to_wire(dt.get("hits") or [])
             _dt_name = dt.get("name")
             _dt_name = _dt_name if isinstance(_dt_name, str) and _dt_name else "Drums"
-            _dt_msg = {
-                "type": "drum_tab",
-                "version": int(dt.get("version", drums_mod.SCHEMA_VERSION)),
-                "name": _dt_name,
-                "kit": kit,
-                "total": len(hits_wire),
-            }
-            # Only multi-part packs identify a part on the wire. Legacy packs
-            # synthesize a one-item list internally but keep their old frame.
-            _wire_part_id = _drum_part_id_for_wire(loaded_slop.drum_parts, _dt_part_id)
-            if _wire_part_id is not None:
-                _dt_msg["part_id"] = _wire_part_id
             try:
-                await websocket.send_json(_dt_msg)
+                await websocket.send_json({
+                    "type": "drum_tab",
+                    "version": int(dt.get("version", drums_mod.SCHEMA_VERSION)),
+                    "name": _dt_name,
+                    "kit": kit,
+                    "total": len(hits_wire),
+                })
                 for i in range(0, len(hits_wire), 500):
                     await websocket.send_json({
                         "type": "drum_hits",
@@ -1014,7 +975,7 @@ async def highway_ws(websocket: WebSocket, filename: str, arrangement: int = -1,
         # base[string] + offset + capo + fret (matches the tuner / open-string
         # labels). arrangement_string_count is O(notes), so compute once here.
         _base = base_open_string_midis(
-            arrangement_string_count(arr), arrangement_is_bass(arr))
+            arrangement_string_count(arr), "bass" in (arr.name or "").lower())
         _capo = int(getattr(arr, "capo", 0) or 0)
 
         def _fill_scale_degree(wire: dict, n, t: float) -> None:

lib/routers/ws_sync.py

@@ -1,140 +0,0 @@
-"""Session-sync relay WebSocket — /ws/sync/{session_id} (feedBack#1030).
-
-A deliberately dumb fan-out room: a JSON text frame received from one client
-is forwarded verbatim to every OTHER client connected to the same session id.
-The server interprets nothing beyond the limits below — message schemas are
-owned entirely by consumers. First consumer: splitscreen's LAN follower mode
-(feedBack-plugin-splitscreen#21), which relays playhead/playstate/song-change
-frames from a host window to view-only followers on other LAN devices.
-
-Design points (full spec in the issue):
-
-- Rooms are created on first join and garbage-collected when the last socket
-  leaves. No history, no replay, no persistence — a late joiner simply waits
-  for the next frame. Consumers that need state on join re-send it themselves
-  (splitscreen answers every follower ``hello`` with a fresh ``config``).
-- That statelessness is what makes consumer crash-recovery work: a host that
-  relaunches and rejoins the same session id resumes publishing to its
-  reconnecting subscribers with no server-side coordination, and an idle room
-  is indistinguishable from a nonexistent one.
-- ``session_id`` is client-generated and opaque (``[A-Za-z0-9_-]{4,64}``);
-  consumers pick their own id policy (splitscreen uses a short typeable,
-  persistent room key).
-- DoS hygiene for a port that may be LAN-exposed: frame-size cap, per-room and
-  total-room caps, and a per-socket inbound token-bucket rate cap. Over-limit
-  sockets are closed with a policy code; the room carries on. A peer that dies
-  mid-fan-out is dropped without wedging delivery to the rest.
-"""
-
-import asyncio
-import logging
-import re
-import time
-
-from fastapi import APIRouter, WebSocket
-
-log = logging.getLogger("feedBack.server")
-
-router = APIRouter()
-
-_SESSION_ID_RE = re.compile(r"^[A-Za-z0-9_-]{4,64}$")
-
-# Limits. Sized generously above the first consumer's needs (splitscreen
-# publishes time frames at ~15-20 Hz to a handful of viewers) while bounding
-# what an open LAN port can be made to do. All module-level so tests (and a
-# desperate operator) can override them.
-MAX_FRAME_BYTES = 16 * 1024
-MAX_CLIENTS_PER_ROOM = 16
-MAX_ROOMS = 32
-RATE_MSGS_PER_SEC = 120.0  # sustained inbound frames per socket
-RATE_BURST = 240.0  # token-bucket burst headroom
-# A peer that stops draining its socket would leave send_text() pending
-# forever — and since publishers await the fan-out gather, one stalled peer
-# would stall every publisher's receive loop behind it. Bounding the send
-# turns the stall into an eviction through the normal failed-send drop path.
-SEND_TIMEOUT_SECONDS = 5.0
-
-# RFC 6455 close codes.
-_WS_UNSUPPORTED_DATA = 1003  # binary frame on a text-only relay
-_WS_POLICY_VIOLATION = 1008  # invalid session id / rate cap exceeded
-_WS_MSG_TOO_BIG = 1009
-_WS_TRY_AGAIN_LATER = 1013  # room or server at capacity
-
-# session_id → {socket: per-socket send lock}. The lock serializes concurrent
-# fan-out sends to the same peer (two publishers relaying at once must not
-# interleave writes on a third socket's transport).
-_rooms: dict[str, dict[WebSocket, asyncio.Lock]] = {}
-
-
-async def _send_locked(peer: WebSocket, lock: asyncio.Lock, text: str) -> None:
-    async with lock:
-        await asyncio.wait_for(peer.send_text(text), timeout=SEND_TIMEOUT_SECONDS)
-
-
-@router.websocket("/ws/sync/{session_id}")
-async def sync_ws(websocket: WebSocket, session_id: str):
-    """Join the fan-out room *session_id*; relay every inbound text frame."""
-    await websocket.accept()
-
-    if not _SESSION_ID_RE.fullmatch(session_id):
-        await websocket.close(code=_WS_POLICY_VIOLATION, reason="invalid session id")
-        return
-
-    # Capacity checks and insertion run with no await between them, so
-    # concurrent joiners on the event loop can't race past the caps.
-    room = _rooms.get(session_id)
-    if room is None:
-        if len(_rooms) >= MAX_ROOMS:
-            await websocket.close(code=_WS_TRY_AGAIN_LATER, reason="too many active sessions")
-            return
-        room = _rooms[session_id] = {}
-        log.debug("ws_sync: room %s created", session_id)
-    elif len(room) >= MAX_CLIENTS_PER_ROOM:
-        await websocket.close(code=_WS_TRY_AGAIN_LATER, reason="session full")
-        return
-    room[websocket] = asyncio.Lock()
-
-    tokens = RATE_BURST
-    last_refill = time.monotonic()
-
-    try:
-        while True:
-            message = await websocket.receive()
-            if message["type"] == "websocket.disconnect":
-                break
-            text = message.get("text")
-            if text is None:
-                await websocket.close(code=_WS_UNSUPPORTED_DATA, reason="text frames only")
-                break
-            if len(text.encode("utf-8", errors="ignore")) > MAX_FRAME_BYTES:
-                await websocket.close(code=_WS_MSG_TOO_BIG, reason="frame too large")
-                break
-
-            now = time.monotonic()
-            tokens = min(RATE_BURST, tokens + (now - last_refill) * RATE_MSGS_PER_SEC)
-            last_refill = now
-            tokens -= 1.0
-            if tokens < 0:
-                await websocket.close(code=_WS_POLICY_VIOLATION, reason="rate cap exceeded")
-                break
-
-            peers = [(ws, lock) for ws, lock in room.items() if ws is not websocket]
-            if not peers:
-                continue
-            results = await asyncio.gather(
-                *(_send_locked(ws, lock, text) for ws, lock in peers),
-                return_exceptions=True,
-            )
-            # A peer that failed mid-send is dropped from the room here; its
-            # own handler finishes cleanup (the finally below) when its
-            # receive loop observes the disconnect.
-            for (peer, _lock), result in zip(peers, results):
-                if isinstance(result, Exception):
-                    room.pop(peer, None)
-    finally:
-        room.pop(websocket, None)
-        # Guard against deleting a NEW room another joiner created after this
-        # one emptied (only possible for a dict that is no longer ours).
-        if not room and _rooms.get(session_id) is room:
-            del _rooms[session_id]
-            log.debug("ws_sync: room %s closed", session_id)

lib/sloppak.py

@@ -730,125 +730,6 @@ class LoadedSloppak:
     # separated stems the moment one drops below 100% — demucs recombination is
     # lossy, so the mixdown is strictly the better audio when nothing is muted.
     full_mix: str | None = None
-    # The song's DRUM PARTS (feedpak 1.17.0 "drums as arrangements"): one dict
-    # {"id", "name", "drum_tab"} per part, primary FIRST. A part comes from a
-    # `type: drums` arrangement entry carrying a per-arrangement `drum_tab`
-    # file pointer and NO note `file` — entries this loader deliberately never
-    # turns into fretted Arrangements (see the file/notation gate in
-    # load_song; that skip IS the grading invariant). The primary part's
-    # payload is the SAME object as `drum_tab` above (the song-level key is
-    # its back-compat alias). None when the pack has no drums at all; a
-    # single-part list for a legacy pack with only the song-level key.
-    drum_parts: list[dict] | None = None
-
-
-def _load_drum_tab_file(source_dir: Path, rel: str, label: str) -> dict | None:
-    """Load + schema-validate one drum-tab JSON named by a manifest-relative
-    path. Shared by the song-level `drum_tab:` key and the per-arrangement
-    drum-part pointers (feedpak 1.17.0), so every tab gets the same posture:
-    permissive — a missing file disables that part silently; a traversal,
-    parse, or validation failure disables it with a warning, never aborting
-    the load."""
-    # Constrain to source_dir to prevent a crafted manifest from reading
-    # files outside the sloppak directory via path traversal (e.g. ../../etc).
-    # Wrap both resolve() calls in a broad handler: symlink loops and
-    # permission errors on .resolve() should disable drums, not abort load.
-    try:
-        dt_path = (source_dir / rel).resolve()
-        dt_path.relative_to(source_dir.resolve())
-    except ValueError:
-        log.warning("sloppak: %s path %r escapes source_dir — skipped", label, rel)
-        return None
-    except OSError as e:
-        log.warning("sloppak: %s path resolution failed (%s) — skipped", label, e)
-        return None
-    if not dt_path.exists():
-        return None
-    try:
-        raw = load_json(dt_path)
-    except Exception as e:
-        log.warning("sloppak: failed to parse %s %r: %s", label, rel, e)
-        return None
-    ok, reason = drums_mod.validate_drum_tab(raw)
-    if not ok:
-        log.warning("sloppak: %s %r failed validation: %s", label, rel, reason)
-        return None
-    return raw
-
-
-def _resolve_drum_parts(
-    source_dir: Path,
-    drum_tab_rel: object,
-    drum_tab_data: dict | None,
-    drum_pointer_entries: list[dict],
-) -> tuple[dict | None, list[dict] | None]:
-    """Resolve drum pointers into a primary-first list with unique ids."""
-    if drum_tab_data is None and not drum_pointer_entries:
-        return drum_tab_data, None
-
-    primary_id = "drums"
-    primary_name = None
-    extra_parts: list[dict] = []
-    seen_rels: set[str] = set()
-    # Use the same canonical, traversal-safe identity as zip member lookup so
-    # equivalent spellings ("x.json", "./x.json", or backslashes) identify
-    # one file. Otherwise an alias pointer can reload and duplicate the primary.
-    primary_rel_key = (
-        _zip_member_key(drum_tab_rel.strip())
-        if isinstance(drum_tab_rel, str) and drum_tab_rel.strip() else None
-    )
-    for entry in drum_pointer_entries:
-        rel = str(entry.get("drum_tab") or "").strip()
-        rel_key = _zip_member_key(rel) if rel else None
-        rel_identity = rel_key or rel
-        if not rel or rel_identity in seen_rels:
-            continue
-        seen_rels.add(rel_identity)
-        entry_id = str(entry.get("id") or "").strip()
-        entry_name = str(entry.get("name") or "").strip()
-        if primary_rel_key is not None and rel_key == primary_rel_key:
-            if entry_id:
-                primary_id = entry_id
-            if entry_name:
-                primary_name = entry_name
-            continue
-        tab = _load_drum_tab_file(source_dir, rel, f"drum part {entry_id or rel}")
-        if tab is None:
-            continue
-        tab_name = tab.get("name")
-        extra_parts.append({
-            "id": entry_id,
-            "name": entry_name
-                or (tab_name if isinstance(tab_name, str) and tab_name else "Drums"),
-            "drum_tab": tab,
-        })
-
-    parts: list[dict] = []
-    used_ids: set[str] = set()
-    if drum_tab_data is not None:
-        if primary_name is None:
-            tab_name = drum_tab_data.get("name")
-            primary_name = tab_name if isinstance(tab_name, str) and tab_name else "Drums"
-        parts.append({"id": primary_id, "name": primary_name, "drum_tab": drum_tab_data})
-        used_ids.add(primary_id)
-
-    next_generated_id = 2
-    for part in extra_parts:
-        part_id = part["id"]
-        if not part_id or part_id in used_ids:
-            while f"drums-{next_generated_id}" in used_ids:
-                next_generated_id += 1
-            part_id = f"drums-{next_generated_id}"
-            next_generated_id += 1
-        part["id"] = part_id
-        used_ids.add(part_id)
-        parts.append(part)
-
-    if not parts:
-        return drum_tab_data, None
-    if drum_tab_data is None:
-        drum_tab_data = parts[0]["drum_tab"]
-    return drum_tab_data, parts
 
 
 def load_song(
@@ -873,7 +754,6 @@ def load_song(
     notation_acc: dict[str, dict] = {}
     any_notation = False
     arrangement_ids_acc: list[str | None] = []  # parallel to song.arrangements
-    drum_pointer_entries: list[dict] = []  # feedpak 1.17.0 drum-part pointers
     for entry in manifest.get("arrangements", []) or []:
         if not isinstance(entry, dict):
             log.warning("sloppak: non-dict arrangement entry skipped (%r)", type(entry).__name__)
@@ -882,30 +762,7 @@ def load_song(
         rel = rel_raw.strip() if isinstance(rel_raw, str) else ""
         notation_raw = entry.get("notation")
         has_notation_key = isinstance(notation_raw, str) and bool(notation_raw.strip())
-        _etype = str(entry.get("type") or "").strip().lower()
-        is_drums = _etype in ("drums", "drum")
-        # A drums-typed entry MUST NEVER become a fretted Arrangement (grading
-        # invariant, spec §5.2/§7.5): route on `type` FIRST, not on file
-        # absence — a malformed drums entry that also carries a note file/
-        # notation would otherwise fall through and grade as garbage.
-        if is_drums or (not rel and not has_notation_key):
-            # A DRUM-PART POINTER entry (feedpak 1.17.0 "drums as
-            # arrangements"): `type: drums` with a per-arrangement `drum_tab`
-            # file. Collect it for the drum-parts load after this loop.
-            if is_drums and isinstance(entry.get("drum_tab"), str):
-                drum_pointer_entries.append(entry)
-            elif is_drums:
-                # Drums-typed but no drum_tab pointer — drop it (any note
-                # file/notation it carries is ignored), never fret it.
-                log.warning(
-                    "sloppak: drums-typed arrangement entry %r has no drum_tab pointer — dropped",
-                    entry.get("id"),
-                )
-            elif isinstance(entry.get("drum_tab"), str):
-                log.warning(
-                    "sloppak: arrangement entry has drum_tab %r but type=%r — ignored",
-                    entry.get("drum_tab"), entry.get("type"),
-                )
+        if not rel and not has_notation_key:
             continue
         data = None
         if rel:
@@ -935,11 +792,6 @@ def load_song(
         # the arrangement JSON (name, tuning, capo, centOffset).
         if entry.get("name"):
             arr.name = str(entry["name"])
-        # Editor-authored instrument type (feedpak-spec §5.2 / editor PR #335).
-        # Drives arrangement_string_count's bass fallback so a bass authored on
-        # an arrangement whose NAME doesn't say "bass" still reports 4 strings.
-        if entry.get("type"):
-            arr.type = str(entry["type"]).strip().lower()
         if "tuning" in entry:
             arr.tuning = list(entry["tuning"])
         if "capo" in entry:
@@ -1016,13 +868,32 @@ def load_song(
     drum_tab_data: dict | None = None
     drum_tab_rel = manifest.get("drum_tab")
     if isinstance(drum_tab_rel, str) and drum_tab_rel:
-        drum_tab_data = _load_drum_tab_file(source_dir, drum_tab_rel, "drum_tab")
-
-    # Keep the dense compatibility logic independently testable and guarantee
-    # ids are unique before the highway exposes them as selectors.
-    drum_tab_data, drum_parts = _resolve_drum_parts(
-        source_dir, drum_tab_rel, drum_tab_data, drum_pointer_entries,
-    )
+        # Constrain to source_dir to prevent a crafted manifest from reading
+        # files outside the sloppak directory via path traversal (e.g. ../../etc).
+        # Wrap both resolve() calls in a broad handler: symlink loops and
+        # permission errors on .resolve() should disable drums, not abort load.
+        try:
+            dt_path = (source_dir / drum_tab_rel).resolve()
+            dt_path.relative_to(source_dir.resolve())
+        except ValueError:
+            log.warning("sloppak: drum_tab path %r escapes source_dir — skipped", drum_tab_rel)
+            dt_path = None
+        except OSError as e:
+            log.warning("sloppak: drum_tab path resolution failed (%s) — skipped", e)
+            dt_path = None
+        if dt_path is not None and dt_path.exists():
+            try:
+                raw = load_json(dt_path)
+            except Exception as e:
+                log.warning("sloppak: failed to parse drum_tab %r: %s", drum_tab_rel, e)
+                raw = None
+            if raw is not None:
+                ok, reason = drums_mod.validate_drum_tab(raw)
+                if ok:
+                    drum_tab_data = raw
+                else:
+                    log.warning("sloppak: drum_tab %r failed validation: %s",
+                                drum_tab_rel, reason)
 
     # Drum-only sloppak: every GP track was percussion, so it ships a
     # drum_tab but no pitched arrangements. The highway WS rejects an empty
@@ -1350,7 +1221,6 @@ def load_song(
         manifest=manifest,
         feedpak_version=_fpv if isinstance(_fpv, str) and _fpv else None,
         drum_tab=drum_tab_data,
-        drum_parts=drum_parts,
         song_timeline=song_timeline_data,
         tempos=tempos_data,
         time_signatures=time_sigs_data,

lib/song.py

@@ -182,12 +182,6 @@ class Arrangement:
     # `base`/`changes` drive the highway tone-change markers; `definitions`
     # feed the Tones plugin gear panel.
     tones: dict | None = None
-    # Editor-authored instrument type (feedpak-spec §5.2 / editor PR #335):
-    # "bass" | "guitar" | "piano" | "keys" | "drums" | "". First-class DATA that
-    # lets a user author an instrument on an arrangement whose NAME doesn't say
-    # so. Lifted from the sloppak manifest entry by sloppak.load_song(); "" for
-    # archive/loose sources, which instead carry the path_* flags below.
-    type: str = ""
     # arrangement XML <arrangementProperties> flags for smart naming (feedBack feat/arrangement).
     # Populated from the XML; default False/0 for sloppak / GP-imported sources.
     path_lead: bool = False
@@ -509,8 +503,8 @@ def note_pitch_midi(arr: "Arrangement", note: "Note") -> int | None:
     O(notes) via ``arrangement_string_count`` — for a whole arrangement, hoist
     the base with :func:`base_open_string_midis` and call :func:`pitch_from_base`
     per note instead."""
-    base = base_open_string_midis(arrangement_string_count(arr),
-                                  arrangement_is_bass(arr))
+    is_bass = "bass" in (arr.name or "").lower()
+    base = base_open_string_midis(arrangement_string_count(arr), is_bass)
     return pitch_from_base(base, int(getattr(arr, "capo", 0) or 0),
                            arr.tuning or [], note.string, note.fret)
 
@@ -639,23 +633,6 @@ def phrase_from_wire(d: dict) -> Phrase:
     )
 
 
-def arrangement_is_bass(arr: Arrangement) -> bool:
-    """Whether ``arr`` is a bass, most-authoritative signal first: an
-    editor-authored ``type == "bass"`` (feedpak-spec §5.2 / editor PR #335,
-    lifted onto sloppaks by :func:`sloppak.load_song`), then the archive
-    ``path_bass`` <arrangementProperties> flag, then the legacy "bass"
-    case-insensitive substring in the name. Single source of the bass decision
-    so string-count derivation and the open-string pitch base (via
-    :func:`base_open_string_midis`) agree — a bass authored on an arrangement
-    whose NAME doesn't say "bass" must get both 4 lanes AND the bass MIDI base,
-    not 4 lanes on a guitar octave."""
-    return (
-        (arr.type or "").strip().lower() == "bass"
-        or bool(arr.path_bass)
-        or "bass" in (arr.name or "").lower()
-    )
-
-
 def arrangement_string_count(arr: Arrangement) -> int:
     """Derive the active arrangement's string count.
 
@@ -673,17 +650,10 @@ def arrangement_string_count(arr: Arrangement) -> int:
        But this is a LOWER BOUND only — a 6-string lead chart that
        never plays string 5 reports 5, undercounting by 1.
 
-    2. **Instrument-type fallback.** An arrangement whose authoritative
-       instrument signal says bass defaults to 4; everything else
-       defaults to 6. This catches the partial-string-usage case where
-       notes don't span all the instrument's strings. The bass signal is
-       any of: an editor-authored ``type == "bass"`` (feedpak-spec §5.2 /
-       editor PR #335 — lifted onto sloppaks by ``sloppak.load_song``),
-       the ``path_bass`` <arrangementProperties> flag (archive/DLC
-       sources), or the legacy "bass" case-insensitive substring in the
-       name. Trusting ``type``/``path_bass`` closes the gap where a user
-       authors a bass instrument on an arrangement whose NAME doesn't say
-       "bass" (the editor lays out 4 lanes; core must agree).
+    2. **Name-based fallback.** Arrangements named "Bass" (case-
+       insensitive substring match) default to 4; everything else
+       defaults to 6. This catches the partial-string-usage case
+       where notes don't span all the instrument's strings.
 
     A third signal — ``len(arr.tuning)`` when it isn't the arrangement XML
     padded value of 6 — folds in for sloppak / GP-imported sources
@@ -714,10 +684,6 @@ def arrangement_string_count(arr: Arrangement) -> int:
       max(0, 4, 0) = 4
     * Empty arrangement named "Lead" (tuning len 6) →
       max(0, 6, 0) = 6
-    * Editor-authored bass named "Low End" (type "bass", tuning len 6,
-      notes 0..3) → name_based=4 → max(4, 4, 0) = 4
-    * DLC bass named "Low End" (pathBass flag set, tuning len 6, notes
-      0..3) → name_based=4 → max(4, 4, 0) = 4
 
     Topkoa's issue argues plugins shouldn't do arrangement-name
     matching; server-side fallback IS the right place for it
@@ -733,9 +699,7 @@ def arrangement_string_count(arr: Arrangement) -> int:
             if cn.string > max_s:
                 max_s = cn.string
     notes_count = max_s + 1 if max_s >= 0 else 0
-    # Bass signal (type / pathBass / name substring) — see arrangement_is_bass.
-    # Any one being bass pulls the fallback to 4.
-    name_based = 4 if arrangement_is_bass(arr) else 6
+    name_based = 4 if "bass" in arr.name.lower() else 6
     # Tuning-length signal — only trustworthy when NOT the arrangement XML
     # padded value of 6. Length 4/5 indicates explicit bass / 5-string
     # bass; length 7/8 indicates an extended-range guitar from GP.

main.py

@@ -44,13 +44,6 @@ def run() -> None:
         # record — including early startup messages — passes through the same
         # structured pipeline.
         log_config=None,
-        # Cap inbound WebSocket frames at the transport, before uvicorn
-        # materializes them in memory (its default is 16 MB). No client sends
-        # large frames to this server: the highway WS receives only small
-        # control messages, and the /ws/sync relay enforces its own tighter
-        # 16 KB application cap (routers/ws_sync.py MAX_FRAME_BYTES) — this is
-        # the defense-in-depth bound above it.
-        ws_max_size=64 * 1024,
     )
 
 

plugins/career/routes.py

@@ -104,13 +104,6 @@ def _bundled(venue_id):
     return (_bundled_venue_dir(venue_id) / "manifest.json").is_file()
 
 
-def _pack_published(pack):
-    """A remote pack is downloadable only once a publish has stamped its real
-    size — the committed manifest carries a 0-byte placeholder (and an all-zero
-    sha) until then, so don't offer a download that can't succeed yet."""
-    return bool(pack and (pack.get("bytes") or 0) > 0)
-
-
 def _stars():
     """(total, per-song dict, detail rows). Accuracy is a 0..1 fraction."""
     db = _state["meta_db"]
@@ -671,7 +664,7 @@ def setup(app, context):
                 "unlocked": stars_total >= v["star_threshold"],
                 "installed": _installed(v["id"]),
                 "bundled": _bundled(v["id"]),
-                "has_pack": _bundled(v["id"]) or _pack_published(v.get("pack")),
+                "has_pack": _bundled(v["id"]) or bool(v.get("pack")),
                 "download": dl,
             })
         return {
@@ -941,7 +934,7 @@ def setup(app, context):
         if venue is None:
             raise HTTPException(404, "Unknown venue.")
         pack = venue.get("pack")
-        if not _pack_published(pack):
+        if not pack:
             raise HTTPException(404, "No pack published for this venue yet.")
         stars_total, _, _ = _stars()
         if stars_total < venue["star_threshold"]:

plugins/career/venues.json

@@ -17,22 +17,14 @@
             "name": "Velvet Room",
             "description": "A proper club stage. People actually came to hear you.",
             "star_threshold": 50,
-            "pack": {
-                "url": "https://github.com/got-feedBack/feedBack/releases/download/venue-club-v1/club-pack-v1.zip",
-                "sha256": "0000000000000000000000000000000000000000000000000000000000000000",
-                "bytes": 0
-            }
+            "pack": null
         },
         {
             "id": "arena",
             "name": "Feedback Arena",
             "description": "Ten thousand seats. Try not to think about it.",
             "star_threshold": 150,
-            "pack": {
-                "url": "https://github.com/got-feedBack/feedBack/releases/download/venue-arena-v1/arena-pack-v1.zip",
-                "sha256": "8898c7912c84123559ecfd8b0afd3be19da9a0a4b04aa9dbb5aa1e7f4e3e1669",
-                "bytes": 351284599
-            }
+            "pack": null
         }
     ]
 }

plugins/folder_library/CLAUDE.md

@@ -160,7 +160,6 @@ Each song object (built by `_meta()`):
 - `filename` is the full relative path from the DLC root — pass it directly to `window.playSong()`.
 - `added` is a Unix timestamp (float, seconds) from `stat().st_mtime` — convert with `new Date(added * 1000)`. Always recomputed fresh (it changes when a file moves), even on a metadata-cache hit.
 - `arrangements` / `stems` are flat lists of **strings**, even though `extract_meta()` returns them as objects.
-- Hover-preview isn't resolved here at all — the cards just carry `data-fn`/`data-v3-play` markup and the `song_preview` plugin handles it (see Preview on Hover).
 
 ### extract_meta returns arrangements/stems as objects, not strings
 
@@ -330,21 +329,13 @@ Drag-and-drop uses **pointer events** (mousedown/mousemove/mouseup), not the HTM
 - **Esc cancels** — resolves with `null`, same as Cancel (applies to rename, delete, create folder/subfolder, move song)
 - **Enter confirms** — submits, equivalent to OK
 
-## Preview on Hover
-
-The Folder Library does **not** implement hover-preview itself — the `song_preview` plugin does, for the whole app. Its hover loop finds song elements by the selector `#v3-songs [data-fn]` (with a `[data-v3-play]` playable surface) and its `MutationObserver` watches the `#v3-songs` subtree — and the folder view (`#lib-folder-tree`) renders **inside** `#v3-songs`. So all folder_library has to do is give each card/row the standard markup:
-
-- **`_songCard`** — `card.dataset.fn = song.filename` (raw filename) + `data-v3-play` on the art wrap (the surface `song_preview` overlays its indicator on).
-- **`_songRow`** — `row.dataset.fn = song.filename` + `data-v3-play` on the thumb.
-
-`song_preview` then previews folder view exactly like the grid/list — same audio (its `/audio` endpoint), same availability/404 handling, same indicator — with **zero preview code here**. If you change the card/row structure, keep `data-fn` (raw, not URL-encoded) and a `[data-v3-play]` descendant, or `song_preview` will stop recognising the cards.
-
 ## Roadmap
 
-Implemented since the original release: **nested subfolders** (recursive tree + create-inside-folder), drag-and-drop, sort, advanced filtering, server-side tree filtering synced to the host library, and the warm metadata cache. Hover-preview is provided by the `song_preview` plugin via the `data-fn` markup above (not implemented here).
+Implemented since the original release: **nested subfolders** (recursive tree + create-inside-folder), drag-and-drop, sort, advanced filtering, server-side tree filtering synced to the host library, and the warm metadata cache.
 
 Not yet implemented, in rough priority order:
 
+- **Auto-play on hover** — with an on/off toggle saved to localStorage.
 - **Bulk move** — multi-select songs and move them all at once.
 - **Thumbnail performance** — faster loading and smoother scrolling with large libraries.
 - **Adjustable thumbnail/row sizes** — user-resizable song cards and list rows.

plugins/folder_library/README.md

@@ -30,7 +30,6 @@ A FeedBack (fee[dB]ack) plugin that organizes your `.sloppak` / `.feedpak` DLC s
 - **List & Grid views** — toggle between a compact list with thumbnails or a full album art card grid
 - **Album art** — pulls art automatically for every song in both views
 - **One-click playback** — click any song to start playing immediately
-- **Preview song on hover** — hover a song to hear a quick preview of its audio (powered by the Song Preview plugin, the same way the grid and list views work)
 - **Sort options** — sort songs by title, artist, duration, year, tuning, or recently added with an asc/desc toggle
 - **Advanced filters** — filter by arrangements, stems, lyrics, and tuning with include and exclude support
 - **Folder management** — create, rename, and delete folders without leaving the plugin
@@ -55,7 +54,6 @@ Folder Library ships bundled with FeedBack as a core plugin (`"bundled": true`),
 | Switch to grid view | Click the grid icon in the toolbar |
 | Switch to list view | Click the list icon in the toolbar |
 | Play a song | Click any song row or card |
-| Preview song on hover | Hover a song — the Song Preview plugin plays a quick clip (same as the grid/list views) |
 | Sort songs | Use the sort dropdown in the toolbar |
 | Toggle sort direction | Click the arrow button next to the sort dropdown |
 | Open filters | Click the filter icon in the toolbar |
@@ -82,8 +80,7 @@ Folder Library started life as a standalone plugin with its own version line, bu
 
 ## Roadmap
 
-- [ ] Compatibility with core settings — respect Accessibility → Interface size
-- [ ] Core parity — Metadata, Unmatched, and Upload should work in the folder view too
+- [ ] Auto play song on hover (with an on/off toggle)
 - [ ] Bulk move — select multiple songs and move them at once
 - [ ] Thumbnail performance — faster loading and smoother scrolling with large song libraries
 - [ ] Adjustable thumbnail and row sizes — resize song cards and list rows to suit your preference

plugins/folder_library/plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "folder_library",
   "name": "Folder Library",
-  "version": "1.9.0",
+  "version": "1.8.0",
   "bundled": true,
   "nav": { "label": "Folders", "screen": "plugin-folder_library" },
   "screen": "screen.html",

plugins/folder_library/screen.js

@@ -735,11 +735,10 @@ function createFolderSurface(cfg) {
         var card = document.createElement('div');
         card.className = 'flex flex-col rounded-lg overflow-hidden cursor-pointer group transition-transform duration-100 hover:scale-105';
         card.style.background = '#1a1d2e';
-        card.dataset.fn = song.filename;   // data-fn (raw): song_preview's hover loop finds cards by this
+        card.dataset.filename  = song.filename;
 
         var artWrap = document.createElement('div');
         artWrap.style.cssText = 'position:relative; width:100%; padding-bottom:100%; background:#111827; overflow:hidden;';
-        artWrap.setAttribute('data-v3-play', '');   // the playable surface song_preview overlays its indicator on
         var img = document.createElement('img');
         img.style.cssText = 'position:absolute; inset:0; width:100%; height:100%; object-fit:cover;';
         img.alt = ''; img.loading = 'lazy';
@@ -805,11 +804,10 @@ function createFolderSurface(cfg) {
     function _songRow(song, folderName) {
         var row = document.createElement('div');
         row.className = 'flex items-center gap-3 px-3 py-2 rounded cursor-pointer hover:bg-dark-500 group transition-colors duration-100';
-        row.dataset.fn = song.filename;   // data-fn (raw): song_preview's hover loop finds rows by this
+        row.dataset.filename = song.filename;
 
         var thumb = document.createElement('div');
         thumb.style.cssText = 'width:36px; height:36px; border-radius:4px; overflow:hidden; background:#111827; flex-shrink:0; position:relative;';
-        thumb.setAttribute('data-v3-play', '');   // marks the row previewable for song_preview
         var tImg = document.createElement('img');
         tImg.loading = 'lazy';
         tImg.src = '/api/song/' + song.filename.split('/').map(encodeURIComponent).join('/') + '/art';
@@ -1709,16 +1707,8 @@ function createFolderSurface(cfg) {
         init: _init,
         onScreenChanged: _onScreenChanged,
         render: _render,
-        // Helpers exposed for tests. visibleWindow is pure; songCard/songRow
-        // need a DOM (the tests supply a minimal element mock) and pin the
-        // song_preview integration markup (data-fn + a data-v3-play surface).
-        __test: {
-            visibleWindow: _visibleWindow,
-            VIRTUAL_MIN: VIRTUAL_MIN,
-            VIRTUAL_BUFFER: VIRTUAL_BUFFER,
-            songCard: _songCard,
-            songRow: _songRow,
-        },
+        // Pure window arithmetic, exposed for tests (no DOM needed).
+        __test: { visibleWindow: _visibleWindow, VIRTUAL_MIN: VIRTUAL_MIN, VIRTUAL_BUFFER: VIRTUAL_BUFFER },
     };
 }
 

plugins/folder_library/tests/song_preview_markup.test.js

@@ -1,116 +0,0 @@
-// song_preview integration markup (feedBack — Folders view hover preview).
-//
-// The Folder Library does NOT implement hover-preview itself. It relies on the
-// separate `song_preview` plugin, exactly like the grid and list views. That
-// plugin's host adapter finds previewable elements with the selector
-// `#v3-songs [data-fn]` and requires each to contain a `[data-v3-play]`
-// descendant (the surface it overlays its indicator on), reading the raw
-// filename from `data-fn`.
-//
-// So the ENTIRE contract Folder Library owns is: every song card and row it
-// renders must carry `data-fn` (raw filename) and expose a `[data-v3-play]`
-// surface. If a refactor drops either, folder cards silently stop previewing
-// while grid/list keep working — a regression that's invisible without a live
-// song_preview install. These tests pin the markup so that can't happen.
-
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const vm = require('node:vm');
-
-// A minimal DOM element mock — just enough for _songCard / _songRow to run.
-// No jsdom in this repo (see virtual_list.test.js); the element tracks the few
-// things the contract cares about: dataset, attributes, and a child tree that
-// querySelector('[data-v3-play]') can walk.
-function makeEl(tag) {
-    const attrs = {};
-    const el = {
-        tagName: String(tag || '').toUpperCase(),
-        style: {},              // supports .cssText and arbitrary props
-        dataset: {},
-        className: '',
-        children: [],
-        parentNode: null,
-        addEventListener() {},
-        removeEventListener() {},
-        setAttribute(k, v) { attrs[k] = String(v); },
-        getAttribute(k) { return k in attrs ? attrs[k] : null; },
-        hasAttribute(k) { return k in attrs; },
-        appendChild(child) { el.children.push(child); if (child) child.parentNode = el; return child; },
-        classList: { add() {}, remove() {}, contains() { return false; }, toggle() {} },
-        remove() {},
-        // Only the '[data-v3-play]'-style attribute selector is needed.
-        querySelector(sel) {
-            const attr = sel.replace(/^\[|\]$/g, '');
-            const stack = el.children.slice();
-            while (stack.length) {
-                const n = stack.shift();
-                if (n && n.hasAttribute && n.hasAttribute(attr)) return n;
-                if (n && n.children) stack.push(...n.children);
-            }
-            return null;
-        },
-    };
-    return el;
-}
-
-function load() {
-    const window = {
-        console,
-        document: {
-            readyState: 'complete',
-            addEventListener() {},
-            getElementById() { return null; },
-            querySelector() { return null; },
-            querySelectorAll() { return []; },
-            createElement(tag) { return makeEl(tag); },
-        },
-        addEventListener() {},
-        localStorage: { getItem() { return null; }, setItem() {} },
-        performance: { now: () => 0 },
-        setInterval() { return 0; },
-        clearInterval() {},
-        requestAnimationFrame() { return 0; },
-        cancelAnimationFrame() {},
-        getComputedStyle() { return { overflowY: 'visible', paddingTop: '0px', paddingBottom: '0px' }; },
-        innerHeight: 800,
-    };
-    window.window = window;
-    window.globalThis = window;
-    const ctx = vm.createContext(window);
-    vm.runInContext(fs.readFileSync(path.join(__dirname, '..', 'screen.js'), 'utf8'), ctx, { filename: 'screen.js' });
-    assert.ok(window.folderLibrary && window.folderLibrary.__test, 'plugin must expose __test');
-    return window.folderLibrary.__test;
-}
-
-const { songCard, songRow } = load();
-
-// A raw filename with a subfolder + spaces — the kind of value song_preview
-// URL-encodes downstream, so it must reach data-fn verbatim, not pre-encoded.
-const FILENAME = 'Some Artist/A Song.sloppak';
-const SONG = { filename: FILENAME, title: 'A Song', artist: 'Some Artist' };
-
-test('song_preview helpers are exposed for the markup contract', () => {
-    assert.equal(typeof songCard, 'function');
-    assert.equal(typeof songRow, 'function');
-});
-
-test('grid card carries data-fn (raw) and a data-v3-play surface', () => {
-    const card = songCard(SONG, 'Unsorted');
-    assert.equal(card.dataset.fn, FILENAME, 'data-fn must be the raw, un-encoded filename');
-    assert.ok(card.querySelector('[data-v3-play]'), 'card must contain a [data-v3-play] surface');
-});
-
-test('list row carries data-fn (raw) and a data-v3-play surface', () => {
-    const row = songRow(SONG, 'Unsorted');
-    assert.equal(row.dataset.fn, FILENAME, 'data-fn must be the raw, un-encoded filename');
-    assert.ok(row.querySelector('[data-v3-play]'), 'row must contain a [data-v3-play] surface');
-});
-
-test('card renders without depending on any optional song metadata', () => {
-    // song_preview only needs filename; the card must build from a bare song
-    // (no duration/arrangements/stems/lyrics/tuning/year) without throwing.
-    assert.doesNotThrow(() => songCard({ filename: FILENAME }, 'Unsorted'));
-    assert.doesNotThrow(() => songRow({ filename: FILENAME }, 'Unsorted'));
-});

plugins/highway_3d/plugin.json

@@ -1,7 +1,7 @@
 {
     "id": "highway_3d",
     "name": "3D Highway",
-    "version": "3.34.1",
+    "version": "3.34.0",
     "type": "visualization",
     "bundled": true,
     "script": "screen.js",

plugins/highway_3d/screen.js

@@ -2786,21 +2786,6 @@
         if (globalVal !== null && globalVal !== undefined) return _bgCoerce(key, globalVal);
         return BG_DEFAULTS[key];
     }
-    // Read a setting's GLOBAL value, ignoring any per-panel override. The
-    // player-chrome control is a single shared instance, so it must always
-    // read (and write) the global slot. Passing null as a panelKey to
-    // _bgReadSetting happened to work only because 'h3d_bg_null_<key>' never
-    // exists; this states the intent directly and can't be shadowed if a
-    // panelKey of null is ever used deliberately. Mirrors the global half of
-    // _bgReadSetting exactly (mem-fallback precedence, then persisted, then
-    // default).
-    function _bgReadGlobal(key) {
-        let globalVal = null;
-        try { globalVal = localStorage.getItem('h3d_bg_' + key); } catch (_) { /* storage blocked */ }
-        if (key in _bgMemFallback) return _bgCoerce(key, _bgMemFallback[key]);
-        if (globalVal !== null && globalVal !== undefined) return _bgCoerce(key, globalVal);
-        return BG_DEFAULTS[key];
-    }
     // Shared "stored string -> bool" coercion for every boolean
     // setting. Mirrors settings.html's coerceBool so the renderer and
     // the UI hydration always agree on what a corrupted/unknown value
@@ -4039,10 +4024,8 @@
      * add a style there and it shows up in both places automatically.
      *
      * MOUNTED ONCE, REFCOUNTED. Under splitscreen there are N renderer
-     * instances but these settings are global — a panel may set a per-panel
-     * override, but this single shared control only ever reads/writes the
-     * global slot (via _bgReadGlobal), so N copies would be N ways to set
-     * one value. init() acquires, destroy() releases,
+     * instances but these settings are global, so N copies of the control
+     * would be N ways to set one value. init() acquires, destroy() releases,
      * and the last release unmounts — so the control disappears when the user
      * switches to a non-3D renderer instead of lingering as a dead knob.
      *
@@ -4063,11 +4046,9 @@
     //
     // Derived by reading the BG_STYLES bodies: a style uses `intensity` if its
     // build() reads settings.intensity, and uses `reactive` if its update()
-    // dereferences the `bands` argument. 'butterchurn' is a mode, not a
-    // BG_STYLES fog-scenery entry: _bcSyncMode owns its controller, which
-    // drives its own audio tap and canvas opacity (only the fog-scenery half
-    // falls through to BG_STYLES.off). So neither knob here reaches it - both
-    // are false, and the tooltip points at Butterchurn's own controls.
+    // dereferences the `bands` argument. 'butterchurn' is not a BG_STYLES entry
+    // at all - _bgMountStyle falls through to BG_STYLES.off - and it drives its
+    // own audio tap and opacity, so both are false for it.
     //
     // KEEP IN STEP WITH BG_STYLES. If a style starts reading bands or intensity
     // and its row is not updated, the control stays greyed out and lies the
@@ -4082,10 +4063,6 @@
         image:       { intensity: true,  reactive: false, why: 'This background does not react to audio' },
         video:       { intensity: false, reactive: false, why: 'The video plays as-is - nothing to adjust here' },
         butterchurn: { intensity: false, reactive: false, why: 'Butterchurn reacts to audio itself - tune it in Settings > 3D Highway, or its Visualizer panel' },
-        // Not in BG_STYLE_IDS, so it never appears in the dropdown - reached
-        // only via the viz-picker Venue flow (h3dVenueSceneSetActive). While
-        // active it is the EFFECTIVE style, so both knobs drive nothing.
-        venue:       { intensity: false, reactive: false, why: 'Venue visualization is active - pick a background from the visualization picker' },
     };
     let _pcRefs = 0, _pcEl = null, _pcSel = null, _pcReactive = null, _pcIntensity = null;
     // Non-disabled wrappers around the two greyable controls. A native-disabled
@@ -4093,7 +4070,7 @@
     // shows on hover — the whole "greyed out, says why on hover" affordance
     // would be dead. The reason lives on these wrappers instead, and the
     // disabled control gets pointer-events:none so the hover reaches them.
-    let _pcReactiveWrap = null, _pcIntensityWrap = null, _pcReason = null;
+    let _pcReactiveWrap = null, _pcIntensityWrap = null;
     let _pcListener = null, _pcRetry = 0, _pcRetryTimer = 0;
 
     // The player chrome exposes this slot once it has initialised. A host
@@ -4101,12 +4078,7 @@
     // page remains the way in.
     function _pcSlot() {
         try {
-            // Gate on the v3 shell per docs/plugin-v3-ui.md (matches the tuner
-            // precedent). The playerControlSlot typeof check below already
-            // covers the practical case - only v3 exposes it - but the
-            // documented checklist asks plugins to detect v3 explicitly.
-            if (!window.feedBack || window.feedBack.uiVersion !== 'v3') return null;
-            const fn = window.feedBack.ui && window.feedBack.ui.playerControlSlot;
+            const fn = window.feedBack && window.feedBack.ui && window.feedBack.ui.playerControlSlot;
             return typeof fn === 'function' ? fn() : null;
         } catch (_) { return null; }
     }
@@ -4154,8 +4126,6 @@
         btn._on = !!on && !disabled;
         btn.disabled = !!disabled;
         btn.setAttribute('aria-disabled', disabled ? 'true' : 'false');
-        // A toggle button must expose its state, not just its label.
-        btn.setAttribute('aria-pressed', btn._on ? 'true' : 'false');
         // pointer-events:none lets the hover fall through to _pcReactiveWrap,
         // which carries the reason a disabled button's own title can't show.
         btn.style.pointerEvents = disabled ? 'none' : '';
@@ -4181,51 +4151,22 @@
     // whenever the settings bus reports one of our keys changed, so editing
     // from the Settings page updates this control and vice-versa.
     function _pcSync() {
-        // The active style is the EFFECTIVE one, not the stored one: while the
-        // Venue scene override is on it is what's mounted, and it ignores the
-        // whole Background group - picking a style writes `style` but
-        // _bgMountStyle resolves back to venue, so the dropdown would look
-        // broken. So under Venue the ENTIRE group goes inert (dropdown too),
-        // and the user exits Venue from the visualization picker where they
-        // entered it. An unknown id enables everything rather than disabling
-        // it, so a style added without a _PC_USES row is merely unhelpful.
-        const venue = !!_venueSceneOverride;
-        const effectiveStyle = venue ? 'venue' : _bgReadGlobal('style');
-        const uses = _PC_USES[effectiveStyle] || { intensity: true, reactive: true };
-        const why = uses.why || 'This background style ignores this setting';
-        if (_pcReason) _pcReason.textContent = why;
-        // Point a screen reader at the reason, but only while a control is
-        // inert - cleared otherwise so an enabled control is not described by a
-        // stale reason.
-        const _pcDescribe = (el, inert) => {
-            if (!el) return;
-            if (inert) el.setAttribute('aria-describedby', 'h3d-pc-reason');
-            else el.removeAttribute('aria-describedby');
-        };
-        _pcDescribe(_pcSel, venue);
-        _pcDescribe(_pcReactive, !uses.reactive);
-        _pcDescribe(_pcIntensity, !uses.intensity);
         if (_pcSel) {
             // The custom slots stay unselectable until something is uploaded -
             // same rule settings.html applies.
             const img = _pcSel.querySelector('option[value="image"]');
             const vid = _pcSel.querySelector('option[value="video"]');
-            if (img) img.disabled = !_bgReadGlobal('customImageDataUrl');
-            if (vid) vid.disabled = !_bgReadGlobal('customVideoName');
-            _pcSel.value = _bgReadGlobal('style');
-            // The dropdown still SHOWS the stored style (venue has no option),
-            // but it's inert while Venue owns the scene.
-            _pcSel.disabled = venue;
-            _pcSel.setAttribute('aria-disabled', venue ? 'true' : 'false');
-            _pcSel.style.opacity = venue ? '.45' : '1';
-            _pcSel.style.cursor = venue ? 'not-allowed' : '';
-            // Restore the base tooltip when Venue exits — blanking it would
-            // permanently drop the mount-time 'Background style' hint. Matches
-            // how the intensity slider and Reactive pill restore theirs.
-            _pcSel.title = venue ? why : 'Background style';
+            if (img) img.disabled = !_bgReadSetting(null, 'customImageDataUrl');
+            if (vid) vid.disabled = !_bgReadSetting(null, 'customVideoName');
+            _pcSel.value = _bgReadSetting(null, 'style');
         }
+        // Grey out whichever controls the ACTIVE style ignores (see _PC_USES).
+        // An unknown id enables both rather than disabling both, so a style
+        // added without a table row is merely unhelpful, never inert.
+        const uses = _PC_USES[_bgReadSetting(null, 'style')] || { intensity: true, reactive: true };
+        const why = uses.why || 'This background style ignores this setting';
         if (_pcReactive) {
-            _pcPaint(_pcReactive, !!_bgReadGlobal('reactive'), !uses.reactive,
+            _pcPaint(_pcReactive, !!_bgReadSetting(null, 'reactive'), !uses.reactive,
                 uses.reactive ? 'React to the audio' : why);
         }
         // The reason shows via the wrapper (see _pcReactiveWrap); empty when
@@ -4235,7 +4176,7 @@
             _pcReactiveWrap.style.cursor = uses.reactive ? '' : 'not-allowed';
         }
         if (_pcIntensity) {
-            _pcIntensity.value = String(_bgReadGlobal('intensity'));
+            _pcIntensity.value = String(_bgReadSetting(null, 'intensity'));
             _pcIntensity.disabled = !uses.intensity;
             _pcIntensity.setAttribute('aria-disabled', uses.intensity ? 'false' : 'true');
             _pcIntensity.style.pointerEvents = uses.intensity ? '' : 'none';
@@ -4262,10 +4203,10 @@
     function _pcSyncSettingsPanel() {
         try {
             const st = document.getElementById('h3d-bg-style');
-            if (st) st.value = _bgReadGlobal('style');
+            if (st) st.value = _bgReadSetting(null, 'style');
             const re = document.getElementById('h3d-bg-reactive');
-            if (re) re.checked = !!_bgReadGlobal('reactive');
-            const inten = _bgReadGlobal('intensity');
+            if (re) re.checked = !!_bgReadSetting(null, 'reactive');
+            const inten = _bgReadSetting(null, 'intensity');
             const ie = document.getElementById('h3d-bg-intensity');
             if (ie) ie.value = String(inten);
             // The panel prints the numeric value beside the slider; keep its
@@ -4285,16 +4226,6 @@
         const box = document.createElement('div');
         box.className = 'h3d-pc';
         box.style.cssText = 'display:flex;flex-direction:column;width:100%;';
-        // Visually-hidden text carrying the "why greyed out" reason to screen
-        // readers; disabled controls point aria-describedby here. A title alone
-        // is announced unreliably and never on touch. One span suffices - every
-        // greyed control shares the same reason (derived from the single
-        // effective style).
-        _pcReason = document.createElement('span');
-        _pcReason.id = 'h3d-pc-reason';
-        _pcReason.style.cssText = 'position:absolute;width:1px;height:1px;padding:0;'
-            + 'margin:-1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0;';
-        box.appendChild(_pcReason);
 
         box.appendChild(_pcGroupLabel('Background'));
         // A dropdown, not pills: the style list is 8 entries and growing, and
@@ -4303,7 +4234,6 @@
         // raw <select>.
         _pcSel = document.createElement('select');
         _pcSel.title = 'Background style';
-        _pcSel.setAttribute('aria-label', 'Background style');
         _pcSel.style.cssText = 'width:100%;padding:.375rem .5rem;border:0;border-radius:.5rem;'
             + 'font-size:.75rem;line-height:1rem;cursor:pointer;'
             + 'background-color:' + _PC_C.idle + ';color:' + _PC_C.text + ';';
@@ -4314,7 +4244,6 @@
             _pcSel.appendChild(o);
         }
         _pcSel.addEventListener('change', () => {
-            if (_pcSel.disabled) return;   // inert under the Venue override
             try { window.h3dBgSetStyle(_pcSel.value); }
             catch (e) { console.error('[3D-Hwy] bg style set failed', e); }
         });
@@ -4340,7 +4269,6 @@
         _pcIntensity.type = 'range';
         _pcIntensity.min = '0'; _pcIntensity.max = '1'; _pcIntensity.step = '0.05';
         _pcIntensity.title = 'Background intensity';
-        _pcIntensity.setAttribute('aria-label', 'Background intensity');
         _pcIntensity.style.cssText = 'width:100%;accent-color:#4080e0;';
         // 'change' (fires on release), NOT 'input'. Every write goes through
         // _bgWriteGlobal -> _bgEmitChange -> _bgRebuild(), which tears the
@@ -4360,11 +4288,7 @@
         _pcSync();
         _pcListener = (key) => {
             if (key === 'style' || key === 'reactive' || key === 'intensity'
-                || key === 'customImageDataUrl' || key === 'customVideoName'
-                || key === 'venueScene') {
-                // 'venueScene' has no dropdown/settings widget of its own, but
-                // toggling Venue changes the EFFECTIVE style, so the greying
-                // must re-evaluate (see _pcSync's effectiveStyle).
+                || key === 'customImageDataUrl' || key === 'customVideoName') {
                 _pcSync();
                 _pcSyncSettingsPanel();
             }
@@ -4376,18 +4300,12 @@
         if (_pcListener) { _bgUnsubscribe(_pcListener); _pcListener = null; }
         if (_pcEl && _pcEl.parentNode) _pcEl.parentNode.removeChild(_pcEl);
         _pcEl = null; _pcSel = null; _pcReactive = null; _pcIntensity = null;
-        _pcReactiveWrap = null; _pcIntensityWrap = null; _pcReason = null;
+        _pcReactiveWrap = null; _pcIntensityWrap = null;
     }
     function _pcAcquire() {
         _pcRefs++;
         _pcBindScreenHook();
         if (_pcMount()) return;
-        // A non-v3 shell has no slot and never will — _pcAcquire only runs once
-        // the renderer is viable inside the v3 player chrome, and player-chrome.js
-        // sets uiVersion synchronously as it builds that chrome, so a missing 'v3'
-        // here means v2, not a not-yet-ready v3. Skip the retry loop rather than
-        // spinning it out to the ~3s budget for a slot that will never appear.
-        if (!window.feedBack || window.feedBack.uiVersion !== 'v3') return;
         // The rail popover may not be built yet on a cold load. Retry a few
         // times, then give up quietly — Settings still works.
         if (_pcRetryTimer) return;
@@ -4395,12 +4313,6 @@
         const tick = () => {
             _pcRetryTimer = 0;
             if (_pcRefs <= 0) return;          // renderer went away mid-retry
-            // Re-attempt the bus subscription too, not just the mount. On a cold
-            // load the renderer can init before window.feedBack.on exists; the
-            // first _pcBindScreenHook() then no-ops and, without this, the hook
-            // never binds and the control goes permanently deaf to screen
-            // changes. Idempotent via the _pcScreenHook guard.
-            _pcBindScreenHook();
             if (_pcMount()) return;
             if (++_pcRetry > 12) return;       // ~3s at 250ms
             _pcRetryTimer = setTimeout(tick, 250);
@@ -7042,11 +6954,37 @@
             return boxH;
         }
 
-        // Lyrics layout cache — measureText per syllable + row wrapping
-        // only changes when the displayed line(s), font size, or canvas
-        // width change, not per frame. Keyed below; the per-frame work is
-        // just drawing over the cached widths.
-        let _lyrRowsCache = null;
+        // Lyrics layout cache — measureText per syllable + width-splitting
+        // only changes when the lyric set, font size, or canvas width
+        // change, not per frame. Keyed below; the per-frame work is just
+        // windowing + drawing over the cached widths.
+        let _lyrLayoutCache = null;
+
+        // Same live-tunable window config as the 2D highway
+        // (static/js/highway-draw.js getLyricsDisplayCfg) — duplicated
+        // because this plugin deliberately does not import the shared
+        // module. Both read localStorage['lyricsDisplay'], so
+        // highway.setLyricsDisplay() tunes both at once.
+        const LYRICS_DISPLAY_DEFAULTS = { upcomingLines: 2, lookaheadSec: 4 };
+        let _lyrCfgRaw, _lyrCfg = LYRICS_DISPLAY_DEFAULTS;
+        function getLyricsDisplayCfg() {
+            let raw = null;
+            try { raw = localStorage.getItem('lyricsDisplay'); } catch (e) { /* storage denied */ }
+            if (raw === _lyrCfgRaw) return _lyrCfg;
+            _lyrCfgRaw = raw;
+            let parsed = null;
+            try { parsed = raw ? JSON.parse(raw) : null; } catch (e) { /* corrupt -> defaults */ }
+            if (!parsed || typeof parsed !== 'object') parsed = {};
+            const num = (v, dflt, lo, hi) => {
+                const n = Number(v);
+                return Number.isFinite(n) ? Math.min(hi, Math.max(lo, n)) : dflt;
+            };
+            _lyrCfg = {
+                upcomingLines: num(parsed.upcomingLines, LYRICS_DISPLAY_DEFAULTS.upcomingLines, 0, 4) | 0,
+                lookaheadSec: num(parsed.lookaheadSec, LYRICS_DISPLAY_DEFAULTS.lookaheadSec, 1, 30),
+            };
+            return _lyrCfg;
+        }
 
         function drawLyrics(lyrics, currentTime, ctx, W, H) {
             if (!lyrics._lines) {
@@ -7073,41 +7011,29 @@
             const allLines = lyrics._lines;
             if (!allLines.length) return 0;
 
-            let currentIdx = -1;
-            for (let i = 0; i < allLines.length; i++) {
-                if (allLines[i].start <= currentTime) currentIdx = i;
-                else break;
-            }
-            if (currentIdx === -1) {
-                if (allLines[0].start - currentTime > 2.0) return 0;
-                currentIdx = 0;
-            }
-            const currentLine = allLines[currentIdx];
-            const nextLine = allLines[currentIdx + 1] || null;
-            const gapToNext = nextLine ? (nextLine.start - currentLine.end) : Infinity;
-            if (currentTime > currentLine.end + 0.5 && gapToNext > 3.0) return 0;
-
-            const linesToShow = [currentLine];
-            if (nextLine && gapToNext <= 3.0) linesToShow.push(nextLine);
-
+            const cfg = getLyricsDisplayCfg();
             const fontSize = Math.max(18, H * 0.028) | 0;
             const lineY = H * 0.04;
             const sylText = s => { const t = s.w || ''; return (t.endsWith('+') || t.endsWith('-')) ? t.slice(0, -1) : t; };
 
             ctx.font = `bold ${fontSize}px sans-serif`;
-            let rows, spaceWidth, bgWidth;
-            const _lc = _lyrRowsCache;
-            if (_lc && _lc.lyricsRef === lyrics && _lc.idx === currentIdx
-                && _lc.shown === linesToShow.length
-                && _lc.fontSize === fontSize && _lc.W === W) {
-                rows = _lc.rows; spaceWidth = _lc.spaceWidth; bgWidth = _lc.bgWidth;
-            } else {
-                spaceWidth = ctx.measureText(' ').width;
-                const maxWidth = W * 0.8;
 
-                rows = [];
-                for (const authoredLine of linesToShow) {
-                    let row = [], rowWidth = 0;
+            // Display lines: authored lines pre-split at word boundaries so
+            // every display line fits maxWidth — one display line is exactly
+            // one rendered row, so a giant transcribed line scrolls through
+            // the window instead of wrapping into an unbounded block.
+            let layout = _lyrLayoutCache;
+            if (!layout || layout.lyricsRef !== lyrics || layout.fontSize !== fontSize || layout.W !== W) {
+                const spaceWidth = ctx.measureText(' ').width;
+                const maxWidth = W * 0.8;
+                const displayLines = [];
+                for (const authoredLine of allLines) {
+                    let row = [], rowWidth = 0, start = null, end = null;
+                    const flushRow = () => {
+                        if (!row.length) return;
+                        displayLines.push({ row, width: rowWidth - spaceWidth, start, end });
+                        row = []; rowWidth = 0; start = null; end = null;
+                    };
                     for (const wordSyls of authoredLine.words) {
                         const parts = [];
                         let wordWidth = 0;
@@ -7118,28 +7044,53 @@
                             wordWidth += w;
                         }
                         const advance = wordWidth + spaceWidth;
-                        if (row.length > 0 && rowWidth + advance > maxWidth) { rows.push(row); row = []; rowWidth = 0; }
+                        if (row.length > 0 && rowWidth + advance > maxWidth) flushRow();
                         row.push({ parts, advance });
                         rowWidth += advance;
+                        const first = wordSyls[0], last = wordSyls[wordSyls.length - 1];
+                        if (start === null) start = first.t;
+                        end = end === null ? last.t + last.d : Math.max(end, last.t + last.d);
                     }
-                    if (row.length) rows.push(row);
+                    flushRow();
                 }
+                layout = _lyrLayoutCache = { lyricsRef: lyrics, fontSize, W, spaceWidth, displayLines };
+            }
+            const displayLines = layout.displayLines;
+            const spaceWidth = layout.spaceWidth;
+            if (!displayLines.length) return 0;
 
-                bgWidth = 0;
-                for (const row of rows) {
-                    const rw = row.reduce((s, w) => s + w.advance, 0) - spaceWidth;
-                    if (rw > bgWidth) bgWidth = rw;
-                }
-                bgWidth = Math.min(bgWidth + 30, W * 0.85);
-                _lyrRowsCache = {
-                    lyricsRef: lyrics, idx: currentIdx,
-                    shown: linesToShow.length, fontSize, W,
-                    rows, spaceWidth, bgWidth,
-                };
+            // Rolling window: current line + up to cfg.upcomingLines of
+            // context, each joining once it starts within cfg.lookaheadSec
+            // (also the pre-song preview window).
+            let currentIdx = -1;
+            for (let i = 0; i < displayLines.length; i++) {
+                if (displayLines[i].start <= currentTime) currentIdx = i;
+                else break;
+            }
+            const nextLine = displayLines[currentIdx + 1] || null;
+            if (currentIdx >= 0
+                && currentTime > displayLines[currentIdx].end + 0.5
+                && (!nextLine || nextLine.start - currentTime > cfg.lookaheadSec)) {
+                return 0;
             }
 
+            const maxLines = 1 + cfg.upcomingLines;
+            const startIdx = currentIdx === -1 ? 0 : currentIdx;
+            const shown = [];
+            for (let i = startIdx; i < displayLines.length && shown.length < maxLines; i++) {
+                if (i !== currentIdx && displayLines[i].start - currentTime > cfg.lookaheadSec) break;
+                shown.push(displayLines[i]);
+            }
+            if (!shown.length) return 0;
+
+            let bgWidth = 0;
+            for (const dl of shown) {
+                if (dl.width > bgWidth) bgWidth = dl.width;
+            }
+            bgWidth = Math.min(bgWidth + 30, W * 0.85);
+
             const rowHeight = fontSize + 6;
-            const totalHeight = rows.length * rowHeight + 10;
+            const totalHeight = shown.length * rowHeight + 10;
 
             ctx.fillStyle = 'rgba(0,0,0,0.7)';
             ctx.beginPath();
@@ -7157,10 +7108,9 @@
 
             ctx.textAlign = 'left';
             ctx.textBaseline = 'top';
-            for (let r = 0; r < rows.length; r++) {
-                const row = rows[r];
-                const rowWidth = row.reduce((s, w) => s + w.advance, 0) - spaceWidth;
-                let xPos = W / 2 - rowWidth / 2;
+            for (let r = 0; r < shown.length; r++) {
+                const row = shown[r].row;
+                let xPos = W / 2 - shown[r].width / 2;
                 const yPos = lineY + r * rowHeight + 2;
                 for (const w of row) {
                     for (const part of w.parts) {

plugins/highway_3d/tests/background_control.test.js

@@ -37,9 +37,8 @@ const END_LF = '    /* =========================================================
 // table, which would only assert that the table equals itself.
 //   intensity: true  => the style's build() reads settings.intensity
 //   reactive:  true  => the style's update() dereferences its `bands` argument
-// 'butterchurn' is a mode, not a BG_STYLES fog-scenery entry: _bcSyncMode
-// owns its controller and drives its own audio tap + canvas opacity (only
-// the fog-scenery half falls through to BG_STYLES.off), so both are false.
+// 'butterchurn' is not a BG_STYLES entry at all (mount falls through to
+// BG_STYLES.off) and drives its own audio tap, so both are false.
 const EXPECTED_USES = {
     off: { intensity: false, reactive: false },
     particles: { intensity: true, reactive: true },
@@ -74,7 +73,6 @@ function makeDom() {
         }
         addEventListener(t, fn) { (this.listeners[t] || (this.listeners[t] = [])).push(fn); }
         setAttribute(k, v) { this[k] = v; }
-        removeAttribute(k) { delete this[k]; }
         get isConnected() {
             let n = this;
             while (n.parentNode) n = n.parentNode;
@@ -129,12 +127,7 @@ function load({ store: initialStore } = {}) {
     const sandbox = {
         console,
         BG_STYLE_IDS,
-        // Module-scope in screen.js; the _pc* block reads it to resolve the
-        // effective style under the Venue override. Tests flip it via
-        // sandbox._venueSceneOverride and fire the 'venueScene' bus key.
-        _venueSceneOverride: false,
         _bgReadSetting: (_panelKey, key) => store[key],
-        _bgReadGlobal: (key) => store[key],
         _bgSubscribe: (fn) => listeners.add(fn),
         _bgUnsubscribe: (fn) => listeners.delete(fn),
         setTimeout: (fn) => { timers.push(fn); return timers.length; },
@@ -146,7 +139,6 @@ function load({ store: initialStore } = {}) {
         },
         window: {
             feedBack: {
-                uiVersion: 'v3',   // _pcSlot gates on this (docs/plugin-v3-ui.md)
                 ui: { playerControlSlot: () => dom.slot },
                 // The real bus is an EventTarget wrapper exposing on/off. Modelled
                 // here so the screen:changed subscription — and its removal — are
@@ -173,7 +165,6 @@ function load({ store: initialStore } = {}) {
         + '   get sel() { return _pcSel; },'
         + '   get react() { return _pcReactive; },'
         + '   get intens() { return _pcIntensity; },'
-        + '   get reason() { return _pcReason; },'
         + '   get refs() { return _pcRefs; } })',
         sandbox,
     );
@@ -182,50 +173,6 @@ function load({ store: initialStore } = {}) {
     return { api, dom, store, emit, writes, timers, sandbox, listenerCount: () => listeners.size, fireScreenChanged, screenHooks };
 }
 
-// Slice the real _bgReadSetting + _bgReadGlobal out of screen.js and run them
-// against a localStorage stub. The main suite stubs both helpers identically,
-// so it can't tell the #2 refactor from a no-op; this one proves the actual
-// helper bodies differ where they must: _bgReadGlobal ignores a per-panel
-// override that _bgReadSetting(panelKey, ...) still honours.
-test('_bgReadGlobal reads the global slot, ignoring per-panel overrides', () => {
-    const src = fs.readFileSync(SCREEN_JS, 'utf8');
-    const rgStart = src.indexOf('    function _bgReadSetting(panelKey, key) {');
-    const rgEnd = src.indexOf('    // Shared "stored string -> bool" coercion');
-    assert.ok(rgStart !== -1 && rgEnd > rgStart, 'could not slice the read helpers');
-    const block = src.slice(rgStart, rgEnd);
-
-    const storage = new Map();
-    const sandbox = {
-        localStorage: { getItem: (k) => (storage.has(k) ? storage.get(k) : null) },
-        _bgCoerce: (_key, v) => v,           // identity: we test key resolution, not coercion
-        _bgMemFallback: Object.create(null),
-        BG_DEFAULTS: { style: 'particles' },
-    };
-    sandbox.globalThis = sandbox;
-    const api = vm.runInNewContext(block + '\n({ _bgReadSetting, _bgReadGlobal, _bgMemFallback })', sandbox);
-
-    storage.set('h3d_bg_style', 'lights');            // global
-    storage.set('h3d_bg_panel3_style', 'geometric');  // a per-panel override
-
-    // The renderer, reading with a panel key, honours the per-panel override...
-    assert.equal(api._bgReadSetting('panel3', 'style'), 'geometric');
-    // ...but the shared control's global read must NOT see it - this is the
-    // whole point of #2 (previously _bgReadSetting(null, ...) relied on
-    // 'h3d_bg_null_style' never existing).
-    assert.equal(api._bgReadGlobal('style'), 'lights');
-
-    // In-memory staged value wins over the persisted global (matches
-    // _bgReadSetting's precedence).
-    api._bgMemFallback.style = 'aurora';
-    assert.equal(api._bgReadGlobal('style'), 'aurora');
-    delete api._bgMemFallback.style;
-
-    // Nothing stored -> BG_DEFAULTS.
-    assert.equal(api._bgReadGlobal('style'), 'lights');
-    storage.delete('h3d_bg_style');
-    assert.equal(api._bgReadGlobal('style'), 'particles');
-});
-
 test('mounts one control into the player-control slot', () => {
     const { api, dom } = load();
     api._pcAcquire();
@@ -252,29 +199,6 @@ test('multiple renderer instances share a single control', () => {
     assert.equal(api.el, null);
 });
 
-test('binds the screen hook on a retry when the bus was not ready at acquire', () => {
-    const ctl = load();
-    // Cold load: on a fresh page the renderer can init before the event bus is
-    // wired AND before the rail popover exists. Simulate both being absent.
-    const savedOn = ctl.sandbox.window.feedBack.on;
-    const savedUi = ctl.sandbox.window.feedBack.ui;
-    delete ctl.sandbox.window.feedBack.on;
-    ctl.sandbox.window.feedBack.ui = {};   // no playerControlSlot -> mount fails
-
-    ctl.api._pcAcquire();
-    assert.equal(ctl.screenHooks(), 0, 'nothing to bind to yet');
-    assert.equal(ctl.api.el, null, 'no slot yet, so nothing mounted');
-
-    // Bus + slot come online; the retry tick must bind the hook, not only mount.
-    ctl.sandbox.window.feedBack.on = savedOn;
-    ctl.sandbox.window.feedBack.ui = savedUi;
-    ctl.timers.shift()();   // run one retry tick
-
-    assert.equal(ctl.screenHooks(), 1, 'the retry tick failed to bind the screen hook');
-    assert.ok(ctl.api.el, 'and it should have mounted too');
-    ctl.api._pcRelease();
-});
-
 test('the last release unbinds the screen:changed hook', () => {
     const ctl = load();
     ctl.api._pcAcquire();
@@ -337,18 +261,6 @@ test('re-mounts into a fresh slot when the player chrome is rebuilt', () => {
     assert.equal(listenerCount(), 1, 'remount must not double-subscribe');
 });
 
-test('a non-v3 host mounts nothing (uiVersion gate)', () => {
-    const ctl = load();
-    ctl.sandbox.window.feedBack.uiVersion = 'v2';   // pre-v3 shell
-    ctl.api._pcAcquire();
-    assert.equal(ctl.api.el, null, 'must not mount when uiVersion is not v3');
-    assert.equal(ctl.dom.slot.children.length, 0);
-    // A non-v3 shell has no slot and never will, so no retry should be scheduled
-    // at all — the loop is for a not-yet-built v3 slot, not for polling v2.
-    assert.equal(ctl.timers.length, 0, 'a non-v3 host must not schedule the retry loop');
-    ctl.api._pcRelease();
-});
-
 test('a host with no player-control slot mounts nothing and does not throw', () => {
     const { api, dom, sandbox, timers } = load();
     sandbox.window.feedBack.ui = {};
@@ -388,49 +300,6 @@ test('the dropdown and Reactive pill drive the real setters', () => {
     assert.ok(writes.some((w) => w[0] === 'reactive'));
 });
 
-test('exposes state and reasons to assistive tech', () => {
-    const ctl = load({ store: { style: 'image', reactive: true } });   // image: reactive inert
-    ctl.api._pcAcquire();
-
-    // The reason live-region must be a REAL mounted element with the id the
-    // controls reference - not a dangling pointer. Assert resolution, not a
-    // literal (a wrong id in code would still equal the literal).
-    const reason = ctl.api.reason;
-    assert.ok(reason, 'the reason span was not created');
-    assert.equal(reason.id, 'h3d-pc-reason');
-    assert.equal(reason.parentNode, ctl.api.el, 'the reason span must be mounted in the control');
-
-    // aria-pressed: a toggle button must expose its state. image greys
-    // Reactive, so not-pressed AND disabled, and it points at the reason.
-    assert.equal(ctl.api.react['aria-pressed'], 'false', 'greyed toggle is not pressed');
-    assert.equal(ctl.api.react['aria-disabled'], 'true');
-    // Pointer must resolve to the actual span's id (kills a wrong-id mutation),
-    // and the span must carry the current reason text (kills a never-set-text
-    // mutation).
-    assert.equal(ctl.api.react['aria-describedby'], reason.id, 'inert control must reference the reason span');
-    assert.equal(reason.textContent, 'This background does not react to audio', 'reason text must match the style');
-    assert.equal(ctl.api.intens['aria-describedby'], undefined, 'an ENABLED control carries no reason');
-
-    // The intensity describe path: a style where INTENSITY is inert.
-    ctl.store.style = 'video'; ctl.emit('style');
-    assert.equal(ctl.api.intens.disabled, true, 'precondition: video greys intensity');
-    assert.equal(ctl.api.intens['aria-describedby'], reason.id, 'inert intensity must reference the reason');
-    assert.equal(reason.textContent, 'The video plays as-is - nothing to adjust here');
-
-    // Both enabled: describedby drops, aria-pressed follows the value.
-    ctl.store.style = 'particles'; ctl.store.reactive = true; ctl.emit('style');
-    assert.equal(ctl.api.react['aria-describedby'], undefined, 'enabled control drops the reason');
-    assert.equal(ctl.api.intens['aria-describedby'], undefined);
-    assert.equal(ctl.api.react['aria-pressed'], 'true', 'reactive on for particles');
-    ctl.store.reactive = false; ctl.emit('reactive');
-    assert.equal(ctl.api.react['aria-pressed'], 'false', 'aria-pressed follows the value');
-
-    // Accessible names on the non-label controls.
-    assert.equal(ctl.api.sel['aria-label'], 'Background style');
-    assert.equal(ctl.api.intens['aria-label'], 'Background intensity');
-    ctl.api._pcRelease();
-});
-
 test('greys out exactly the controls each style ignores', () => {
     const { api, store, emit } = load();
     api._pcAcquire();
@@ -442,48 +311,6 @@ test('greys out exactly the controls each style ignores', () => {
     }
 });
 
-test('the Venue override greys the whole Background group', () => {
-    const ctl = load({ store: { style: 'particles' } });   // a style that uses both
-    ctl.api._pcAcquire();
-    assert.equal(ctl.api.intens.disabled, false, 'precondition: both enabled off-venue');
-    assert.equal(ctl.api.react.disabled, false);
-
-    // Venue turns on: the effective style is now 'venue', which uses neither.
-    // The transition arrives on the settings bus as the 'venueScene' key.
-    ctl.sandbox._venueSceneOverride = true;
-    ctl.emit('venueScene');
-    assert.equal(ctl.api.intens.disabled, true, 'intensity should grey under Venue');
-    assert.equal(ctl.api.react.disabled, true, 'reactive should grey under Venue');
-    assert.equal(ctl.api.sel.disabled, true, 'the dropdown should be inert under Venue too');
-    assert.match(ctl.api.intens.title, /venue/i, 'reason should mention Venue');
-    // All three inert controls point at the reason under Venue (kills a
-    // 'describe reactive only' regression on the select/intensity paths).
-    const vReason = ctl.api.reason.id;
-    assert.equal(ctl.api.sel['aria-describedby'], vReason, 'select must reference the reason under Venue');
-    assert.equal(ctl.api.intens['aria-describedby'], vReason, 'intensity must reference the reason under Venue');
-    assert.equal(ctl.api.react['aria-describedby'], vReason, 'reactive must reference the reason under Venue');
-    assert.match(ctl.api.reason.textContent, /venue/i, 'the reason span carries the Venue text');
-
-    // The dropdown still shows the stored style (venue has no option), but
-    // selecting must not write while it's inert.
-    assert.equal(ctl.api.sel.value, 'particles');
-    const before = ctl.writes.length;
-    ctl.api.sel.value = 'lights';
-    ctl.api.sel.fire('change');
-    assert.equal(ctl.writes.length, before, 'a disabled dropdown must not write');
-
-    // Venue off: controls come back per the stored style.
-    ctl.sandbox._venueSceneOverride = false;
-    ctl.emit('venueScene');
-    assert.equal(ctl.api.intens.disabled, false, 'intensity re-enables when Venue exits');
-    assert.equal(ctl.api.react.disabled, false);
-    assert.equal(ctl.api.sel.disabled, false, 'the dropdown re-enables when Venue exits');
-    assert.equal(ctl.api.sel.title, 'Background style', 'the base tooltip must come back, not blank');
-    assert.equal(ctl.api.sel['aria-describedby'], undefined, 'select drops the reason off-Venue');
-    assert.equal(ctl.api.intens['aria-describedby'], undefined, 'intensity drops the reason off-Venue');
-    ctl.api._pcRelease();
-});
-
 test('an unknown style enables both controls (fails open)', () => {
     const { api, store, emit } = load();
     api._pcAcquire();

server.py

@@ -49,7 +49,7 @@ import demo_mode
 import scan
 import tailwind_rebuild
 # Extracted route modules. They import `appstate`, never `server` — one-way graph.
-from routers import audio_effects, artist_aliases, loops, playlists, ws_highway, ws_sync, chart, wanted, library_extras, shop, progression, profile, stats, version, diagnostics
+from routers import audio_effects, artist_aliases, loops, playlists, ws_highway, chart, wanted, library_extras, shop, progression, profile, stats, version, diagnostics
 from routers import tunings as tunings_router
 import enrichment
 from routers import art as art_router
@@ -1618,12 +1618,6 @@ app.include_router(media_router.router)
 app.include_router(ws_highway.router)
 
 
-# ── Session-sync relay WebSocket (feedBack#1030) ─────────────────────────────
-# Dumb JSON fan-out rooms for cross-device followers (splitscreen LAN mode).
-# Implementation in lib/routers/ws_sync.py.
-app.include_router(ws_sync.router)
-
-
 # ── Audio serving ─────────────────────────────────────────────────────────────
 
 

static/app.js

@@ -1150,7 +1150,7 @@ window.feedBack.on('song:ready', () => {
 let _arrBusyGen = 0;
 let _arrBusyTimeout = null;
 
-async function changeArrangement(index, drumPart) {
+async function changeArrangement(index) {
     if (currentFilename) {
         // Tear down any pending fresh-load credits before switching: the
         // no-count-in hold timer would otherwise fire togglePlay() against the
@@ -1276,38 +1276,11 @@ async function changeArrangement(index, drumPart) {
         _resetSectionPracticeLog();
         invalidateParentCount();
 
-        // Carry the selected drum part across the re-stream. An explicit
-        // `drumPart` (a drum-part switch, from changeDrumPart) wins; otherwise
-        // preserve the current picker selection so an ARRANGEMENT switch keeps
-        // the chosen part (drum parts are song-level, not per-arrangement).
-        const part = drumPart !== undefined
-            ? drumPart
-            : (document.getElementById('drum-part-select')?.value || '');
-        window.highway.reconnect(currentFilename, index, part);
+        window.highway.reconnect(currentFilename, index);
         window.feedBack.emit('arrangement:changed', { index, filename: currentFilename });
     }
 }
 
-// Switch which drum part plays (feedpak 1.17.0 "drums as arrangements"). A part
-// switch re-streams the same song with a different drum tab — the same
-// transition as an arrangement switch — so it delegates to changeArrangement
-// with the CURRENT arrangement held and the new part applied. Wired to
-// #drum-part-select's onchange; the select is populated + shown by
-// highway.js's song_info handler only when the song has 2+ drum parts.
-async function changeDrumPart(partId) {
-    if (!currentFilename) return;
-    let index = 0;
-    const si = window.highway && typeof window.highway.getSongInfo === 'function'
-        ? window.highway.getSongInfo() : null;
-    if (si && typeof si.arrangement_index === 'number' && si.arrangement_index >= 0) {
-        index = si.arrangement_index;
-    } else {
-        const arrSel = document.getElementById('arr-select');
-        if (arrSel && arrSel.value !== '') index = Number(arrSel.value) || 0;
-    }
-    return changeArrangement(index, partId);
-}
-
 // Restart the current song from the beginning (or from loop A when an A–B
 // loop is armed). Uses the canonical _audioSeek funnel only — never touches
 // audio.currentTime directly and never reloads via playSong().
@@ -2352,7 +2325,7 @@ configureHost({
 Object.assign(window, {
     _confirmDialog, _getArrangementNamingMode, _libraryLocalFilename, _librarySongArtUrl,
     _librarySongId, _onHeaderClick, _onNamingModeChange, _trapFocusInModal,
-    changeArrangement, changeDrumPart, checkPluginUpdates, clearLibFilters, clearLoop,
+    changeArrangement, checkPluginUpdates, clearLibFilters, clearLoop,
     deleteSelectedLoop, esc, exportDiagnostics, exportSettings, filterFavorites,
     filterLibrary, fullRescanLibrary, goFavPage, handleSliderInput,
     hideScanBanner, importSettings, loadPlugins, loadSavedLoop,

static/highway.js

@@ -60,6 +60,7 @@ import {
     bsearchChords,
     drawChords,
     drawLyrics,
+    getLyricsDisplayCfg,
     drawNote,
     drawNotes,
     drawStrumGroups,
@@ -2298,31 +2299,6 @@ function createHighway() {
                                         sel.appendChild(opt);
                                     }
                                 }
-                                // Drum-part picker (feedpak 1.17.0 "drums as
-                                // arrangements"): a song can carry several drum
-                                // charts. Populate the picker beside the
-                                // arrangement switcher; show it only when there
-                                // are 2+ parts to choose between. `drum_parts`
-                                // is always present (empty for non-drum songs),
-                                // so a single-drum / no-drum song hides it. The
-                                // currently-streaming part is marked selected by
-                                // the `drum_tab` handler below (authoritative
-                                // `part_id`), so we don't guess here.
-                                {
-                                    const dpSel = document.getElementById('drum-part-select');
-                                    if (dpSel) {
-                                        const parts = Array.isArray(msg.drum_parts) ? msg.drum_parts : [];
-                                        dpSel.textContent = '';
-                                        for (const p of parts) {
-                                            const opt = document.createElement('option');
-                                            opt.value = p.id;
-                                            opt.textContent = p.name || p.id;
-                                            dpSel.appendChild(opt);
-                                        }
-                                        const dpRow = document.getElementById('v3-drum-part-row');
-                                        if (dpRow) dpRow.classList.toggle('hidden', parts.length <= 1);
-                                    }
-                                }
                             }
                             // Plugin context API — broadcast current song state
                             if (window.feedBack) {
@@ -2405,22 +2381,7 @@ function createHighway() {
                                 name: (typeof msg.name === 'string' && msg.name) ? msg.name : 'Drums',
                                 kit: Array.isArray(msg.kit) ? msg.kit : [],
                                 hits: [],
-                                // Which drum part this stream carries (feedpak
-                                // 1.17.0). Present only for multi-part packs;
-                                // null otherwise. Plugins can read it via
-                                // bundle.drumTab.part_id.
-                                part_id: (typeof msg.part_id === 'string' && msg.part_id) ? msg.part_id : null,
                             };
-                            // Reflect the authoritative streaming part in the
-                            // picker (the server resolves an unknown/absent
-                            // selection to the primary, so this keeps the
-                            // dropdown honest even after a fallback).
-                            if (hwState.drumTab.part_id) {
-                                const dpSel = document.getElementById('drum-part-select');
-                                if (dpSel && dpSel.value !== hwState.drumTab.part_id) {
-                                    dpSel.value = hwState.drumTab.part_id;
-                                }
-                            }
                             break;
                         case 'drum_hits':
                             if (hwState.drumTab && Array.isArray(msg.data)) {
@@ -2789,6 +2750,18 @@ function createHighway() {
         },
         setOnLyricsChange(fn) { hwState._onLyricsChange = fn; },
 
+        // Lyric display window (current + upcoming context). Live-tunable:
+        // takes effect on the next drawn frame, shared with the 3D highway
+        // via the same localStorage key. Partial updates merge over the
+        // current values; out-of-range values are clamped by the reader.
+        //   highway.setLyricsDisplay({ upcomingLines: 3, lookaheadSec: 12 })
+        getLyricsDisplay() { return { ...getLyricsDisplayCfg() }; },
+        setLyricsDisplay(opts) {
+            const next = { ...getLyricsDisplayCfg(), ...(opts || {}) };
+            localStorage.setItem('lyricsDisplay', JSON.stringify(next));
+            return { ...getLyricsDisplayCfg() };
+        },
+
         // Teaching marks (§6.2.2): toggle the opt-in sd/ch overlays. The fg
         // numeral has its own toggle below. Persisted to localStorage.
         getTeachingMarksVisible() { return hwState._showTeachingMarks; },
@@ -2813,7 +2786,7 @@ function createHighway() {
             localStorage.setItem('showFingerHints', String(hwState._showFingerHints));
         },
 
-        reconnect(filename, arrangement, drumPart) {
+        reconnect(filename, arrangement) {
             // Close old WS but keep audio + animation running
             if (hwState.ws) { hwState.ws.close(); hwState.ws = null; }
             hwState.ready = false;
@@ -2839,11 +2812,6 @@ function createHighway() {
             _resetChordRenderState();
             const wsParams = new URLSearchParams();
             if (arrangement !== undefined) wsParams.set('arrangement', arrangement);
-            // Multiple drum parts (feedpak 1.17.0 "drums as arrangements"):
-            // carry the selected part id so the WS streams ITS drum tab. Empty
-            // / undefined → the primary part (server default), i.e. today's
-            // one-drum behavior for any pack the picker never touched.
-            if (drumPart) wsParams.set('drum_part', drumPart);
             let namingMode = 'smart';
             if (typeof window._getArrangementNamingMode === 'function') {
                 const v = window._getArrangementNamingMode();

static/js/highway-draw.js

@@ -921,11 +921,46 @@ export function drawChords(hwState, W, H) {
 }
 
 // ── Helpers ───────────────────────────────────────────────────────────
+
+// Live-tunable lyric display window, persisted as JSON under
+// localStorage['lyricsDisplay'] and settable in-game via
+// highway.setLyricsDisplay({upcomingLines, lookaheadSec}). Read per frame
+// behind a raw-string compare so a tweak takes effect on the next frame
+// without a reload.
+//   upcomingLines — how many lines beyond the current one may be shown (0-4)
+//   lookaheadSec  — how far ahead a line may start and still be previewed (1-30)
+// lookahead default is deliberately modest (4s): dense singing still gets
+// full upcoming context (next lines start within a couple of seconds), but
+// the banner goes away during instrumental gaps instead of hanging there
+// with unsung lines — which reads as "the lyrics are out of sync".
+const LYRICS_DISPLAY_DEFAULTS = { upcomingLines: 2, lookaheadSec: 4 };
+let _lyricsCfgRaw;
+let _lyricsCfg = LYRICS_DISPLAY_DEFAULTS;
+export function getLyricsDisplayCfg() {
+    let raw = null;
+    try { raw = localStorage.getItem('lyricsDisplay'); } catch (e) { /* storage denied */ }
+    if (raw === _lyricsCfgRaw) return _lyricsCfg;
+    _lyricsCfgRaw = raw;
+    let parsed = null;
+    try { parsed = raw ? JSON.parse(raw) : null; } catch (e) { /* corrupt -> defaults */ }
+    if (!parsed || typeof parsed !== 'object') parsed = {};
+    const num = (v, dflt, lo, hi) => {
+        const n = Number(v);
+        return Number.isFinite(n) ? Math.min(hi, Math.max(lo, n)) : dflt;
+    };
+    _lyricsCfg = {
+        upcomingLines: num(parsed.upcomingLines, LYRICS_DISPLAY_DEFAULTS.upcomingLines, 0, 4) | 0,
+        lookaheadSec: num(parsed.lookaheadSec, LYRICS_DISPLAY_DEFAULTS.lookaheadSec, 1, 30),
+    };
+    return _lyricsCfg;
+}
+
 export function drawLyrics(hwState, W, H) {
     if (!hwState.lyrics.length) return;
 
     const fontSize = Math.max(18, H * 0.028) | 0;
     const lineY = H * 0.04;
+    const cfg = getLyricsDisplayCfg();
 
     // Vocal markers: a trailing "-" means the syllable joins the
     // next one into a single word (no space); a trailing "+" marks the end
@@ -975,67 +1010,88 @@ export function drawLyrics(hwState, W, H) {
     const allLines = hwState.lyrics._lines;
     if (!allLines.length) return;
 
-    // Current line = most recently started line. Before the first line has
-    // started, preview the first line if it's within 2s of starting.
-    let currentIdx = -1;
-    for (let i = 0; i < allLines.length; i++) {
-        if (allLines[i].start <= hwState.currentTime) currentIdx = i;
-        else break;
-    }
-    if (currentIdx === -1) {
-        if (allLines[0].start - hwState.currentTime > 2.0) return;
-        currentIdx = 0;
-    }
-
-    const currentLine = allLines[currentIdx];
-    const nextLine = allLines[currentIdx + 1] || null;
-    const gapToNext = nextLine ? (nextLine.start - currentLine.end) : Infinity;
-
-    // Hide once the current line is clearly over and nothing relevant follows.
-    if (hwState.currentTime > currentLine.end + 0.5 && gapToNext > 3.0) return;
-
-    const linesToShow = [currentLine];
-    if (nextLine && gapToNext <= 3.0) linesToShow.push(nextLine);
-
     const sylText = (s) => {
         const t = s.w || '';
         return (t.endsWith('+') || t.endsWith('-')) ? t.slice(0, -1) : t;
     };
 
     hwState.ctx.font = `bold ${fontSize}px sans-serif`;
-    const spaceWidth = _measureLyricText(hwState, hwState.ctx, fontSize, ' ');
     const maxWidth = W * 0.8;
 
-    // Respect authored line breaks; wrap only if a line overflows maxWidth.
-    const rows = [];
-    for (const authoredLine of linesToShow) {
-        let row = [], rowWidth = 0;
-        for (const wordSyls of authoredLine.words) {
-            const parts = [];
-            let wordWidth = 0;
-            for (const s of wordSyls) {
-                const text = sylText(s);
-                const w = _measureLyricText(hwState, hwState.ctx, fontSize, text);
-                parts.push({ syl: s, text, width: w });
-                wordWidth += w;
+    // Display lines: authored lines pre-split at word boundaries so every
+    // display line fits maxWidth — one display line is exactly one rendered
+    // row. This is what keeps a giant transcribed line (word-timed lyrics
+    // break only on long gaps) from blowing up into an unbounded wrap block:
+    // its segments become ordinary lines that scroll through the window
+    // below. Cached per (lyrics, fontSize, W); measure work never runs per
+    // frame.
+    let layout = hwState._lyricLayout;
+    if (!layout || layout.lyricsRef !== hwState.lyrics || layout.fontSize !== fontSize || layout.W !== W) {
+        const spaceWidth = _measureLyricText(hwState, hwState.ctx, fontSize, ' ');
+        const displayLines = [];
+        for (const authoredLine of allLines) {
+            let row = [], rowWidth = 0, start = null, end = null;
+            const flushRow = () => {
+                if (!row.length) return;
+                displayLines.push({ row, width: rowWidth - spaceWidth, start, end });
+                row = []; rowWidth = 0; start = null; end = null;
+            };
+            for (const wordSyls of authoredLine.words) {
+                const parts = [];
+                let wordWidth = 0;
+                for (const s of wordSyls) {
+                    const text = sylText(s);
+                    const w = _measureLyricText(hwState, hwState.ctx, fontSize, text);
+                    parts.push({ syl: s, text, width: w });
+                    wordWidth += w;
+                }
+                const advance = wordWidth + spaceWidth;
+                if (row.length > 0 && rowWidth + advance > maxWidth) flushRow();
+                row.push({ parts, advance });
+                rowWidth += advance;
+                const first = wordSyls[0], last = wordSyls[wordSyls.length - 1];
+                if (start === null) start = first.t;
+                end = end === null ? last.t + last.d : Math.max(end, last.t + last.d);
             }
-            const advance = wordWidth + spaceWidth;
-            if (row.length > 0 && rowWidth + advance > maxWidth) {
-                rows.push(row);
-                row = []; rowWidth = 0;
-            }
-            row.push({ parts, advance });
-            rowWidth += advance;
+            flushRow();
         }
-        if (row.length) rows.push(row);
+        layout = hwState._lyricLayout = { lyricsRef: hwState.lyrics, fontSize, W, spaceWidth, displayLines };
+    }
+    const displayLines = layout.displayLines;
+    const spaceWidth = layout.spaceWidth;
+    if (!displayLines.length) return;
+
+    // Rolling window: the current line plus up to cfg.upcomingLines of
+    // context. An upcoming line joins the window once it starts within
+    // cfg.lookaheadSec (this also serves as the pre-song preview window).
+    let currentIdx = -1;
+    for (let i = 0; i < displayLines.length; i++) {
+        if (displayLines[i].start <= hwState.currentTime) currentIdx = i;
+        else break;
+    }
+    const nextLine = displayLines[currentIdx + 1] || null;
+    // Hide once the current line is clearly over and nothing upcoming is
+    // close enough to preview.
+    if (currentIdx >= 0
+        && hwState.currentTime > displayLines[currentIdx].end + 0.5
+        && (!nextLine || nextLine.start - hwState.currentTime > cfg.lookaheadSec)) {
+        return;
     }
 
+    const maxLines = 1 + cfg.upcomingLines;
+    const startIdx = currentIdx === -1 ? 0 : currentIdx;
+    const shown = [];
+    for (let i = startIdx; i < displayLines.length && shown.length < maxLines; i++) {
+        if (i !== currentIdx && displayLines[i].start - hwState.currentTime > cfg.lookaheadSec) break;
+        shown.push(displayLines[i]);
+    }
+    if (!shown.length) return;
+
     const rowHeight = fontSize + 6;
-    const totalHeight = rows.length * rowHeight + 10;
+    const totalHeight = shown.length * rowHeight + 10;
     let bgWidth = 0;
-    for (const row of rows) {
-        const rw = row.reduce((s, w) => s + w.advance, 0) - spaceWidth;
-        if (rw > bgWidth) bgWidth = rw;
+    for (const dl of shown) {
+        if (dl.width > bgWidth) bgWidth = dl.width;
     }
     bgWidth = Math.min(bgWidth + 30, W * 0.85);
 
@@ -1046,10 +1102,9 @@ export function drawLyrics(hwState, W, H) {
     hwState.ctx.textAlign = 'left';
     hwState.ctx.textBaseline = 'top';
 
-    for (let r = 0; r < rows.length; r++) {
-        const row = rows[r];
-        const rowWidth = row.reduce((s, w) => s + w.advance, 0) - spaceWidth;
-        let xPos = W/2 - rowWidth/2;
+    for (let r = 0; r < shown.length; r++) {
+        const row = shown[r].row;
+        let xPos = W/2 - shown[r].width/2;
         const yPos = lineY + r * rowHeight + 2;
 
         for (const w of row) {

static/v3/index.html

@@ -1194,10 +1194,6 @@
                         <button id="arr-default-pin" type="button" onclick="pinCurrentArrangementDefault()" aria-pressed="false" aria-label="Select an arrangement to make it the default" class="v3-pop-pin" title="Select an arrangement to make it the default">☆</button>
                     </span>
                 </div>
-                <div class="v3-pop-row hidden" id="v3-drum-part-row">
-                    <span class="v3-pop-label">Drum part</span>
-                    <select id="drum-part-select" onchange="changeDrumPart(this.value)" class="v3-pop-select max-w-[130px]" title="Which drum chart to play — a song can carry several"></select>
-                </div>
                 <div class="v3-pop-row">
                     <span class="v3-pop-label" id="mastery-slider-label">Difficulty</span>
                     <span class="flex items-center gap-2">

tests/js/highway_chart_transform.test.js

@@ -316,7 +316,7 @@ test('anchor zoom helpers read the staged anchors first', () => {
 test('init and reconnect clear the stage but keep the provider', () => {
     const src = fs.readFileSync(highwayJs, 'utf8');
     const initBody = extractBlock(src, 'init(canvasEl, container)');
-    const reconnectBody = extractBlock(src, 'reconnect(filename, arrangement, drumPart)');
+    const reconnectBody = extractBlock(src, 'reconnect(filename, arrangement)');
     assert.match(initBody, /_clearChartTransformStage\(\);/, 'init clears the stage');
     assert.match(reconnectBody, /_clearChartTransformStage\(\);/, 'reconnect clears the stage');
     assert.ok(!/init\([\s\S]{0,2000}_xfProvider = null/.test(src.slice(src.indexOf('const api = {'))),

tests/js/highway_lyrics_window.test.js

@@ -0,0 +1,178 @@
+// Behavioural tests for the lyric display window (drawLyrics in
+// static/js/highway-draw.js): width-based pre-splitting of long lines,
+// the rolling current+upcoming window, its caps, and the live-tunable
+// config reader. Extraction-by-source pattern per highway_teaching_marks.
+//
+// The 3D plugin (plugins/highway_3d/screen.js) carries a deliberate
+// duplicate of this logic; these tests pin the canonical copy.
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const SRC = fs.readFileSync(
+    path.join(__dirname, '..', '..', 'static', 'js', 'highway-draw.js'), 'utf8');
+
+function extractFn(src, name) {
+    const start = src.indexOf('function ' + name);
+    assert.ok(start >= 0, `function ${name} must exist`);
+    const open = src.indexOf('{', start);
+    let depth = 0;
+    for (let i = open; i < src.length; i++) {
+        if (src[i] === '{') depth++;
+        else if (src[i] === '}' && --depth === 0) return { text: src.slice(start, i + 1), end: i + 1 };
+    }
+    throw new Error(`unbalanced braces extracting ${name}`);
+}
+
+// getLyricsDisplayCfg with its module-level state: slice from the defaults
+// const through the end of the function so the real declarations come along.
+function loadCfgReader(storage) {
+    const constIdx = SRC.indexOf('const LYRICS_DISPLAY_DEFAULTS');
+    assert.ok(constIdx >= 0);
+    const fn = extractFn(SRC, 'getLyricsDisplayCfg');
+    const body = SRC.slice(constIdx, fn.end).replace(/^export /gm, '');
+    return new Function('localStorage', '"use strict";' + body + '\nreturn getLyricsDisplayCfg;')(storage);
+}
+
+function makeStorage(initial) {
+    const store = new Map(Object.entries(initial || {}));
+    return {
+        getItem: (k) => (store.has(k) ? store.get(k) : null),
+        setItem: (k, v) => store.set(k, String(v)),
+    };
+}
+
+test('cfg reader: defaults, clamping, corrupt JSON, live re-read', () => {
+    const storage = makeStorage();
+    const read = loadCfgReader(storage);
+    assert.deepEqual(read(), { upcomingLines: 2, lookaheadSec: 4 });
+
+    storage.setItem('lyricsDisplay', JSON.stringify({ upcomingLines: 99, lookaheadSec: 0 }));
+    assert.deepEqual(read(), { upcomingLines: 4, lookaheadSec: 1 }); // clamped
+
+    storage.setItem('lyricsDisplay', '{not json');
+    assert.deepEqual(read(), { upcomingLines: 2, lookaheadSec: 4 }); // corrupt -> defaults
+
+    storage.setItem('lyricsDisplay', JSON.stringify({ upcomingLines: 1 }));
+    assert.deepEqual(read(), { upcomingLines: 1, lookaheadSec: 4 }); // partial merges over defaults
+});
+
+// ── drawLyrics harness ───────────────────────────────────────────────────
+// Deps injected: _measureLyricText (10px per char), roundRect (noop),
+// getLyricsDisplayCfg (test-controlled). ctx records fillText rows.
+function loadDrawLyrics(cfg) {
+    const fn = extractFn(SRC, 'drawLyrics');
+    return new Function(
+        '_measureLyricText', 'roundRect', 'getLyricsDisplayCfg',
+        '"use strict";' + fn.text + '\nreturn drawLyrics;'
+    )(
+        (hw, ctx, fs_, text) => text.length * 10,
+        () => {},
+        () => cfg
+    );
+}
+
+function makeCtx() {
+    const calls = [];
+    return {
+        calls,
+        font: '', fillStyle: '', textAlign: '', textBaseline: '',
+        fillText: (text, x, y) => calls.push({ text, x, y }),
+        fill: () => {}, beginPath: () => {},
+        measureText: (t) => ({ width: t.length * 10 }),
+    };
+}
+
+function rowsDrawn(ctx) {
+    return new Set(ctx.calls.map(c => c.y)).size;
+}
+
+// Word-timed syllables, one per word, `plus` marks authored line ends.
+function syl(t, w, plus) { return { t, d: 0.4, w: plus ? w + '+' : w }; }
+
+const H = 1000; // fontSize = max(18, 28) = 28
+
+test('line-timed lyrics: current + upcoming context lines shown', () => {
+    // Four short authored lines, 2s apart — all inside an 8s lookahead.
+    const lyrics = [
+        syl(10, 'one', true), syl(12, 'two', true),
+        syl(14, 'three', true), syl(16, 'four', true),
+    ];
+    const draw = loadDrawLyrics({ upcomingLines: 2, lookaheadSec: 8 });
+    const ctx = makeCtx();
+    draw({ lyrics, ctx, currentTime: 10.1 }, 2000, H);
+    assert.equal(rowsDrawn(ctx), 3, 'current + 2 upcoming');
+    assert.deepEqual(ctx.calls.map(c => c.text), ['one', 'two', 'three']);
+});
+
+test('upcomingLines: 0 shows only the current line', () => {
+    const lyrics = [syl(10, 'one', true), syl(12, 'two', true)];
+    const draw = loadDrawLyrics({ upcomingLines: 0, lookaheadSec: 8 });
+    const ctx = makeCtx();
+    draw({ lyrics, ctx, currentTime: 10.1 }, 2000, H);
+    assert.equal(rowsDrawn(ctx), 1);
+    assert.deepEqual(ctx.calls.map(c => c.text), ['one']);
+});
+
+test('lookahead gates upcoming lines', () => {
+    // Next line 20s away — outside an 8s lookahead.
+    const lyrics = [syl(10, 'one', true), syl(30, 'far', true)];
+    const draw = loadDrawLyrics({ upcomingLines: 2, lookaheadSec: 8 });
+    const ctx = makeCtx();
+    draw({ lyrics, ctx, currentTime: 10.1 }, 2000, H);
+    assert.deepEqual(ctx.calls.map(c => c.text), ['one']);
+});
+
+test('a giant unmarked line splits into rows capped by the window', () => {
+    // 40 words, no "+" anywhere, continuous timing (gaps < 4s): the old
+    // renderer wrapped all of it at once. Narrow canvas (W=300 →
+    // maxWidth=240) forces splits; the window must cap what is drawn at
+    // 1 current + 2 upcoming rows, never the whole blob.
+    const lyrics = [];
+    for (let i = 0; i < 40; i++) lyrics.push(syl(10 + i * 0.5, 'word' + i, false));
+    const draw = loadDrawLyrics({ upcomingLines: 2, lookaheadSec: 8 });
+    const ctx = makeCtx();
+    draw({ lyrics, ctx, currentTime: 10.1 }, 300, H);
+    assert.ok(rowsDrawn(ctx) <= 3, `expected <=3 rows, got ${rowsDrawn(ctx)}`);
+    assert.ok(ctx.calls.length < 40, 'must not draw the entire blob');
+    assert.equal(ctx.calls[0].text, 'word0', 'current segment starts the window');
+});
+
+test('pre-song preview appears within lookahead, not before', () => {
+    const lyrics = [syl(10, 'one', true)];
+    const draw = loadDrawLyrics({ upcomingLines: 2, lookaheadSec: 8 });
+
+    const early = makeCtx();
+    draw({ lyrics, ctx: early, currentTime: 0 }, 2000, H); // 10s out > 8s
+    assert.equal(early.calls.length, 0);
+
+    const near = makeCtx();
+    draw({ lyrics, ctx: near, currentTime: 3 }, 2000, H); // 7s out <= 8s
+    assert.deepEqual(near.calls.map(c => c.text), ['one']);
+});
+
+test('banner hides during an instrumental gap, returns within lookahead', () => {
+    // The "Marks Of The Evil One" report: short authored lines around a ~6s
+    // instrumental gap. Mid-gap the banner must hide (nothing is being
+    // sung), then return once the next line is inside the lookahead.
+    const lyrics = [syl(10, 'sung', true), syl(17, 'next', true)];
+    const draw = loadDrawLyrics({ upcomingLines: 2, lookaheadSec: 4 });
+
+    const midGap = makeCtx();
+    draw({ lyrics, ctx: midGap, currentTime: 12 }, 2000, H); // next is 5s out
+    assert.equal(midGap.calls.length, 0, 'mid-gap: no unsung lyrics on screen');
+
+    const nearNext = makeCtx();
+    draw({ lyrics, ctx: nearNext, currentTime: 13.5 }, 2000, H); // 3.5s out
+    assert.deepEqual(nearNext.calls.map(c => c.text), ['sung', 'next']);
+});
+
+test('banner hides after the last line ends with nothing upcoming', () => {
+    const lyrics = [syl(10, 'one', true)];
+    const draw = loadDrawLyrics({ upcomingLines: 2, lookaheadSec: 8 });
+    const ctx = makeCtx();
+    draw({ lyrics, ctx, currentTime: 15 }, 2000, H); // ended at 10.4, +0.5 grace
+    assert.equal(ctx.calls.length, 0);
+});

tests/plugins/career/test_routes.py

@@ -83,25 +83,10 @@ def test_download_without_published_pack_404s(client):
 
 def test_download_locked_venue_403s(client, monkeypatch):
     club = career_routes._venue("club")
-    monkeypatch.setitem(club, "pack", {"url": "http://x/pack.zip", "sha256": "0" * 64, "bytes": 123})
+    monkeypatch.setitem(club, "pack", {"url": "http://x/pack.zip", "sha256": "0" * 64})
     assert client.post("/api/plugins/career/packs/club/download").status_code == 403
 
 
-def test_placeholder_pack_is_not_offered_until_published(client, monkeypatch):
-    # A committed manifest carries a 0-byte placeholder until its release is
-    # published. Such a pack must not be offered (has_pack False) and its
-    # download must 404 — else the UI shows a button that can only fail.
-    monkeypatch.setattr(career_routes, "_bundled", lambda vid: False)
-    club = career_routes._venue("club")
-    monkeypatch.setitem(club, "pack",
-                        {"url": "http://x/c.zip", "sha256": "0" * 64, "bytes": 0})
-    by_id = {v["id"]: v for v in client.get("/api/plugins/career/state").json()["venues"]}
-    assert by_id["club"]["has_pack"] is False          # placeholder → not offered
-    assert by_id["arena"]["has_pack"] is True          # arena ships real bytes
-    # Even forced, an unpublished pack won't start a download.
-    assert client.post("/api/plugins/career/packs/club/download").status_code == 404
-
-
 def test_bundled_bar_pack_is_installed_and_served(client):
     state = client.get("/api/plugins/career/state").json()
     bar = {v["id"]: v for v in state["venues"]}["bar"]
@@ -182,53 +167,9 @@ def test_download_worker_end_to_end(client, tmp_path):
     assert "sha256" in bad["error"]
 
 
-def test_content_packs_build_roundtrips_through_download(client, tmp_path):
-    # tools/content_packs.py must produce a zip the real career worker accepts:
-    # build_pack → manifest_entry → _download_pack → installed.
-    from tools import content_packs
-
-    src = tmp_path / "bar"
-    src.mkdir()
-    for s in career_routes.REQUIRED_LOOPS:
-        (src / f"{s}.mp4").write_bytes(b"fake-" + s.encode())
-    (src / "cheer.mp4").write_bytes(b"fake-cheer")
-    (src / "manifest.json").write_text(json.dumps({
-        "venue": "bar", "version": 1,
-        "loops": {s: f"{s}.mp4" for s in career_routes.REQUIRED_LOOPS},
-        "stingers": {"cheer": "cheer.mp4"},
-    }))
-    out_dir = tmp_path / "packs"
-    zip_path = out_dir / content_packs.pack_asset("bar", 1)
-    info = content_packs.build_pack(src, zip_path)
-    entry = content_packs.manifest_entry(zip_path, zip_path.resolve().as_uri())
-    assert entry["sha256"] == info["sha256"] and entry["bytes"] == info["bytes"]
-
-    progress = {"status": "running", "bytes_done": 0, "bytes_total": 0, "error": None}
-    career_routes._download_pack("bar", entry, progress)
-    assert progress["status"] == "done", progress["error"]
-    assert career_routes._installed("bar")
-
-
-def test_content_packs_rejects_files_the_downloader_would_refuse(tmp_path):
-    # A stray file (e.g. macOS .DS_Store) must fail the build, not get published
-    # and then break every client's download at _validate_pack_dir.
-    from tools import content_packs
-
-    src = tmp_path / "bar"
-    src.mkdir()
-    (src / "bored.mp4").write_bytes(b"fake")
-    (src / ".DS_Store").write_bytes(b"junk")
-    try:
-        content_packs.build_pack(src, tmp_path / "bar-pack-v1.zip")
-    except ValueError as e:
-        assert "downloader will reject" in str(e)
-    else:
-        raise AssertionError("build_pack accepted a .DS_Store the downloader rejects")
-
-
 def test_double_download_409s(client, monkeypatch):
     bar = career_routes._venue("bar")
-    monkeypatch.setitem(bar, "pack", {"url": "http://x/pack.zip", "sha256": "0" * 64, "bytes": 123})
+    monkeypatch.setitem(bar, "pack", {"url": "http://x/pack.zip", "sha256": "0" * 64})
     # Pretend one is already running.
     career_routes._state["downloads"]["bar"] = {"status": "running"}
     assert client.post("/api/plugins/career/packs/bar/download").status_code == 409

tests/test_content_packs_vst.py

@@ -1,91 +0,0 @@
-"""VST-pack slicing (tools/content_packs.build_vst_pack): each platform pack
-keeps only its own binaries + the shared bundle files, drops the rest, and is
-reproducible."""
-import zipfile
-from pathlib import Path
-
-from tools import content_packs
-
-
-def _fake_vst_tree(root: Path):
-    # One fat .vst3 with all three platform binaries + shared files, plus a
-    # src/ build tree that must never ship.
-    c = root / "amps" / "Foo.vst3" / "Contents"
-    (c / "MacOS").mkdir(parents=True)
-    (c / "x86_64-win").mkdir(parents=True)
-    (c / "x86_64-linux").mkdir(parents=True)
-    (c / "Resources").mkdir(parents=True)
-    (c / "MacOS" / "Foo").write_bytes(b"mac-binary")
-    (c / "x86_64-win" / "Foo.vst3").write_bytes(b"win-binary")
-    (c / "x86_64-linux" / "Foo.so").write_bytes(b"linux-binary")
-    (c / "Info.plist").write_bytes(b"<plist/>")
-    (c / "Resources" / "moduleinfo.json").write_bytes(b"{}")
-    (root / "src" / "build").mkdir(parents=True)
-    (root / "src" / "build" / "junk.o").write_bytes(b"objfile")
-
-
-def _names(zip_path):
-    with zipfile.ZipFile(zip_path) as zf:
-        return set(zf.namelist())
-
-
-def test_slice_keeps_target_platform_and_shared_drops_foreign(tmp_path):
-    root = tmp_path / "vst"
-    _fake_vst_tree(root)
-    content_packs.build_vst_pack(root, tmp_path / "mac.zip", "mac")
-    names = _names(tmp_path / "mac.zip")
-
-    base = "amps/Foo.vst3/Contents"
-    assert f"{base}/MacOS/Foo" in names                 # target binary kept
-    assert f"{base}/Info.plist" in names                # shared kept
-    assert f"{base}/Resources/moduleinfo.json" in names  # shared kept
-    assert f"{base}/x86_64-win/Foo.vst3" not in names    # foreign dropped
-    assert f"{base}/x86_64-linux/Foo.so" not in names    # foreign dropped
-    assert not any(n.startswith("src/") for n in names)  # build trees never ship
-
-
-def test_each_platform_gets_its_own_binary(tmp_path):
-    root = tmp_path / "vst"
-    _fake_vst_tree(root)
-    wanted = {"mac": "MacOS/Foo", "win": "x86_64-win/Foo.vst3", "linux": "x86_64-linux/Foo.so"}
-    for plat, rel in wanted.items():
-        content_packs.build_vst_pack(root, tmp_path / f"{plat}.zip", plat)
-        names = _names(tmp_path / f"{plat}.zip")
-        assert f"amps/Foo.vst3/Contents/{rel}" in names
-        others = [v for k, v in wanted.items() if k != plat]
-        for o in others:
-            assert f"amps/Foo.vst3/Contents/{o}" not in names
-
-
-def test_slice_is_reproducible(tmp_path):
-    root = tmp_path / "vst"
-    _fake_vst_tree(root)
-    a = content_packs.build_vst_pack(root, tmp_path / "a.zip", "linux")
-    b = content_packs.build_vst_pack(root, tmp_path / "b.zip", "linux")
-    assert a == b and a["sha256"]
-
-
-def test_slice_pins_create_system_for_cross_runner_reproducibility(tmp_path, monkeypatch):
-    # ZipInfo defaults create_system from the host OS (0 on Windows, 3 on Unix),
-    # and it lands in the central directory — so without an explicit pin the same
-    # tree hashes differently on a Windows runner, breaking the precomputable-hash
-    # guarantee exactly where it matters (native .vst3 are built on Windows). A
-    # same-machine reproducibility test can't catch that; simulate win32 and
-    # assert the pin forces 3 regardless.
-    monkeypatch.setattr(zipfile.sys, "platform", "win32")
-    root = tmp_path / "vst"
-    _fake_vst_tree(root)
-    content_packs.build_vst_pack(root, tmp_path / "w.zip", "linux")
-    with zipfile.ZipFile(tmp_path / "w.zip") as zf:
-        assert all(i.create_system == 3 for i in zf.infolist())
-
-
-def test_unknown_platform_rejected(tmp_path):
-    root = tmp_path / "vst"
-    _fake_vst_tree(root)
-    try:
-        content_packs.build_vst_pack(root, tmp_path / "x.zip", "bsd")
-    except ValueError as e:
-        assert "unknown platform" in str(e)
-    else:
-        raise AssertionError("build_vst_pack accepted an unknown platform")

tests/test_highway_ws_drum_parts.py

@@ -1,17 +0,0 @@
-"""Wire-compatibility coverage for selectable drum parts."""
-
-from routers.ws_highway import _drum_part_id_for_wire
-
-
-def test_single_synthesized_part_keeps_legacy_frame_without_part_id():
-    parts = [{"id": "drums", "name": "Drums", "drum_tab": {}}]
-    assert _drum_part_id_for_wire(parts, "drums") is None
-
-
-def test_multiple_parts_expose_selected_part_id():
-    parts = [
-        {"id": "drums", "name": "Drums", "drum_tab": {}},
-        {"id": "drums-2", "name": "Aux", "drum_tab": {}},
-    ]
-    assert _drum_part_id_for_wire(parts, "drums-2") == "drums-2"
-    assert _drum_part_id_for_wire(parts, None) is None

tests/test_sloppak_drum_parts.py

@@ -1,295 +0,0 @@
-"""Loader coverage for MULTIPLE drum parts (feedpak 1.17.0 "drums as
-arrangements").
-
-A drum part rides the manifest as a `type: drums` arrangement entry carrying
-a per-arrangement `drum_tab` file pointer and NO note `file`. The loader:
-
-  - NEVER turns a pointer entry into a fretted Arrangement — that skip is
-    the grading invariant (an empty drum chart must not reach the fretted
-    pipeline, where note detection would grade it as garbage);
-  - resolves the parts into `LoadedSloppak.drum_parts`, primary FIRST: the
-    entry aliasing the song-level `drum_tab:` file contributes its id/name
-    but is never loaded twice (its payload IS `loaded.drum_tab`);
-  - loads each extra part's file with the same permissive posture as the
-    song-level tab (a bad part disables that part only, never the load);
-  - copes with a pointer-only pack (no song-level key): the first part
-    becomes the primary so every legacy consumer keeps working.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-from pathlib import Path
-
-import yaml
-
-import sloppak as sloppak_mod
-
-
-def _tab(name: str, hits: list[dict] | None = None) -> dict:
-    return {
-        "version": 1,
-        "name": name,
-        "kit": [{"id": "kick", "name": "Kick"}],
-        "hits": hits if hits is not None else [{"t": 1.0, "p": "kick", "v": 100}],
-    }
-
-
-def _write_pak(root: Path, manifest_extras: dict, files: dict[str, dict | str]) -> Path:
-    """A minimal directory-form sloppak with one Lead arrangement plus the
-    given extra files ({relpath: json-dict-or-raw-text})."""
-    pak = root / f"{root.name}.sloppak"
-    pak.mkdir()
-    arr_dir = pak / "arrangements"
-    arr_dir.mkdir()
-    arr = {
-        "name": "Lead", "tuning": [0, 0, 0, 0, 0, 0], "capo": 0,
-        "notes": [], "chords": [], "anchors": [], "handshapes": [],
-        "templates": [], "beats": [], "sections": [],
-    }
-    (arr_dir / "lead.json").write_text(json.dumps(arr))
-    manifest = {
-        "title": "Test", "artist": "Tester", "album": "", "year": 2026,
-        "duration": 10.0,
-        "arrangements": [
-            {"id": "lead", "name": "Lead", "file": "arrangements/lead.json"},
-        ],
-        "stems": [{"id": "full", "file": "stems/full.ogg", "default": True}],
-    }
-    manifest.update(manifest_extras)
-    (pak / "manifest.yaml").write_text(yaml.safe_dump(manifest, sort_keys=False))
-    for rel, payload in files.items():
-        text = payload if isinstance(payload, str) else json.dumps(payload)
-        (pak / rel).write_text(text)
-    return pak
-
-
-def _load(pak_path: Path, tmp_path: Path):
-    dlc_root = pak_path.parent
-    cache = tmp_path / "cache"
-    cache.mkdir()
-    return sloppak_mod.load_song(pak_path.name, dlc_root, cache)
-
-
-def _two_part_manifest() -> dict:
-    """The exact shape the editor writes: primary alias entry + one extra."""
-    return {
-        "drum_tab": "drum_tab.json",
-        "arrangements": [
-            {"id": "lead", "name": "Lead", "file": "arrangements/lead.json"},
-            {"id": "drums", "name": "Drums", "type": "drums",
-             "drum_tab": "drum_tab.json"},
-            {"id": "drums-2", "name": "Drums (Live)", "type": "drums",
-             "drum_tab": "drum_tab_drums-2.json"},
-        ],
-    }
-
-
-# ── The grading invariant ────────────────────────────────────────────────────
-
-def test_pointer_entries_never_become_fretted_arrangements(tmp_path: Path):
-    pak = _write_pak(tmp_path, _two_part_manifest(), {
-        "drum_tab.json": _tab("Drums"),
-        "drum_tab_drums-2.json": _tab("Drums (Live)"),
-    })
-    loaded = _load(pak, tmp_path)
-    # Only the Lead chart is an Arrangement — neither drum part enters the
-    # fretted pipeline (song.arrangements is what note detection grades).
-    assert [a.name for a in loaded.song.arrangements] == ["Lead"]
-    # And the ids list stays parallel to song.arrangements (skipped entries
-    # contribute nothing) — a misalignment here would remap every chart edit.
-    assert loaded.arrangement_ids == ["lead"]
-
-
-def test_drums_typed_entry_with_note_file_never_frets(tmp_path: Path):
-    # A malformed entry: type:drums but ALSO carrying a note `file`. Keying the
-    # skip on file absence would let it through as a fretted, selectable,
-    # gradeable Arrangement (spec §5.2/§7.5 MUST-NOT). Routing on `type` first
-    # drops it instead — it never reaches song.arrangements.
-    bogus = {
-        "name": "Bogus", "tuning": [0, 0, 0, 0, 0, 0], "capo": 0,
-        "notes": [], "chords": [], "anchors": [], "handshapes": [],
-        "templates": [], "beats": [], "sections": [],
-    }
-    pak = _write_pak(tmp_path, {
-        "arrangements": [
-            {"id": "lead", "name": "Lead", "file": "arrangements/lead.json"},
-            {"id": "bad", "name": "Bogus", "type": "drums",
-             "file": "arrangements/bogus.json"},
-        ],
-    }, {"arrangements/bogus.json": bogus})
-    loaded = _load(pak, tmp_path)
-    assert [a.name for a in loaded.song.arrangements] == ["Lead"]
-    assert loaded.arrangement_ids == ["lead"]
-
-
-# ── Parts resolution ─────────────────────────────────────────────────────────
-
-def test_two_parts_resolve_primary_first_with_alias_identity(tmp_path: Path):
-    pak = _write_pak(tmp_path, _two_part_manifest(), {
-        "drum_tab.json": _tab("Drums"),
-        "drum_tab_drums-2.json": _tab("Drums (Live)", [{"t": 2.0, "p": "kick", "v": 90}]),
-    })
-    loaded = _load(pak, tmp_path)
-    assert loaded.drum_parts is not None
-    assert [(p["id"], p["name"]) for p in loaded.drum_parts] == [
-        ("drums", "Drums"), ("drums-2", "Drums (Live)"),
-    ]
-    # The primary's payload IS the song-level tab — same object, loaded once.
-    assert loaded.drum_parts[0]["drum_tab"] is loaded.drum_tab
-    assert loaded.drum_parts[1]["drum_tab"]["hits"][0]["t"] == 2.0
-
-
-def test_primary_pointer_equivalent_path_is_not_duplicated(tmp_path: Path):
-    manifest = {
-        "drum_tab": "drum_tab.json",
-        "arrangements": [
-            {"id": "lead", "name": "Lead", "file": "arrangements/lead.json"},
-            {"id": "kit", "name": "Live Kit", "type": "drums",
-             "drum_tab": "./drum_tab.json"},
-        ],
-    }
-    pak = _write_pak(tmp_path, manifest, {"drum_tab.json": _tab("Drums")})
-    loaded = _load(pak, tmp_path)
-    assert loaded.drum_parts is not None
-    assert [(p["id"], p["name"]) for p in loaded.drum_parts] == [
-        ("kit", "Live Kit"),
-    ]
-    assert loaded.drum_parts[0]["drum_tab"] is loaded.drum_tab
-
-
-def test_legacy_single_drum_pack_gets_a_one_part_list(tmp_path: Path):
-    pak = _write_pak(tmp_path, {"drum_tab": "drum_tab.json"}, {
-        "drum_tab.json": _tab("Drums"),
-    })
-    loaded = _load(pak, tmp_path)
-    assert loaded.drum_parts is not None and len(loaded.drum_parts) == 1
-    assert loaded.drum_parts[0]["id"] == "drums"
-    assert loaded.drum_parts[0]["drum_tab"] is loaded.drum_tab
-
-
-def test_no_drums_means_no_parts(tmp_path: Path):
-    pak = _write_pak(tmp_path, {}, {})
-    loaded = _load(pak, tmp_path)
-    assert loaded.drum_parts is None
-    assert loaded.drum_tab is None
-
-
-def test_pointer_only_pack_promotes_the_first_part_to_primary(tmp_path: Path):
-    # A writer that omitted the song-level alias: readers must cope (the
-    # spec keeps the alias, but a reader never crashes on its absence).
-    pak = _write_pak(tmp_path, {
-        "arrangements": [
-            {"id": "lead", "name": "Lead", "file": "arrangements/lead.json"},
-            {"id": "kit", "name": "Kit", "type": "drums",
-             "drum_tab": "drum_tab_kit.json"},
-        ],
-    }, {"drum_tab_kit.json": _tab("Kit")})
-    loaded = _load(pak, tmp_path)
-    assert loaded.drum_parts is not None and len(loaded.drum_parts) == 1
-    # The part's tab becomes THE drum tab, so has_drum_tab / the default
-    # stream / the drum-only placeholder all keep working.
-    assert loaded.drum_tab is loaded.drum_parts[0]["drum_tab"]
-    assert loaded.drum_parts[0]["id"] == "kit"
-
-
-# ── Permissive per-part failure ──────────────────────────────────────────────
-
-def test_a_bad_extra_part_disables_that_part_only(tmp_path: Path):
-    manifest = _two_part_manifest()
-    manifest["arrangements"].append(
-        {"id": "drums-3", "name": "Broken", "type": "drums",
-         "drum_tab": "drum_tab_broken.json"})
-    pak = _write_pak(tmp_path, manifest, {
-        "drum_tab.json": _tab("Drums"),
-        "drum_tab_drums-2.json": _tab("Drums (Live)"),
-        "drum_tab_broken.json": "not json {{{",
-    })
-    loaded = _load(pak, tmp_path)
-    assert [p["id"] for p in loaded.drum_parts] == ["drums", "drums-2"]
-
-
-def test_a_traversal_part_path_is_skipped(tmp_path: Path):
-    manifest = _two_part_manifest()
-    manifest["arrangements"][2]["drum_tab"] = "../outside.json"
-    (tmp_path / "outside.json").write_text(json.dumps(_tab("Evil")))
-    pak = _write_pak(tmp_path, manifest, {"drum_tab.json": _tab("Drums")})
-    loaded = _load(pak, tmp_path)
-    assert [p["id"] for p in loaded.drum_parts] == ["drums"]
-
-
-def test_duplicate_pointer_rels_load_once(tmp_path: Path):
-    manifest = _two_part_manifest()
-    manifest["arrangements"].append(
-        {"id": "drums-dup", "name": "Dup", "type": "drums",
-         "drum_tab": "drum_tab_drums-2.json"})
-    pak = _write_pak(tmp_path, manifest, {
-        "drum_tab.json": _tab("Drums"),
-        "drum_tab_drums-2.json": _tab("Drums (Live)"),
-    })
-    loaded = _load(pak, tmp_path)
-    assert [p["id"] for p in loaded.drum_parts] == ["drums", "drums-2"]
-
-
-def test_duplicate_part_ids_are_made_unique(tmp_path: Path):
-    manifest = _two_part_manifest()
-    manifest["arrangements"][2]["id"] = "drums"
-    manifest["arrangements"].append(
-        {"id": "drums-2", "name": "Aux", "type": "drums",
-         "drum_tab": "drum_tab_aux.json"})
-    pak = _write_pak(tmp_path, manifest, {
-        "drum_tab.json": _tab("Drums"),
-        "drum_tab_drums-2.json": _tab("Drums (Live)"),
-        "drum_tab_aux.json": _tab("Aux"),
-    })
-    loaded = _load(pak, tmp_path)
-    assert [p["id"] for p in loaded.drum_parts] == ["drums", "drums-2", "drums-3"]
-
-
-def test_drum_pointer_with_wrong_type_logs_warning(tmp_path: Path, caplog):
-    pak = _write_pak(tmp_path, {
-        "arrangements": [
-            {"id": "lead", "name": "Lead", "file": "arrangements/lead.json"},
-            {"id": "typo", "type": "druns", "drum_tab": "drum_tab_typo.json"},
-        ],
-    }, {"drum_tab_typo.json": _tab("Typo")})
-    # feedBack sets propagate=False, so pytest's root capture sees nothing from
-    # it — attach caplog's handler to the feedBack logger and pin WARNING
-    # regardless of ambient level (a sibling test can leak ERROR onto this tree).
-    lg = logging.getLogger("feedBack")
-    orig_level = lg.level
-    lg.addHandler(caplog.handler)
-    lg.setLevel(logging.WARNING)
-    try:
-        loaded = _load(pak, tmp_path)
-    finally:
-        lg.removeHandler(caplog.handler)
-        lg.setLevel(orig_level)
-    assert loaded.drum_parts is None
-    assert "has drum_tab" in caplog.text and "type='druns'" in caplog.text
-
-
-# ── Drum-only pack with parts ────────────────────────────────────────────────
-
-def test_drum_only_pack_with_pointer_entries_still_synthesizes_placeholder(tmp_path: Path):
-    # No pitched arrangements at all, drums via pointer entries only: the
-    # placeholder "Drums" arrangement must still appear so the highway WS
-    # proceeds and the tab reaches the drum highway.
-    pak = _write_pak(tmp_path, {
-        "arrangements": [
-            {"id": "kit", "name": "Kit", "type": "drums",
-             "drum_tab": "drum_tab_kit.json"},
-        ],
-    }, {"drum_tab_kit.json": _tab("Kit", [{"t": 5.0, "p": "kick", "v": 100}])})
-    # Remove the Lead arrangement _write_pak added to the manifest.
-    manifest_path = pak / "manifest.yaml"
-    manifest = yaml.safe_load(manifest_path.read_text())
-    manifest["arrangements"] = [e for e in manifest["arrangements"] if e.get("id") != "lead"]
-    manifest.pop("duration", None)
-    manifest_path.write_text(yaml.safe_dump(manifest, sort_keys=False))
-    loaded = _load(pak, tmp_path)
-    assert [a.name for a in loaded.song.arrangements] == ["Drums"]
-    assert loaded.drum_parts is not None and loaded.drum_parts[0]["id"] == "kit"
-    # Song length derived from the last hit (the drum-only path's rule).
-    assert loaded.song.song_length > 5.0

tests/test_song.py

@@ -329,31 +329,6 @@ def test_note_pitch_midi_bass_uses_bass_base():
     assert note_pitch_midi(bass, Note(time=0, string=0, fret=0)) == 28
 
 
-def test_note_pitch_midi_authored_bass_type_uses_bass_base():
-    """Editor PR #335: a bass authored via `type` on an arrangement whose NAME
-    doesn't say "bass". arrangement_string_count now returns 4 for it, so the
-    open-string base MUST also be the bass base (low E1 = 28), not the guitar
-    octave (40). Pre-fix note_pitch_midi keyed is_bass off the name only, so
-    this returned 40 (4 lanes on a guitar octave — the exact inconsistency)."""
-    bass = Arrangement(
-        name="Low End", type="bass",
-        tuning=[0, 0, 0, 0],
-        notes=[Note(time=float(i), string=i, fret=0) for i in range(4)],
-    )
-    assert note_pitch_midi(bass, Note(time=0, string=0, fret=0)) == 28
-
-
-def test_note_pitch_midi_path_bass_flag_uses_bass_base():
-    """Same guarantee via the archive <arrangementProperties> pathBass flag on a
-    non-"bass"-named arrangement: bass base (28), not guitar (40)."""
-    bass = Arrangement(
-        name="Low End", path_bass=True,
-        tuning=[0, 0, 0, 0],
-        notes=[Note(time=float(i), string=i, fret=0) for i in range(4)],
-    )
-    assert note_pitch_midi(bass, Note(time=0, string=0, fret=0)) == 28
-
-
 def test_note_pitch_midi_out_of_range_string_is_none():
     arr = Arrangement(name="Lead", tuning=[0, 0, 0, 0, 0, 0])
     assert note_pitch_midi(arr, Note(time=0, string=9, fret=0)) is None
@@ -1178,60 +1153,6 @@ def test_string_count_ignores_rs_padded_tuning_for_bass():
     assert arrangement_string_count(arr) == 4
 
 
-def test_string_count_4_for_path_bass_flag_without_bass_in_name():
-    # Archive/DLC bass whose manifest ArrangementName isn't "Bass" but whose
-    # <arrangementProperties> pathBass flag is set. Notes on 0..3, tuning
-    # padded to the arrangement-XML length of 6. Pre-fix, name_based forced
-    # 6 (name has no "bass"), so this returned 6 despite the authoritative
-    # instrument flag saying bass.
-    arr = Arrangement(
-        name="Low End",
-        path_bass=True,
-        tuning=[0, 0, 0, 0, 0, 0],
-        notes=[Note(time=float(i), string=i, fret=0) for i in range(4)],
-    )
-    assert arrangement_string_count(arr) == 4
-
-
-def test_string_count_4_for_authored_bass_type_without_bass_in_name():
-    # Editor PR #335: an instrument `type` authored as bass on an arrangement
-    # whose NAME does not contain "bass" (the sloppak loader lifts the manifest
-    # `type` onto Arrangement.type). Notes on 0..3, tuning padded to 6.
-    # The editor lays out 4 lanes off the type; core must agree.
-    arr = Arrangement(
-        name="Low End",
-        type="bass",
-        tuning=[0, 0, 0, 0, 0, 0],
-        notes=[Note(time=float(i), string=i, fret=0) for i in range(4)],
-    )
-    assert arrangement_string_count(arr) == 4
-
-
-def test_string_count_6_for_authored_guitar_type_no_regression():
-    # A non-bass authored type on a generic name still resolves to the
-    # canonical 6 — the type signal only pulls DOWN to 4 for bass.
-    arr = Arrangement(
-        name="Track 1",
-        type="guitar",
-        notes=[Note(time=float(i), string=i, fret=0) for i in range(5)],
-    )
-    assert arrangement_string_count(arr) == 6
-
-
-def test_arrangement_is_bass_signal_safety():
-    # The manifest `type` is lifted onto arr.type verbatim; the helper must be
-    # safe against the messy shapes a hand-edited/loose source can produce.
-    from song import arrangement_is_bass
-    assert arrangement_is_bass(Arrangement(name="Low End", type="bass"))
-    assert arrangement_is_bass(Arrangement(name="Low End", type=" BASS "))  # ws/case
-    assert arrangement_is_bass(Arrangement(name="Low End", path_bass=True))
-    assert arrangement_is_bass(Arrangement(name="Slap Bass"))               # legacy name
-    # Non-bass / absent signals stay False (back-compat: no bass signal → 6).
-    assert not arrangement_is_bass(Arrangement(name="Lead", type=""))
-    assert not arrangement_is_bass(Arrangement(name="Rhythm", type="guitar"))
-    assert not arrangement_is_bass(Arrangement(name="", type=""))
-
-
 # ── compute_smart_names ───────────────────────────────────────────────────────
 
 def _sarr(path_lead=False, path_rhythm=False, path_bass=False,

tests/test_tuning_provider_isolation.py

@@ -60,14 +60,12 @@ def test_the_failure_is_actually_logged(registry, caplog):
     # capture_logger() context manager for this, but it is not importable from here:
     # pyproject pins pythonpath to [".", "lib"], so `tests` is not a package.)
     lg = logging.getLogger("feedBack")
-    orig_level = lg.level
     lg.addHandler(caplog.handler)
     lg.setLevel(logging.ERROR)
     try:
         registry.get_merged()
     finally:
         lg.removeHandler(caplog.handler)
-        lg.setLevel(orig_level)  # restore, or ERROR leaks onto the feedBack tree
 
     assert any("bad-plugin" in r.getMessage() for r in caplog.records), (
         "the raising provider was never named in the logs"

tests/test_ws_sync.py

@@ -1,234 +0,0 @@
-"""Tests for the session-sync relay WebSocket (/ws/sync/{session_id}).
-
-Behavior tests run against a minimal FastAPI app carrying just the router
-(fast — no full-server import); one integration test imports the real server
-to pin that the route is actually mounted there.
-
-Covers the feedBack#1030 acceptance list: bidirectional fan-out, late join,
-sender never echoed, room garbage collection, and the limit closes (invalid
-session id, binary frames, frame size, room size, room count, rate cap) —
-including that one client tripping a limit doesn't disturb the others.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import importlib
-import sys
-import time
-
-import pytest
-from fastapi import FastAPI
-from fastapi.testclient import TestClient
-from starlette.websockets import WebSocketDisconnect
-
-from routers import ws_sync
-
-
-@pytest.fixture(autouse=True)
-def _clean_rooms():
-    ws_sync._rooms.clear()
-    yield
-    ws_sync._rooms.clear()
-
-
-@pytest.fixture()
-def client():
-    app = FastAPI()
-    app.include_router(ws_sync.router)
-    with TestClient(app) as c:
-        yield c
-
-
-def _expect_close(ws, code):
-    with pytest.raises(WebSocketDisconnect) as exc:
-        ws.receive_text()
-    assert exc.value.code == code
-
-
-# ── Fan-out semantics ────────────────────────────────────────────────────────
-
-def test_two_clients_relay_both_directions_and_no_echo(client):
-    with client.websocket_connect("/ws/sync/ROOM01") as a, \
-         client.websocket_connect("/ws/sync/ROOM01") as b:
-        a.send_text('{"type":"time","t":1.5}')
-        assert b.receive_text() == '{"type":"time","t":1.5}'
-        b.send_text('{"type":"hello"}')
-        # A's first inbound frame is B's hello — NOT an echo of its own send.
-        assert a.receive_text() == '{"type":"hello"}'
-
-
-def test_late_joiner_receives_subsequent_frames(client):
-    with client.websocket_connect("/ws/sync/ROOM02") as a, \
-         client.websocket_connect("/ws/sync/ROOM02") as b:
-        a.send_text("f1")
-        assert b.receive_text() == "f1"
-        with client.websocket_connect("/ws/sync/ROOM02") as c:
-            a.send_text("f2")
-            assert b.receive_text() == "f2"
-            assert c.receive_text() == "f2"
-
-
-def test_rooms_are_isolated(client):
-    with client.websocket_connect("/ws/sync/ROOMA1") as a, \
-         client.websocket_connect("/ws/sync/ROOMB1") as b, \
-         client.websocket_connect("/ws/sync/ROOMA1") as a2:
-        a.send_text("for-room-a")
-        assert a2.receive_text() == "for-room-a"
-        # B (other room) got nothing: prove it by relaying within B's room.
-        with client.websocket_connect("/ws/sync/ROOMB1") as b2:
-            b2.send_text("for-room-b")
-            assert b.receive_text() == "for-room-b"
-
-
-def test_client_disconnect_does_not_disrupt_remaining(client):
-    with client.websocket_connect("/ws/sync/ROOM03") as a, \
-         client.websocket_connect("/ws/sync/ROOM03") as b:
-        with client.websocket_connect("/ws/sync/ROOM03") as c:
-            a.send_text("before")
-            assert b.receive_text() == "before"
-            assert c.receive_text() == "before"
-        # C is gone; relay between A and B continues.
-        a.send_text("after")
-        assert b.receive_text() == "after"
-
-
-def test_room_garbage_collected_when_last_client_leaves(client):
-    with client.websocket_connect("/ws/sync/ROOM04") as a:
-        with client.websocket_connect("/ws/sync/ROOM04") as b:
-            a.send_text("x")
-            assert b.receive_text() == "x"
-            assert "ROOM04" in ws_sync._rooms
-    assert "ROOM04" not in ws_sync._rooms
-    assert ws_sync._rooms == {}
-
-
-# ── Limit enforcement ────────────────────────────────────────────────────────
-
-@pytest.mark.parametrize("bad_id", ["abc", "x" * 65, "has space", "bad$id", "nope!"])
-def test_invalid_session_id_closed_with_policy_code(client, bad_id):
-    with client.websocket_connect(f"/ws/sync/{bad_id}") as ws:
-        _expect_close(ws, 1008)
-    assert ws_sync._rooms == {}
-
-
-def test_binary_frame_closes_with_unsupported_data(client):
-    with client.websocket_connect("/ws/sync/ROOM05") as ws:
-        ws.send_bytes(b"\x00\x01")
-        _expect_close(ws, 1003)
-
-
-def test_oversized_frame_closes_sender_only(client):
-    with client.websocket_connect("/ws/sync/ROOM06") as a, \
-         client.websocket_connect("/ws/sync/ROOM06") as b, \
-         client.websocket_connect("/ws/sync/ROOM06") as c:
-        a.send_text("x" * (ws_sync.MAX_FRAME_BYTES + 1))
-        _expect_close(a, 1009)
-        # The room carries on without A.
-        b.send_text("still-alive")
-        assert c.receive_text() == "still-alive"
-
-
-def test_room_client_cap(client, monkeypatch):
-    monkeypatch.setattr(ws_sync, "MAX_CLIENTS_PER_ROOM", 2)
-    with client.websocket_connect("/ws/sync/ROOM07") as a, \
-         client.websocket_connect("/ws/sync/ROOM07") as b, \
-         client.websocket_connect("/ws/sync/ROOM07") as c:
-        _expect_close(c, 1013)
-        a.send_text("two-is-fine")
-        assert b.receive_text() == "two-is-fine"
-
-
-def test_total_room_cap(client, monkeypatch):
-    monkeypatch.setattr(ws_sync, "MAX_ROOMS", 1)
-    with client.websocket_connect("/ws/sync/ROOM08"):
-        with client.websocket_connect("/ws/sync/ROOM09") as overflow:
-            _expect_close(overflow, 1013)
-        # Joining the EXISTING room is still fine at the room cap.
-        with client.websocket_connect("/ws/sync/ROOM08"):
-            pass
-
-
-def test_rate_cap_closes_flooding_sender(client, monkeypatch):
-    monkeypatch.setattr(ws_sync, "RATE_BURST", 3.0)
-    monkeypatch.setattr(ws_sync, "RATE_MSGS_PER_SEC", 0.0)
-    with client.websocket_connect("/ws/sync/ROOM10") as a, \
-         client.websocket_connect("/ws/sync/ROOM10") as b:
-        for i in range(3):
-            a.send_text(f"burst-{i}")
-        for i in range(3):
-            assert b.receive_text() == f"burst-{i}"
-        a.send_text("one-too-many")
-        _expect_close(a, 1008)
-        # The over-limit frame was dropped, not relayed, and B lives on.
-        with client.websocket_connect("/ws/sync/ROOM10") as c:
-            c.send_text("fresh-socket")
-            assert b.receive_text() == "fresh-socket"
-
-
-class _StalledPeer:
-    """A fake room member whose send never completes (peer stopped draining)."""
-
-    async def send_text(self, text):
-        await asyncio.Event().wait()
-
-
-def test_stalled_peer_is_evicted_and_healthy_peers_still_receive(client, monkeypatch):
-    monkeypatch.setattr(ws_sync, "SEND_TIMEOUT_SECONDS", 0.2)
-    with client.websocket_connect("/ws/sync/ROOM11") as a, \
-         client.websocket_connect("/ws/sync/ROOM11") as b:
-        # Wait for both handlers to have registered in the room, then inject
-        # the stalled peer directly (a real stalled TCP peer isn't
-        # constructible under TestClient).
-        deadline = time.monotonic() + 2.0
-        while len(ws_sync._rooms.get("ROOM11", {})) < 2:
-            assert time.monotonic() < deadline, "room never filled"
-            time.sleep(0.01)
-        stalled = _StalledPeer()
-        ws_sync._rooms["ROOM11"][stalled] = asyncio.Lock()
-
-        # Healthy delivery is not blocked behind the stalled peer, and by the
-        # time a second frame has round-tripped, the first fan-out's timeout
-        # has fired and evicted it.
-        a.send_text("f1")
-        assert b.receive_text() == "f1"
-        a.send_text("f2")
-        assert b.receive_text() == "f2"
-        assert stalled not in ws_sync._rooms["ROOM11"]
-
-
-def test_main_run_caps_uvicorn_ws_max_size():
-    """main.py must bound inbound WS frames at the transport (uvicorn defaults
-    to 16 MB, which would let a client materialize frames far past the relay's
-    16 KB application cap before the handler ever sees them)."""
-    import unittest.mock
-
-    import main
-
-    with (
-        unittest.mock.patch("logging_setup.configure_logging"),
-        unittest.mock.patch("uvicorn.run") as mock_run,
-    ):
-        main.run()
-
-    kwargs = mock_run.call_args.kwargs
-    assert kwargs.get("ws_max_size") == 64 * 1024
-    assert kwargs["ws_max_size"] >= ws_sync.MAX_FRAME_BYTES
-
-
-# ── Real-app integration ─────────────────────────────────────────────────────
-
-def test_route_mounted_on_real_server(tmp_path, monkeypatch):
-    monkeypatch.setenv("CONFIG_DIR", str(tmp_path / "config"))
-    monkeypatch.setenv("DLC_DIR", str(tmp_path / "dlc"))
-    monkeypatch.setenv("FEEDBACK_SYNC_STARTUP", "1")
-    sys.modules.pop("server", None)
-    server = importlib.import_module("server")
-    monkeypatch.setattr(server, "load_plugins", lambda *a, **kw: None)
-    monkeypatch.setattr(server, "startup_scan", lambda: None)
-
-    with TestClient(server.app) as client:
-        with client.websocket_connect("/ws/sync/REALAPP") as a, \
-             client.websocket_connect("/ws/sync/REALAPP") as b:
-            a.send_text('{"type":"time","t":0}')
-            assert b.receive_text() == '{"type":"time","t":0}'

tools/content_packs.py

@@ -1,294 +0,0 @@
-#!/usr/bin/env python3
-"""Build & publish opt-in content packs (career venue media, rig VST slices).
-
-Flat-zips a pack directory, sha256s it, and emits the ``{url, sha256, bytes}``
-block that the career and rig_builder download paths consume
-(``plugins/career/routes.py`` ``_download_pack``). Two modes:
-
-  --local <dir>    write zips + a file:// manifest (dev/CI/tests; no network)
-  --publish        create/upload each pack's per-pack release; emit release URLs
-
-The zip is flat (files at the archive root) to satisfy career's zip-slip guard
-(``PACK_FILENAME_RE``) and ``_validate_pack_dir``. This module is the reusable
-core the content-packs CI workflow calls, so building packs is automation —
-never a person's manual job.
-
-Run ``python tools/content_packs.py --selfcheck`` for the built-in round-trip.
-"""
-
-import argparse
-import hashlib
-import json
-import re
-import subprocess
-import sys
-import zipfile
-from pathlib import Path
-
-REPO = "got-feedBack/feedBack"  # where the content-packs release lives (public)
-
-# Must mirror career's download-time whitelist (plugins/career/routes.py
-# PACK_FILENAME_RE). If the builder packs a name the downloader rejects (e.g. a
-# stray .DS_Store), the published pack fails _validate_pack_dir for every client.
-PACK_FILENAME_RE = re.compile(r"^[a-z0-9_-]{1,64}\.(mp4|webm|mp3|json)$")
-
-
-def build_pack(src_dir: Path, out_zip: Path) -> dict:
-    """Flat-zip every file directly under src_dir; return {sha256, bytes}.
-
-    Only regular files at the top level are included (venue packs are flat).
-    Subdirectories are skipped — a nested tree would trip career's zip-slip
-    guard on download anyway.
-
-    The build is REPRODUCIBLE: identical file contents always yield a
-    byte-identical zip (fixed name order, fixed mtime, fixed permissions,
-    ZIP_STORED). So a sha256 computed on any machine matches the zip the CI
-    workflow or another contributor produces — anyone can precompute the
-    manifest values without having to be the one who uploads the asset.
-    """
-    files = sorted((p for p in src_dir.iterdir() if p.is_file()),
-                   key=lambda p: p.name)
-    if not files:
-        raise ValueError(f"no files to pack in {src_dir}")
-    bad = [p.name for p in files if not PACK_FILENAME_RE.fullmatch(p.name)]
-    if bad:
-        raise ValueError(
-            f"{src_dir}: files the downloader will reject: {bad} "
-            f"(allowed: {PACK_FILENAME_RE.pattern})")
-    out_zip.parent.mkdir(parents=True, exist_ok=True)
-    with zipfile.ZipFile(out_zip, "w", zipfile.ZIP_STORED) as zf:
-        # ZIP_STORED: the media (mp4/mp3) and .vst3 binaries are already
-        # compressed; deflating just burns CPU for ~0 gain.
-        for p in files:
-            # Fixed mtime (the zip epoch, 1980-01-01) + fixed perms so the
-            # bytes don't depend on the checkout's file timestamps.
-            info = zipfile.ZipInfo(p.name, date_time=(1980, 1, 1, 0, 0, 0))
-            info.compress_type = zipfile.ZIP_STORED
-            # Pin create_system: ZipInfo defaults it from the host OS (0 on
-            # Windows, 3 on Unix), which would otherwise make the same pack
-            # hash differently across runners. 3 = Unix.
-            info.create_system = 3
-            info.external_attr = 0o644 << 16
-            zf.writestr(info, p.read_bytes())
-    data = out_zip.read_bytes()
-    return {"sha256": hashlib.sha256(data).hexdigest(), "bytes": len(data)}
-
-
-# rig_builder ships "fat" .vst3 bundles carrying all three platforms inside
-# Contents/. A pack for one platform keeps that platform's binary dir + the
-# shared bundle files, and drops the other two.
-VST_PLATFORM_DIRS = {"mac": "MacOS", "win": "x86_64-win", "linux": "x86_64-linux"}
-
-
-def build_vst_pack(vst_root: Path, out_zip: Path, platform: str) -> dict:
-    """Reproducibly zip the VST tree keeping only `platform`'s binaries.
-
-    Slices each fat .vst3: everything is kept except the two foreign platform
-    dirs (MacOS / x86_64-win / x86_64-linux) and the vst/src build trees. Arc
-    names are relative to vst_root so the download endpoint extracts straight
-    into <plugin>/vst/. Same reproducible-build guarantees as build_pack.
-    """
-    if platform not in VST_PLATFORM_DIRS:
-        raise ValueError(f"unknown platform {platform!r} (want mac/win/linux)")
-    foreign = set(VST_PLATFORM_DIRS.values()) - {VST_PLATFORM_DIRS[platform]}
-    files = []
-    for p in sorted(vst_root.rglob("*"), key=lambda q: q.as_posix()):
-        if not p.is_file():
-            continue
-        rel = p.relative_to(vst_root)
-        if rel.parts and rel.parts[0] == "src":      # skip C++/JUCE build trees
-            continue
-        if set(rel.parts) & foreign:                 # drop foreign-platform binaries
-            continue
-        files.append((p, rel))
-    if not files:
-        raise ValueError(f"no VST files to pack for {platform} in {vst_root}")
-    out_zip.parent.mkdir(parents=True, exist_ok=True)
-    with zipfile.ZipFile(out_zip, "w", zipfile.ZIP_STORED) as zf:
-        for p, rel in files:
-            info = zipfile.ZipInfo(rel.as_posix(), date_time=(1980, 1, 1, 0, 0, 0))
-            info.compress_type = zipfile.ZIP_STORED
-            # Pin create_system like build_pack: ZipInfo defaults it from the
-            # host OS (0 on Windows, 3 on Unix), which would otherwise make the
-            # same pack hash differently across runners. VST packs are the most
-            # likely to be built on Windows (native .vst3), so without this pin
-            # the precomputable-hash guarantee breaks exactly where it's needed.
-            info.create_system = 3
-            info.external_attr = 0o644 << 16
-            zf.writestr(info, p.read_bytes())
-    data = out_zip.read_bytes()
-    return {"sha256": hashlib.sha256(data).hexdigest(), "bytes": len(data)}
-
-
-def manifest_entry(out_zip: Path, url: str) -> dict:
-    """Pack info as the download-path expects it: {url, sha256, bytes}."""
-    return {"url": url,
-            "sha256": hashlib.sha256(out_zip.read_bytes()).hexdigest(),
-            "bytes": out_zip.stat().st_size}
-
-
-# Per-pack, versioned, immutable release convention (matches what the team
-# already published, e.g. tag `venue-arena-v1` / asset `arena-pack-v1.zip`).
-def pack_tag(pack_id: str, version: int) -> str:
-    return f"venue-{pack_id}-v{version}"
-
-
-def pack_asset(pack_id: str, version: int) -> str:
-    return f"{pack_id}-pack-v{version}.zip"
-
-
-def pack_url(pack_id: str, version: int, repo: str = REPO) -> str:
-    return (f"https://github.com/{repo}/releases/download/"
-            f"{pack_tag(pack_id, version)}/{pack_asset(pack_id, version)}")
-
-
-# VST packs use the same immutable per-pack convention, keyed by platform:
-# tag `vst-<plat>-v<N>`, asset `vst-<plat>-pack-v<N>.zip`. The manifest they
-# emit is keyed by platform (mac/win/linux) — the shape the rig_builder plugin's
-# data/vst_packs.json consumes.
-def vst_tag(platform: str, version: int) -> str:
-    return f"vst-{platform}-v{version}"
-
-
-def vst_asset(platform: str, version: int) -> str:
-    return f"vst-{platform}-pack-v{version}.zip"
-
-
-def vst_url(platform: str, version: int, repo: str = REPO) -> str:
-    return (f"https://github.com/{repo}/releases/download/"
-            f"{vst_tag(platform, version)}/{vst_asset(platform, version)}")
-
-
-def _publish_release(tag: str, zip_path: Path, title: str, notes: str,
-                     repo: str = REPO) -> None:
-    """Create the per-pack release if missing, then upload the versioned zip.
-
-    Tags are immutable: a media change means a new version (v1 → v2), never a
-    re-upload — so no --clobber. gh errors if the asset already exists, which is
-    the right guard against overwriting a published, referenced pack.
-    """
-    if subprocess.run(["gh", "release", "view", tag, "--repo", repo],
-                      capture_output=True).returncode != 0:
-        subprocess.run(
-            ["gh", "release", "create", tag, "--repo", repo, "--latest=false",
-             "--title", title, "--notes", notes],
-            check=True)
-    subprocess.run(
-        ["gh", "release", "upload", tag, str(zip_path), "--repo", repo], check=True)
-
-
-def publish(pack_id: str, version: int, zip_path: Path, repo: str = REPO) -> None:
-    _publish_release(pack_tag(pack_id, version), zip_path,
-                     f"{pack_id.capitalize()} venue pack v{version}",
-                     "Opt-in career venue pack. Not a code release.", repo)
-
-
-def _pack_id(src_dir: Path) -> str:
-    return src_dir.name
-
-
-def main(argv=None) -> int:
-    ap = argparse.ArgumentParser(description=__doc__)
-    ap.add_argument("src", nargs="*", type=Path,
-                    help="pack source dirs (e.g. plugins/career/venue-packs/club)")
-    ap.add_argument("--version", type=int, default=1,
-                    help="pack version (tag venue-<id>-v<N>); default 1")
-    ap.add_argument("--local", type=Path, metavar="DIR",
-                    help="write zips here + a file:// manifest.json; no upload")
-    ap.add_argument("--publish", action="store_true",
-                    help="create/upload the per-pack release; emit release URLs")
-    ap.add_argument("--vst", action="store_true",
-                    help="slice one rig VST root (src[0]) into per-platform "
-                         "vst-<plat>-v<N> packs; manifest keyed by platform "
-                         "(the shape rig_builder's data/vst_packs.json wants)")
-    ap.add_argument("--manifest", type=Path,
-                    help="write the {id: {url,sha256,bytes}} map here (default: stdout)")
-    ap.add_argument("--selfcheck", action="store_true", help="run the round-trip demo and exit")
-    args = ap.parse_args(argv)
-
-    if args.selfcheck:
-        return _selfcheck()
-    if not args.src or (not args.local and not args.publish):
-        ap.error("need one or more src dirs and either --local or --publish")
-
-    out_dir = args.local if args.local else Path(args.src[0]).parent / "_packs"
-    manifest = {}
-    if args.vst:
-        vst_root = args.src[0]
-        for plat in VST_PLATFORM_DIRS:
-            zip_path = out_dir / vst_asset(plat, args.version)
-            build_vst_pack(vst_root, zip_path, plat)
-            if args.publish:
-                _publish_release(vst_tag(plat, args.version), zip_path,
-                                 f"Rig VST pack ({plat}) v{args.version}",
-                                 "Opt-in per-platform rig VST pack. Not a code release.")
-                url = vst_url(plat, args.version)
-            else:
-                url = (out_dir.resolve() / zip_path.name).as_uri()
-            manifest[plat] = manifest_entry(zip_path, url)
-    else:
-        for src in args.src:
-            pid = _pack_id(src)
-            zip_path = out_dir / pack_asset(pid, args.version)
-            build_pack(src, zip_path)
-            if args.publish:
-                publish(pid, args.version, zip_path)
-                url = pack_url(pid, args.version)
-            else:
-                url = (out_dir.resolve() / zip_path.name).as_uri()
-            manifest[pid] = manifest_entry(zip_path, url)
-
-    out = json.dumps(manifest, indent=2)
-    if args.manifest:
-        args.manifest.write_text(out + "\n", encoding="utf-8")
-    else:
-        print(out)
-    return 0
-
-
-def _selfcheck() -> int:
-    """Build a pack and confirm build_pack/manifest_entry agree on the digest."""
-    import tempfile
-    with tempfile.TemporaryDirectory() as td:
-        td = Path(td)
-        src = td / "bar"
-        src.mkdir()
-        (src / "manifest.json").write_text('{"venue":"bar"}')
-        (src / "bored.mp4").write_bytes(b"\x00fake-video")
-        zip_path = td / pack_asset("bar", 1)
-        info = build_pack(src, zip_path)
-        # Reproducible: a second build (into a different path) is byte-identical.
-        info2 = build_pack(src, td / "again.zip")
-        assert info2["sha256"] == info["sha256"], "build is not reproducible"
-        entry = manifest_entry(zip_path, pack_url("bar", 1))
-        assert entry["sha256"] == info["sha256"], "digest mismatch"
-        assert entry["bytes"] == info["bytes"]
-        assert entry["url"] == (
-            f"https://github.com/{REPO}/releases/download/venue-bar-v1/bar-pack-v1.zip")
-        # Round-trip: the zip must be flat (names == basenames).
-        with zipfile.ZipFile(zip_path) as zf:
-            names = zf.namelist()
-        assert set(names) == {"manifest.json", "bored.mp4"}, names
-
-        # VST slice: keep target platform + shared, drop foreign, reproducible.
-        c = td / "vst" / "Foo.vst3" / "Contents"
-        for d in ("MacOS", "x86_64-win", "x86_64-linux", "Resources"):
-            (c / d).mkdir(parents=True)
-        (c / "MacOS" / "Foo").write_bytes(b"mac")
-        (c / "x86_64-linux" / "Foo.so").write_bytes(b"linux")
-        (c / "Info.plist").write_bytes(b"<plist/>")
-        vzip = td / vst_asset("linux", 1)
-        vinfo = build_vst_pack(td / "vst", vzip, "linux")
-        assert vinfo == build_vst_pack(td / "vst", td / "v2.zip", "linux"), \
-            "vst slice is not reproducible"
-        with zipfile.ZipFile(vzip) as zf:
-            vnames = set(zf.namelist())
-        assert "Foo.vst3/Contents/x86_64-linux/Foo.so" in vnames
-        assert "Foo.vst3/Contents/Info.plist" in vnames
-        assert not any("MacOS" in n for n in vnames), vnames
-    print("content_packs selfcheck: ok")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())