diff --git a/.gitignore b/.gitignore
index 7a60b85..b4bc537 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 __pycache__/
 *.pyc
+node_modules/
diff --git a/.specify/memory/constitution.md b/.specify/memory/constitution.md
index 3ef3d1d..e1ab1d8 100644
--- a/.specify/memory/constitution.md
+++ b/.specify/memory/constitution.md
@@ -3,44 +3,53 @@
 ## Inheritance
 
 feedBack's core plugin contract governs everything in this repo (manifest,
-plugin context: `get_dlc_dir`, `get_sloppak_cache_dir`, asset serving, the
-`slopsmithViz_*` visualization factory contract, splitscreen mounting). This
-constitution lists Tab View's own non-negotiables.
+the `slopsmithViz_*` visualization factory contract, splitscreen mounting).
+This constitution lists Tab View's own non-negotiables.
 
 ## Core Principles
 
 ### I. alphaTab is the renderer; we're the bridge
 Tab View MUST NOT render notation glyphs itself. alphaTab is the source of
 truth for all musical glyphs, beam grouping, stems, and bar layout. Our job
-is to translate arrangement XML → Guitar Pro 5 (`rs2gp.py`) and to drive
-alphaTab's cursor (`tickPosition`) from `audio.currentTime` using beat
-timing data the highway already exposes.
+is to translate the renderer bundle (notes/chords/tuning/stringCount/beats)
+into an alphaTab `Score` (`src/chart-quantize.js` + `src/score-builder.js`)
+and to drive our own boundsLookup-driven marker from `window.highway.getTime()`
+(single-player) or `bundle.currentTime` (splitscreen), using beat timing data
+the highway exposes.
 
 ### II. Multi-instance by construction (slopsmith#36)
 Per-instance state lives in factory closures returned from `createFactory()`.
 Module-level scope is reserved for genuine singletons:
 - The CDN script load promise (one `<script>` per page).
-- `_tvFilename` captured from `window.playSong` and `arrangement:changed`
-  (one global player → one filename, even when multiple panels render
-  different arrangements of the same song).
 - `_nextInstanceId` for unique DOM ids.
 
 ### III. Pin the alphaTab CDN version
-`ALPHATAB_VERSION = '1.8.2'` MUST be an explicit constant. New jsDelivr
-cache invalidations or upstream breaking changes cannot land silently in
+`ALPHATAB_VERSION = '1.8.2'` MUST be an explicit constant, kept in sync with
+package.json's `@coderline/alphatab` devDependency (used to test
+score-builder.js against the real model classes). New jsDelivr cache
+invalidations or upstream breaking changes cannot land silently in
 production. Bumps require local QA against cursor-sync and tab-highlight
 behaviour.
 
-### IV. Path-traversal guard on the GP5 endpoint
-`GET /api/plugins/tabview/gp5/{filename:path}` MUST resolve `filename`
-under the configured DLC dir and reject anything that escapes (`..`, absolute
-paths). The endpoint is publicly mounted; the guard is the single defence.
+### IV. One AlphaTabApi instance per activation
+Tab View MUST NOT destroy and recreate its `AlphaTabApi` instance on every
+chart rebuild — `renderScore()` on a live instance is alphaTab's own
+documented way to switch content; recreating redoes font/layout setup and
+DOM teardown for no reason. The instance is destroyed only in
+`_teardown()`. Each render registers its own `scoreLoaded`/
+`renderFinished`/`error` closures; the previous render's listeners MUST be
+unregistered first via the unregister functions `.on()` returns, or they
+accumulate for the life of the instance.
 
-### V. Sloppak path is loaded lazily
-Older feedBack cores ship without `lib/sloppak.py`. A top-level
-`import sloppak` here would disable Tab View entirely on those installs
-(including for archive songs). The sloppak branch MUST `import sloppak`
-inside the function and surface a `501 Not Implemented` when missing.
+### V. The tab is built from the bundle, not a converted file
+Tab View MUST NOT fetch or convert a separate file server-side.
+`buildScoreFromBundle` (`src/score-builder.js`) builds the alphaTab `Score`
+directly from `bundle.notes`/`.chords`/`.tuning`/`.stringCount`/`.beats` —
+the same bundle passed to any custom renderer's `init`/`draw`. Since
+`highway.js` stages any registered chart-transform provider's output into
+that bundle first, this is also the only path by which a transform reaches
+the tab. This also drops GP5's hard 7-string cap — alphaTab's own model
+has no string-count ceiling.
 
 ### VI. Visualization is opt-in (`matchesArrangement` deliberately absent)
 Tab View does not advertise itself as the auto-select renderer for any
@@ -50,9 +59,13 @@ review.
 
 ## Governance
 
-Amendments touching the GP5 conversion (`rs2gp.py`) must keep a back-compat
-fall-through for older arrangement XML formats. Amendments touching the
-factory contract must align with whatever the latest core
-`slopsmithViz_*` interface requires.
+Amendments touching score construction (`src/score-builder.js`,
+`src/chart-quantize.js`) must keep `test/score-builder.test.mjs` and
+`test/chart-quantize.test.mjs` passing — the former against the real
+`@coderline/alphatab` package, the only verification available without a
+live browser. New alphaTab-independent chart math belongs in
+`chart-quantize.js`, keeping most conversion logic testable without
+alphaTab. Amendments touching the factory contract must align with the
+latest core `slopsmithViz_*` interface.
 
-**Version**: 3.0.0 | **Ratified**: 2026-05-09 | **Last Amended**: 2026-05-09
+**Version**: 4.0.0 | **Ratified**: 2026-05-09 | **Last Amended**: 2026-07-22
diff --git a/README.md b/README.md
index 72839f9..39d15b1 100644
--- a/README.md
+++ b/README.md
@@ -4,13 +4,13 @@ A [feedBack](https://github.com/got-feedback/feedback) plugin that renders custo
 
 ## Features
 
-- Converts arrangement XML to Guitar Pro 5 format on the fly
+- Builds an alphaTab score directly from the renderer bundle (notes, chords, tuning, string count, beats) — no server round trip
 - Renders scrolling tablature notation via alphaTab in the browser
 - Cursor syncs to the existing audio playback
-- Supports guitar and bass arrangements
-- Preserves techniques: bends, slides, hammer-ons, pull-offs, harmonics, palm mutes, tremolo picking
-- Handles custom tunings and capo
+- Supports guitar and bass arrangements, including extended-range instruments (no string-count ceiling)
+- Preserves techniques: bends, slides, hammer-ons, pull-offs, harmonics, palm mutes, tremolo picking, accents
 - Per-measure tempo changes
+- Reflects any active chart-transform provider — since the tab is built from the same bundle every other renderer sees, a provider's remapped notes/strings/tuning show up automatically
 
 ## Installation
 
@@ -33,20 +33,24 @@ Restart feedBack. The plugin loads automatically.
 
 ## Dependencies
 
-- **Server**: `pyguitarpro` (already included in feedBack's requirements)
 - **Client**: alphaTab is loaded from CDN on first use
+- **Dev/test**: `@coderline/alphatab` (npm, pinned to the same version as the CDN load) — used only to test `src/score-builder.js` against the real alphaTab model classes in Node; never shipped to the browser
 
 ## How it works
 
-1. **routes.py** exposes `GET /api/plugins/tabview/gp5/{filename}?arrangement=N`
-2. **rs2gp.py** converts the arrangement (notes, chords, beats, tuning, techniques) into a Guitar Pro 5 file using `pyguitarpro`
-3. **screen.js** loads alphaTab from CDN, fetches the GP5 file, renders it, and syncs the cursor to `audio.currentTime` using the beat timing data from the highway
+1. **screen.js** gathers the current chart bundle (notes/chords/tuning/stringCount/beats/songInfo — the same bundle any custom renderer's `init`/`draw` receives) and passes it to `buildScoreFromBundle`.
+2. **src/chart-quantize.js** does the alphaTab-independent chart math: groups beats into measures, quantizes note onsets to a 32nd-note grid, decomposes gaps into duration/dots pairs, and builds the tuning table.
+3. **src/score-builder.js** builds an `alphaTab.model.Score` from that: constructs the `Track`/`Staff`/`Bar`/`Voice`/`Beat`/`Note` graph and maps techniques (hammer-on/pull-off, slides, bends, harmonics, palm mute, tremolo, accents) onto alphaTab `Note`/`Beat` fields.
+4. **screen.js** hands the built `Score` to `alphaTabApi.renderScore()` (reusing one `AlphaTabApi` instance across rebuilds) and positions its own boundsLookup-driven marker from `window.highway.getTime()` (single-player) or `bundle.currentTime` (splitscreen).
+
+The tab rebuilds whenever `bundle.notes`' identity changes — on a song/arrangement switch, a mastery-slider move, or a chart-transform provider rerunning (a provider always restages a fresh notes array), so the tab always reflects the same effective chart the highway itself is drawing.
 
 ## Files
 
 | File | Purpose |
 |------|---------|
 | `plugin.json` | Plugin manifest |
-| `routes.py` | FastAPI endpoint serving GP5 files |
-| `rs2gp.py` | arrangement → Guitar Pro 5 converter |
 | `screen.js` | Frontend: alphaTab integration, cursor sync, UI |
+| `src/chart-quantize.js` | Pure chart math: measures, quantization, tuning table (no alphaTab dependency) |
+| `src/score-builder.js` | bundle → alphaTab `Score` builder (techniques, track/staff/bar assembly) |
+| `test/` | Node tests for `src/chart-quantize.js` and `src/score-builder.js` (`npm test`) |
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..7aef213
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,22 @@
+{
+  "name": "feedBack-plugin-tabview",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "devDependencies": {
+        "@coderline/alphatab": "1.8.2"
+      }
+    },
+    "node_modules/@coderline/alphatab": {
+      "version": "1.8.2",
+      "resolved": "https://registry.npmjs.org/@coderline/alphatab/-/alphatab-1.8.2.tgz",
+      "integrity": "sha512-Ab11m2IwCdOG+Wbzbv+v4pvJgJnNqw+UjIgKyaTu9TBTWfE7GlOuuElpswkQ2mLB6E4HcOX1FSBopMZdP41B5g==",
+      "dev": true,
+      "license": "MPL-2.0",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    }
+  }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..d51a91e
--- /dev/null
+++ b/package.json
@@ -0,0 +1,10 @@
+{
+  "private": true,
+  "type": "module",
+  "devDependencies": {
+    "@coderline/alphatab": "1.8.2"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  }
+}
diff --git a/plugin.json b/plugin.json
index 8106430..1f3b1b9 100644
--- a/plugin.json
+++ b/plugin.json
@@ -1,11 +1,11 @@
 {
-  "id": "tabview",
-  "name": "Tab View",
-  "version": "3.0.1",
+  "id": "tabview_dev",
+  "name": "Tab View (dev)",
+  "version": "4.0.0",
   "type": "visualization",
   "private": false,
   "script": "screen.js",
-  "routes": "routes.py",
+  "scriptType": "module",
   "category": "practice",
   "description": "Guitar Pro-style tablature view.",
   "icon": "assets/thumb.svg"
diff --git a/requirements.txt b/requirements.txt
deleted file mode 100644
index d35f8c5..0000000
--- a/requirements.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-# Runtime deps beyond what the host app already provides.
-# PyGuitarPro: rs2gp.py builds GP5 files with the `guitarpro` package.
-# Also installed by the org reusable CI so tests importing rs2gp.py work.
-PyGuitarPro>=0.11
diff --git a/routes.py b/routes.py
deleted file mode 100644
index 13a571f..0000000
--- a/routes.py
+++ /dev/null
@@ -1,93 +0,0 @@
-"""Tab View plugin — serves Guitar Pro files converted from arrangements."""
-
-import sys
-import tempfile
-from pathlib import Path
-from fastapi import FastAPI
-from fastapi.responses import Response
-
-# Ensure the song lib is importable
-_lib = str(Path(__file__).resolve().parent.parent.parent / "lib")
-if _lib not in sys.path:
-    sys.path.insert(0, _lib)
-
-# `sloppak` is loaded lazily inside the song-package branch below — older
-# cores ship without lib/sloppak.py, and a top-level import here would
-# disable Tab View entirely on those installs.
-
-# Song-package suffixes: `.feedpak` is the current extension, `.sloppak` the
-# legacy one — same on-disk format either way (mirrors core lib/sloppak.py
-# SONG_EXTS, which can't be imported here without breaking the lazy import).
-PAK_EXTS = (".feedpak", ".sloppak")
-
-
-def setup(app: FastAPI, context: dict):
-    get_dlc_dir = context["get_dlc_dir"]
-    get_sloppak_cache = context.get("get_sloppak_cache_dir")
-
-    from rs2gp import arrangement_to_gp5
-
-    def _song_to_gp5(song, arrangement: int) -> Response:
-        if not song.arrangements:
-            return Response("No arrangements found", status_code=404)
-        idx = max(0, min(arrangement, len(song.arrangements) - 1))
-        gp5_bytes = arrangement_to_gp5(song, idx)
-        return Response(
-            content=gp5_bytes,
-            media_type="application/octet-stream",
-            headers={"Content-Disposition": 'attachment; filename="tab.gp5"'},
-        )
-
-    @app.get("/api/plugins/tabview/gp5/{filename:path}")
-    def tabview_gp5(filename: str, arrangement: int = 0):
-        dlc = get_dlc_dir()
-        if not dlc:
-            return Response("DLC folder not configured", status_code=500)
-
-        song_path = Path(dlc) / filename
-
-        # Path traversal guard: reject any filename that resolves outside dlc.
-        dlc_resolved = Path(dlc).resolve()
-        try:
-            resolved = song_path.resolve()
-        except Exception:
-            return Response("Path resolution failed", status_code=400)
-        if resolved != dlc_resolved and dlc_resolved not in resolved.parents:
-            return Response("Path traversal not allowed", status_code=400)
-
-        if not song_path.exists():
-            return Response("File not found", status_code=404)
-
-        try:
-            # Song package (zip-form *.feedpak / *.sloppak or directory-form
-            # ending in either suffix): use the sloppak loader directly — it
-            # accepts both extensions. Only directories whose name ends with
-            # a package suffix are treated as packages; any other input is
-            # rejected with a clear error below.
-            is_pak = filename.lower().endswith(PAK_EXTS) or (
-                song_path.is_dir() and song_path.name.lower().endswith(PAK_EXTS)
-            )
-            if is_pak:
-                try:
-                    import sloppak as sloppak_mod
-                except ImportError:
-                    return Response(
-                        "Sloppak support requires a newer feedBack core (lib/sloppak.py). "
-                        "Update the host.",
-                        status_code=501,
-                    )
-                raw_cache = get_sloppak_cache() if get_sloppak_cache else None
-                cache = Path(raw_cache) if raw_cache is not None else Path(tempfile.gettempdir()) / "sloppak_cache"
-                cache.mkdir(parents=True, exist_ok=True)
-                loaded = sloppak_mod.load_song(filename, Path(dlc), cache)
-                return _song_to_gp5(loaded.song, arrangement)
-
-            # Any non-package input is unsupported.
-            return Response(
-                "Only .feedpak / .sloppak songs are supported",
-                status_code=400,
-            )
-        except Exception as e:
-            import traceback
-            traceback.print_exc()
-            return Response(f"Conversion error: {e}", status_code=500)
diff --git a/rs2gp.py b/rs2gp.py
deleted file mode 100644
index 94059ba..0000000
--- a/rs2gp.py
+++ /dev/null
@@ -1,533 +0,0 @@
-"""Convert arrangement data to Guitar Pro 5 format."""
-
-import io
-import guitarpro
-from song import arrangement_string_count
-
-TICKS_PER_BEAT = 960
-SUBDIV = 8  # 32nd notes per beat
-
-# Standard open-string MIDI values: GP string 1 (highest) to N (lowest).
-#
-# Guitar: extended to cover 6/7/8-string instruments. Each extra lower string
-# is a perfect fourth (5 semitones) below the previous one in standard tuning.
-#   6-string standard: E4 B3 G3 D3 A2 E2
-#   7-string adds:     B1  (standard low-B 7-string)
-#   8-string adds:     F#1 (standard low-F# 8-string)
-GUITAR_STANDARD = [64, 59, 55, 50, 45, 40, 35, 30]  # E4 B3 G3 D3 A2 E2 B1 F#1
-
-# Bass: keyed by string count because a 6-string bass gains a *high* string
-# (C3) relative to 4/5-string, shifting the whole table upward — not just
-# appending a new low string. 4-string and 5-string share the same high
-# string (G2=43), so they can share a contiguous prefix.
-#   4-string standard: G2 D2 A1 E1
-#   5-string adds low: B0
-#   6-string adds low B0 AND high C3
-BASS_STANDARD = {
-    4: [43, 38, 33, 28],
-    5: [43, 38, 33, 28, 23],
-    6: [48, 43, 38, 33, 28, 23],
-}
-
-
-def arrangement_to_gp5(song, arrangement_index=0):
-    """Convert a Song arrangement to GP5 bytes."""
-    arr = song.arrangements[arrangement_index]
-
-    # path_bass is populated from existing arrangement data and is more reliable than
-    # name-matching alone for official DLC (which can have localised or
-    # abbreviated arrangement names). Name-match is the fallback for custom charts and
-    # sloppaks that don't carry path flags.
-    is_bass = bool(arr.path_bass) or "bass" in arr.name.lower()
-
-    # arrangement_string_count() (song.py) handles the RS XML quirk where
-    # arr.tuning is always length 6 regardless of instrument: it combines the
-    # highest string index seen in notes/chords, a name-based fallback (4 for
-    # bass, 6 for guitar), and len(arr.tuning) when it isn't the RS-XML
-    # padded value of 6 (trustworthy for sloppak/GP-imported sources).
-    num_strings = arrangement_string_count(arr)
-
-    measures_info = _parse_measures(song.beats)
-    if not measures_info:
-        measures_info = [_fallback_measure(song.song_length)]
-
-    events = _merge_events(arr)
-
-    # --- GP3/4/5 hard limit: writeTrack only writes 7 tuning slots, and
-    # writeNotes packs note strings into an 8-bit stringFlags byte via
-    # `1 << (7 - note.string)`, so note.string must be in 1..7. There is no
-    # way to represent an 8-string instrument in this format — pyguitarpro
-    # has no GP6+/.gpx writer that would lift this cap.
-    #
-    # Workaround for 8-string guitar: in practice most 8-string custom charts only
-    # plays 7 distinct strings (the 8th exists in the tuning/instrument
-    # definition but is never actually notated). If that's true for this
-    # arrangement, drop the one *unused* string and shift the remaining 7
-    # into GP strings 1-7 — this preserves every note. If all 8 strings are
-    # genuinely used, fall back to dropping the lowest string (gp_str > 7),
-    # which is the only option GP5 leaves us.
-    #
-    # TODO: the real fix is to stop going through pyguitarpro/GP5 for this
-    # path and feed alphaTab (already used by screen.js for rendering) its
-    # own score format directly, which has no string-count ceiling.
-    remap = None
-    if num_strings == 8:
-        used = _used_string_indices(events)
-        if len(used) <= 7:
-            remaining = sorted(used)
-            remap = {rs: len(remaining) - rank for rank, rs in enumerate(remaining)}
-            num_strings = len(remaining)
-
-    gp = guitarpro.Song()
-    gp.title = song.title or "Untitled"
-    gp.artist = song.artist or ""
-    gp.album = song.album or ""
-    gp.measureHeaders = []
-    gp.tracks = []
-
-    # Set initial tempo from first measure
-    gp.tempo = max(30, min(300, round(measures_info[0]["bpm"])))
-
-    track = guitarpro.Track(gp, number=1)
-    track.name = arr.name or ("Bass" if is_bass else "Guitar")
-    track.channel = guitarpro.MidiChannel(
-        channel=1 if is_bass else 0,
-        effectChannel=3 if is_bass else 2,
-        instrument=33 if is_bass else 30,
-    )
-    track.strings = _make_strings(arr.tuning, is_bass, num_strings, remap)
-    track.indicateTuning = True
-    track.measures = []
-
-    tick = TICKS_PER_BEAT
-    prev_bpm = gp.tempo
-
-    for i, m_info in enumerate(measures_info):
-        header = guitarpro.MeasureHeader(number=i + 1, start=tick)
-        header.timeSignature = guitarpro.TimeSignature()
-        header.timeSignature.numerator = m_info["num_beats"]
-        header.timeSignature.denominator = guitarpro.Duration(value=4)
-        gp.measureHeaders.append(header)
-
-        m_events = [
-            e
-            for e in events
-            if m_info["start_time"] <= e["time"] < m_info["end_time"]
-        ]
-
-        measure = guitarpro.Measure(track, header)
-        voice = measure.voices[0]
-        voice.beats = _create_beats(m_events, m_info, voice, num_strings, remap)
-
-        # Tempo change via MixTableChange on the first beat
-        cur_bpm = max(30, min(300, round(m_info["bpm"])))
-        if i > 0 and cur_bpm != prev_bpm and voice.beats:
-            first_beat = voice.beats[0]
-            first_beat.effect.mixTableChange = guitarpro.MixTableChange(
-                tempo=guitarpro.MixTableItem(value=cur_bpm, duration=1, allTracks=True),
-            )
-        prev_bpm = cur_bpm
-
-        track.measures.append(measure)
-        tick += m_info["num_beats"] * TICKS_PER_BEAT
-
-    gp.tracks = [track]
-
-    buf = io.BytesIO()
-    guitarpro.write(gp, buf)
-    return buf.getvalue()
-
-
-# ---------------------------------------------------------------------------
-# Measure parsing
-# ---------------------------------------------------------------------------
-
-def _parse_measures(beats):
-    """Parse arrangement beats into measure info dicts."""
-    if not beats:
-        return []
-
-    groups = []
-    cur = []
-    for b in beats:
-        if b.measure >= 0 and cur:
-            groups.append(cur)
-            cur = []
-        cur.append(b)
-    if cur:
-        groups.append(cur)
-
-    result = []
-    for i, grp in enumerate(groups):
-        start = grp[0].time
-        if i + 1 < len(groups):
-            end = groups[i + 1][0].time
-        else:
-            if len(grp) > 1:
-                avg = (grp[-1].time - grp[0].time) / (len(grp) - 1)
-                end = grp[-1].time + avg
-            elif result:
-                end = start + (result[-1]["end_time"] - result[-1]["start_time"])
-            else:
-                end = start + 2.0
-
-        n = len(grp)
-        if n > 1:
-            interval = (grp[-1].time - grp[0].time) / (n - 1)
-            bpm = 60.0 / interval if interval > 0 else 120.0
-        elif result:
-            bpm = result[-1]["bpm"]
-        else:
-            bpm = 120.0
-
-        result.append(
-            {
-                "start_time": start,
-                "end_time": end,
-                "num_beats": n,
-                "beat_times": [b.time for b in grp],
-                "bpm": bpm,
-            }
-        )
-    return result
-
-
-def _fallback_measure(length):
-    length = length or 60.0
-    return {
-        "start_time": 0.0,
-        "end_time": length,
-        "num_beats": 4,
-        "beat_times": [i * 0.5 for i in range(8)],
-        "bpm": 120.0,
-    }
-
-
-# ---------------------------------------------------------------------------
-# Event merging
-# ---------------------------------------------------------------------------
-
-_NOTE_FIELDS = [
-    "slide_to",
-    "bend",
-    "hammer_on",
-    "pull_off",
-    "harmonic",
-    "harmonic_pinch",
-    "palm_mute",
-    "mute",
-    "tremolo",
-    "accent",
-    "tap",
-]
-
-
-def _note_dict(n):
-    d = {"string": n.string, "fret": n.fret, "sustain": n.sustain}
-    for f in _NOTE_FIELDS:
-        d[f] = getattr(n, f, False)
-    return d
-
-
-def _merge_events(arr):
-    events = []
-    for n in arr.notes:
-        ev = _note_dict(n)
-        ev["time"] = n.time
-        ev["type"] = "note"
-        events.append(ev)
-
-    for ch in arr.chords:
-        if ch.high_density:
-            continue
-        events.append(
-            {
-                "time": ch.time,
-                "type": "chord",
-                "chord_notes": [_note_dict(cn) for cn in ch.notes],
-            }
-        )
-
-    events.sort(key=lambda e: e["time"])
-    return events
-
-
-def _used_string_indices(events):
-    """Set of RS string indices (0-based) actually played in this arrangement."""
-    used = set()
-    for ev in events:
-        if ev["type"] == "chord":
-            for nd in ev["chord_notes"]:
-                used.add(nd["string"])
-        else:
-            used.add(ev["string"])
-    return used
-
-
-# ---------------------------------------------------------------------------
-# String tuning helpers
-# ---------------------------------------------------------------------------
-
-def _make_strings(tuning, is_bass, num_strings, remap=None):
-    """Build the GP GuitarString list for a track.
-
-    For guitar, GUITAR_STANDARD covers 6–8 strings directly. For bass,
-    BASS_STANDARD is keyed by count because 6-string bass adds a high C
-    string (shifting the whole table up) rather than just appending a low
-    string. Both tables are extended by perfect-fourth extrapolation for
-    any count beyond the defined range, which should only occur for
-    genuinely exotic instruments not currently in the custom-song corpus.
-
-    `remap` (8-string guitar only): dict of {rs_string_index: gp_string_number}
-    covering 7 of the 8 RS strings (one unused string dropped). When present,
-    builds a 7-string GP track using the correct GUITAR_STANDARD entry and
-    tuning offset for each remaining RS string, in its proper gp_str slot.
-    """
-    if is_bass:
-        standard = BASS_STANDARD.get(num_strings)
-        if standard is None:
-            # Nearest defined key, then extend downward by perfect fourths.
-            nearest_key = min(BASS_STANDARD.keys(), key=lambda k: abs(k - num_strings))
-            base = list(BASS_STANDARD[nearest_key])
-            while len(base) < num_strings:
-                base.append(base[-1] - 5)
-            standard = base[:num_strings]
-    else:
-        standard = GUITAR_STANDARD
-
-    if remap is not None:
-        # One slot per remapped RS string. `remap` values are gp string
-        # numbers 1..len(remap) (== num_strings), so a fixed size of 7 would
-        # leave trailing None slots when an 8-string arrangement uses ≤6
-        # distinct strings — pyguitarpro's writeTrack then dereferences
-        # None.value and 500s. Size to the actual number of filled slots.
-        strings = [None] * len(remap)
-        for rs_idx, gp_str in remap.items():
-            gp_idx_8 = 7 - rs_idx  # this RS string's position in the original 8-string table
-            if gp_idx_8 < len(standard):
-                base_midi = standard[gp_idx_8]
-            else:
-                base_midi = standard[-1] - 5 * (gp_idx_8 - len(standard) + 1)
-            midi_val = base_midi + (tuning[rs_idx] if rs_idx < len(tuning) else 0)
-            strings[gp_str - 1] = guitarpro.GuitarString(number=gp_str, value=midi_val)
-        return strings
-
-    # GP3/4/5 can only represent 7 strings; for num_strings==8 without a
-    # remap (all 8 strings genuinely used), gp_str > 7 notes are dropped in
-    # _create_beats, so only build the 7 strings that can be represented.
-    n = min(num_strings, 7)
-    strings = []
-    for gp_idx in range(n):
-        rs_idx = num_strings - 1 - gp_idx
-        if gp_idx < len(standard):
-            base_midi = standard[gp_idx]
-        else:
-            # Extrapolate downward by perfect fourths beyond the table.
-            base_midi = standard[-1] - 5 * (gp_idx - len(standard) + 1)
-        midi_val = base_midi + (tuning[rs_idx] if rs_idx < len(tuning) else 0)
-        strings.append(guitarpro.GuitarString(number=gp_idx + 1, value=midi_val))
-    return strings
-
-
-# ---------------------------------------------------------------------------
-# Beat creation
-# ---------------------------------------------------------------------------
-
-def _quantize_sixteenth(event_time, beat_times, measure_end):
-    """Return the nearest 32nd-note position index within a measure."""
-    best, best_d = 0, float("inf")
-    for i, bt in enumerate(beat_times):
-        nxt = beat_times[i + 1] if i + 1 < len(beat_times) else measure_end
-        dur = nxt - bt
-        for sub in range(SUBDIV):
-            t = bt + dur * sub / SUBDIV
-            d = abs(event_time - t)
-            if d < best_d:
-                best_d = d
-                best = i * SUBDIV + sub
-    return best
-
-
-def _decompose_sixteenths(count):
-    """Break a 32nd-note count into a list of guitarpro.Duration objects."""
-    if count <= 0:
-        return [guitarpro.Duration(value=4)]
-    durs = []
-    rem = count
-    while rem > 0:
-        d = guitarpro.Duration()
-        if rem >= 32:
-            d.value = 1
-            rem -= 32
-        elif rem >= 24:
-            d.value = 2
-            d.isDotted = True
-            rem -= 24
-        elif rem >= 16:
-            d.value = 2
-            rem -= 16
-        elif rem >= 12:
-            d.value = 4
-            d.isDotted = True
-            rem -= 12
-        elif rem >= 8:
-            d.value = 4
-            rem -= 8
-        elif rem >= 6:
-            d.value = 8
-            d.isDotted = True
-            rem -= 6
-        elif rem >= 4:
-            d.value = 8
-            rem -= 4
-        elif rem >= 3:
-            d.value = 16
-            d.isDotted = True
-            rem -= 3
-        elif rem >= 2:
-            d.value = 16
-            rem -= 2
-        else:
-            d.value = 32
-            rem -= 1
-        durs.append(d)
-    return durs
-
-
-def _dur_sixteenths(d):
-    """Number of 32nd notes a Duration occupies."""
-    base = {1: 32, 2: 16, 4: 8, 8: 4, 16: 2, 32: 1}
-    v = base.get(d.value, 8)
-    if d.isDotted:
-        v = int(v * 1.5)
-    return max(v, 1)
-
-
-def _create_beats(events, m_info, voice, num_strings, remap=None):
-    """Build GP Beat list for one measure."""
-    total = m_info["num_beats"] * SUBDIV
-
-    if not events:
-        return _rest_beats(total, voice)
-
-    slots = {}
-    for ev in events:
-        pos = _quantize_sixteenth(ev["time"], m_info["beat_times"], m_info["end_time"])
-        pos = max(0, min(pos, total - 1))
-        slots.setdefault(pos, []).append(ev)
-
-    positions = sorted(slots.keys())
-    beats = []
-    cursor = 0
-
-    for i, pos in enumerate(positions):
-        if pos > cursor:
-            beats.extend(_rest_beats(pos - cursor, voice))
-            cursor = pos
-
-        nxt = positions[i + 1] if i + 1 < len(positions) else total
-        gap = max(1, nxt - pos)
-        durations = _decompose_sixteenths(gap)
-
-        beat = guitarpro.Beat(voice, status=guitarpro.BeatStatus.normal)
-        beat.duration = durations[0]
-
-        seen = set()
-        for ev in slots[pos]:
-            note_dicts = (
-                ev.get("chord_notes", []) if ev["type"] == "chord" else [ev]
-            )
-            for nd in note_dicts:
-                if remap is not None:
-                    gp_str = remap.get(nd["string"])
-                    if gp_str is None:
-                        # this is the one unused 8th string — nothing to drop here
-                        continue
-                else:
-                    gp_str = num_strings - nd["string"]
-                    if gp_str < 1 or gp_str > 7:
-                        continue
-
-                if gp_str in seen:
-                    continue
-                seen.add(gp_str)
-                note = guitarpro.Note(
-                    beat, value=nd["fret"], string=gp_str,
-                    velocity=guitarpro.Velocities.forte,
-                    type=guitarpro.NoteType.normal,
-                )
-                if nd.get("mute"):
-                    note.type = guitarpro.NoteType.dead
-                _apply_effects(note, nd)
-                beat.notes.append(note)
-
-        beats.append(beat)
-        cursor += _dur_sixteenths(durations[0])
-
-        for rd in durations[1:]:
-            beats.extend(_rest_beats(_dur_sixteenths(rd), voice))
-            cursor += _dur_sixteenths(rd)
-
-    if cursor < total:
-        beats.extend(_rest_beats(total - cursor, voice))
-
-    return beats
-
-
-def _rest_beats(sixteenths, voice):
-    beats = []
-    for d in _decompose_sixteenths(sixteenths):
-        b = guitarpro.Beat(voice, status=guitarpro.BeatStatus.rest)
-        b.duration = d
-        beats.append(b)
-    return beats
-
-
-# ---------------------------------------------------------------------------
-# Technique mapping
-# ---------------------------------------------------------------------------
-
-def _apply_effects(gp_note, nd):
-    eff = gp_note.effect
-
-    if nd.get("hammer_on") or nd.get("pull_off"):
-        eff.hammer = True
-
-    slide = nd.get("slide_to", -1)
-    if isinstance(slide, int) and slide >= 0:
-        eff.slides = [guitarpro.SlideType.shiftSlideTo]
-
-    bend_val = nd.get("bend", 0)
-    if bend_val and bend_val > 0:
-        gp_val = int(bend_val * 2)  # RS semitones -> GP quarter-tones
-        eff.bend = guitarpro.BendEffect(
-            type=guitarpro.BendType.bend,
-            value=gp_val,
-            points=[
-                guitarpro.BendPoint(position=0, value=0),
-                guitarpro.BendPoint(position=6, value=gp_val),
-                guitarpro.BendPoint(position=12, value=gp_val),
-            ],
-        )
-
-    if nd.get("harmonic"):
-        eff.harmonic = guitarpro.NaturalHarmonic()
-    elif nd.get("harmonic_pinch"):
-        try:
-            eff.harmonic = guitarpro.PinchHarmonic()
-        except Exception:
-            eff.harmonic = guitarpro.NaturalHarmonic()
-
-    if nd.get("palm_mute"):
-        eff.palmMute = True
-
-    if nd.get("tremolo"):
-        eff.tremoloPicking = guitarpro.TremoloPickingEffect(
-            duration=guitarpro.Duration(value=8),
-        )
-
-    if nd.get("accent"):
-        eff.accentuatedNote = True
-
-    if nd.get("tap"):
-        eff.hammer = True
\ No newline at end of file
diff --git a/screen.js b/screen.js
index a1f8001..dbfa070 100644
--- a/screen.js
+++ b/screen.js
@@ -1,29 +1,25 @@
-// Tab View visualization plugin — renders arrangements as
-// scrolling tablature via alphaTab (https://alphatab.net/).
+// Tab View — renders arrangements as scrolling tablature via alphaTab
+// (https://alphatab.net/), built directly from the renderer bundle
+// (bundle.notes/.chords/.tuning/.stringCount/.beats — see
+// src/chart-quantize.js and src/score-builder.js) instead of a server-
+// converted Guitar Pro file. The bundle is already chart-transform-applied
+// (highway.js stages any registered transform first), so a provider's
+// remap reaches the tab automatically, and alphaTab's model has no GP5-
+// style string-count ceiling.
 //
-// Wave C (slopsmith#36): per-instance refactor. Earlier Wave B
-// landed setRenderer support with an explicit single-instance
-// module-state assumption (one alphaTab API, one container, one
-// cursor highlight, one set of fetch sentinels). Wave C lifts that:
-// every piece of per-render state moves into createFactory closures
-// so N tabview instances coexist under splitscreen panels.
+// Per-instance state lives in createFactory() closures so N tabview
+// instances coexist under splitscreen panels (slopsmith#36). Module scope
+// is reserved for the one genuine singleton: the alphaTab CDN script load.
 //
-// Module-scope retained for genuine singletons:
-//   - alphaTab CDN script load (one <script> tag per tab)
-//   - _tvFilename — captured from window.playSong + arrangement:changed,
-//     applies to the single global player so all instances share it
+// No MIDI input, no focus-driven behavior — each panel renders from its
+// own bundle.currentTime; the splitscreen helper is only consulted for
+// the mount target (panelChromeFor()).
 //
-// Tabview has no MIDI input and no focus-driven behavior — every
-// panel renders independently from its own bundle.currentTime, and
-// the splitscreen helper is consulted only for the mount target via
-// panelChromeFor(). Absence of window.slopsmithSplitscreen OR
-// isActive()===false means "main-player, mount into #player."
-//
-// alphaTab multi-instance: alphaTab loads its font + soundfont as
-// CDN-cached static resources, so N AlphaTabApi instances on the
-// same page share the underlying assets without coordination. Each
-// instance owns its own AlphaTabApi + its own scoreLoaded /
-// renderFinished / error subscriptions.
+// alphaTab's font/soundfont are CDN-cached static assets, so multiple
+// AlphaTabApi instances on one page share them without coordination; each
+// instance owns its own scoreLoaded/renderFinished/error subscriptions.
+
+import { buildScoreFromBundle } from './src/score-builder.js';
 
 (function () {
 'use strict';
@@ -32,36 +28,29 @@
 // Module-level state (singletons)
 // ═══════════════════════════════════════════════════════════════════════
 
-// Captured from playSong wrap + arrangement:changed. All tabview
-// instances see the same filename because slopsmith plays one song
-// per tab — splitscreen panels render different arrangements OF THE
-// SAME song, not different songs. Per-instance arrangement index
-// arrives via bundle.songInfo.arrangement_index.
-let _tvFilename = null;
-
-// Monotonic id for per-instance DOM tagging (containers, alphaTab
-// mount divs, highlight overlays, error banners — every node a
-// tabview instance creates is suffixed with this so N instances
-// don't collide on getElementById.
+// Monotonic id suffixed onto every DOM node a tabview instance creates,
+// so N instances don't collide on getElementById.
 let _nextInstanceId = 0;
 
 // ═══════════════════════════════════════════════════════════════════════
 // alphaTab CDN loader (memoized — one load per page)
 // ═══════════════════════════════════════════════════════════════════════
 
-// Pin alphaTab to a specific release so new jsDelivr cache invalidations
-// or upstream breaking changes can't land silently in production. Bump
-// this when the alphaTab CDN publishes a version tested against the
-// cursor-sync / tab-highlight behavior below.
+// Pin alphaTab to a specific release, kept in sync with package.json's
+// @coderline/alphatab devDependency, so CDN cache/version drift can't
+// land silently. Bump only after QA against cursor-sync/tab-highlight.
 const ALPHATAB_VERSION = '1.8.2';
 const ALPHATAB_CDN_BASE = 'https://cdn.jsdelivr.net/npm/@coderline/alphatab@' + ALPHATAB_VERSION + '/dist';
 
-// Matches rs2gp.py:TICKS_PER_BEAT. The GP5 builder places the first measure
-// at tick TICKS_PER_BEAT (one beat in), hence the baseline offset added in
-// _tvTimeToTick and subtracted back out in _tvSyncCursor before looking the
-// beat up against alphaTab's 0-based absoluteDisplayStart (slopsmith#336).
+// alphaTab's internal MIDI tick resolution (ticks per quarter note) —
+// confirmed fixed at 960 (MidiUtils.QuarterTime). Bar 1 starts at tick 0.
 const TICKS_PER_BEAT = 960;
 
+// Sentinel for "nothing tracked" in the chart-identity state below —
+// distinct from any real bundle.notes value, including null, so a
+// null-notes chart can still be tracked correctly.
+const _NO_NOTES_REF = Symbol('no-notes-ref');
+
 let _alphaTabLoadPromise = null;
 function _tvLoadScript() {
     if (window.alphaTab) return Promise.resolve();
@@ -79,60 +68,13 @@ function _tvLoadScript() {
     return _alphaTabLoadPromise;
 }
 
-// ═══════════════════════════════════════════════════════════════════════
-// Filename tracking (module-level — one global player)
-// ═══════════════════════════════════════════════════════════════════════
-//
-// slopsmith core doesn't expose the current song's filename via a
-// getter (song_info carries metadata, not the WS URL). Capture it
-// ourselves by wrapping window.playSong once at module load and
-// subscribing to arrangement:changed. init() consumes the cached
-// _tvFilename when bundle.songInfo.filename isn't populated.
-
-(function () {
-    // Idempotency: if screen.js is re-evaluated (loader cache miss, hot reload,
-    // older core builds without the load-side guard), don't re-wrap playSong
-    // and don't re-subscribe to arrangement:changed — re-wrap grows the
-    // wrapper chain, and a duplicate listener would update _tvFilename twice
-    // per event.
-    //
-    // Two independent install steps with their own guards: the first eval
-    // may run before window.playSong / window.slopsmith are populated (load
-    // order, hot reload), so a single combined flag would lock out a later
-    // retry from the second eval. Mark the wrapper itself for playSong (per
-    // notedetect/stepmode convention) and a window flag for the listener.
-
-    const origPlay = typeof window.playSong === 'function' ? window.playSong : null;
-    if (origPlay && !origPlay._tabviewWrapped) {
-        const wrapper = async function (filename, arrangement) {
-            _tvFilename = filename;
-            return origPlay.call(this, filename, arrangement);
-        };
-        wrapper._tabviewWrapped = true;
-        window.playSong = wrapper;
-    }
-
-    if (
-        window.slopsmith &&
-        typeof window.slopsmith.on === 'function' &&
-        !window.__slopsmithTabviewArrangementSubscribed
-    ) {
-        window.slopsmith.on('arrangement:changed', (e) => {
-            // detail = { index, filename }
-            if (e && e.detail && e.detail.filename) _tvFilename = e.detail.filename;
-        });
-        window.__slopsmithTabviewArrangementSubscribed = true;
-    }
-})();
-
 // ═══════════════════════════════════════════════════════════════════════
 // Splitscreen helper wrapper
 // ═══════════════════════════════════════════════════════════════════════
 //
-// Tabview only needs panelChromeFor() — there's no MIDI routing or
-// focus-driven behavior. Validate ONLY that surface so a partial
-// helper that lacks the focus-related methods (which tabview doesn't
-// consume) still routes through the splitscreen mount target.
+// Tabview only needs panelChromeFor(); validate just that so a partial
+// helper (missing the focus/MIDI methods tabview doesn't use) still
+// routes through the splitscreen mount target.
 
 function _ssActive() {
     const ss = window.slopsmithSplitscreen;
@@ -147,16 +89,10 @@ function _ssPanelChrome(highwayCanvas) {
 }
 
 // Resolve the DOM mount target for tabview's container / error banner.
-// Splitscreen-active: ONLY the panel chrome is acceptable; if
-// panelChromeFor returns null mid-creation or during a screen
-// transition, return null so callers treat the mount as unavailable
-// (the container won't be cached, and a later draw() / resize() /
-// banner attempt retries cleanly once the panel chrome resolves).
-// Falling through to #player here would (a) cache _tvContainer
-// against the main player surface for the rest of the instance's
-// lifetime, rendering this panel's tabs over the wrong area, and
-// (b) confuse _tvSizeContainer's splitscreen vs main-player branch
-// since _ssActive() would still be true on subsequent calls.
+// Splitscreen-active: ONLY the panel chrome is acceptable. If
+// panelChromeFor() returns null mid-creation, return null so callers
+// retry later instead of caching _tvContainer against the wrong mount
+// (main player) or confusing _tvSizeContainer's branch logic.
 function _resolveMount(highwayCanvas) {
     if (_ssActive()) {
         return _ssPanelChrome(highwayCanvas);
@@ -168,21 +104,29 @@ function _resolveMount(highwayCanvas) {
 // Cursor sync helpers (stateless — beats come from the bundle)
 // ═══════════════════════════════════════════════════════════════════════
 
+// Count of leading elements (arr sorted ascending by keyFn) with
+// keyFn(el) <= target. One less than this is "largest index with
+// keyFn <= target", what both call sites below want (verified against
+// 17k+ randomized cases). Shared here since highway.js's own
+// lowerBoundTime is bundle-scoped, and the single-player cursor loop has
+// no bundle to read it from.
+function _countLE(arr, target, keyFn) {
+    let lo = 0, hi = arr.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (keyFn(arr[mid]) <= target) lo = mid + 1;
+        else hi = mid;
+    }
+    return lo;
+}
+
 function _tvTimeToTick(seconds, beats) {
-    if (!beats || beats.length < 2) return TICKS_PER_BEAT;
-    if (seconds < beats[0].time) return TICKS_PER_BEAT;
+    if (!beats || beats.length < 2) return 0;
+    if (!isFinite(seconds) || seconds < beats[0].time) return 0;
 
     // Largest idx in [0, beats.length-2] with beats[idx].time <= seconds.
-    // Binary search (beats are time-sorted) — identical result to a linear
-    // scan, but O(log n) per frame instead of O(n) (CodeRabbit nitpick: this
-    // is the dominant per-frame sync cost). beats[0].time <= seconds holds
-    // here (guarded above), so idx is always >= 0.
-    let idx = 0, lo = 0, hi = beats.length - 2;
-    while (lo <= hi) {
-        const mid = (lo + hi) >> 1;
-        if (beats[mid].time <= seconds) { idx = mid; lo = mid + 1; }
-        else { hi = mid - 1; }
-    }
+    const count = _countLE(beats, seconds, b => b.time);
+    const idx = Math.min(count - 1, beats.length - 2);
 
     let frac = 0;
     if (idx < beats.length - 1) {
@@ -193,7 +137,7 @@ function _tvTimeToTick(seconds, beats) {
         }
     }
 
-    return TICKS_PER_BEAT + Math.round((idx + frac) * TICKS_PER_BEAT);
+    return Math.round((idx + frac) * TICKS_PER_BEAT);
 }
 
 // ═══════════════════════════════════════════════════════════════════════
@@ -207,7 +151,8 @@ function createFactory() {
     let _isReady = false;
 
     // alphaTab + DOM state (per-instance)
-    let _tvApi = null;
+    let _tvApi = null;           // persists across chart rebuilds — see _tvInitAlphaTab
+    let _tvUnsubscribe = null;   // current render's [off, off, off] from _tvApi's .on() calls
     let _tvContainer = null;
     let _tvAtMount = null;       // inner <div> alphaTab renders into
     let _tvHighlight = null;     // cursor highlight overlay element
@@ -224,82 +169,62 @@ function createFactory() {
     // _tvRemoveContainer() can put it back on teardown.
     let _tvPrevMountPosition = null;
 
-    // Observes #player-controls so the overlay re-insets when the controls
-    // bar wraps to a second row on narrow viewports (slopsmith#336). The
-    // window-resize listener only fires for viewport changes; this catches
-    // content reflow within an unchanged viewport. Main-player mode only —
-    // splitscreen panel chrome owns its own bottom-bar layout.
+    // Re-insets the overlay when #player-controls wraps to a second row
+    // (slopsmith#336) — window-resize alone misses in-viewport content
+    // reflow. Main-player mode only; splitscreen owns its own layout.
     let _tvControlsObserver = null;
 
-    // Fetch / load tracking
-    let _tvCurrentFile = null;   // filename the currently-loaded GP5 was fetched for
-    let _tvCurrentArr = null;    // arrangement_index the current GP5 was fetched for
-    let _tvLoadingFile = null;   // filename a currently-in-flight fetch is targeting
-    let _tvLoadingArr = null;    // arrangement_index that fetch is targeting
-    let _tvFailedFile = null;    // last (filename, arr_index) pair whose fetch failed —
-    let _tvFailedArr = null;     // used by draw() to avoid a per-frame retry storm
+    // Keyed on bundle.notes IDENTITY: highway.js restages a fresh array
+    // whenever the effective chart changes (song load, mastery move,
+    // transform rerun), so a reference change means "rebuild the tab".
+    let _tvCurrentNotesRef = _NO_NOTES_REF;  // notes ref the currently-rendered score reflects
+    let _tvPendingNotesRef = _NO_NOTES_REF;  // notes ref a render is currently in flight for
+    let _tvFailedNotesRef = _NO_NOTES_REF;   // notes ref that last failed (avoid a per-frame retry storm)
 
     // Cursor sync
-    let _tvLastTick = -1;
+    let _tvLastTick = -9999;  // far below any real tick (0 is now a valid position)
 
-    // Self-driven cursor rAF handle (slopsmith#734 follow-up). In
-    // single-player the marker is advanced from our OWN requestAnimationFrame
-    // loop, not the host draw() pump — see _tvCursorLoop for why.
+    // Self-driven cursor rAF handle — single-player advances the marker
+    // from our own loop, not the host draw() pump (see _tvCursorLoop).
     let _tvCursorRAF = null;
 
-    // Marker positioning (slopsmith#734). We render our OWN playback
-    // marker from alphaTab's layout geometry instead of relying on
-    // alphaTab's internal player cursor (.at-cursor-bar). That cursor
-    // only appears once alphaTab's *player* reaches the "ready" state,
-    // which requires the soundfont to download from the CDN — fragile
-    // in the desktop shell (the cursor silently vanished in 0.2.9-beta.2).
-    // We don't use alphaTab's synth at all (slopsmith drives audio), so
-    // the player is disabled and the marker is driven by boundsLookup,
-    // which is available from layout alone (core.includeNoteBounds).
+    // We render our own playback marker from alphaTab's layout geometry
+    // (boundsLookup, via core.includeNoteBounds) instead of alphaTab's
+    // internal player cursor, which only appears once its synth reaches
+    // "ready" — fragile, and unused here since slopsmith drives audio, not
+    // alphaTab's player (slopsmith#734).
     //
-    // _tvAtBeats: flat [{ beat, start }] for every rhythmic beat in the
-    // loaded score, sorted by absoluteDisplayStart (960-ppq MIDI ticks,
-    // bar 0 beat 0 == tick 0). Rebuilt on each scoreLoaded.
-    // _tvLastBeat: the alphaTab Beat the marker currently sits on — kept
-    // so a resize (which re-lays-out and rebuilds boundsLookup) can
-    // re-place the marker without waiting for the next time tick.
+    // _tvAtBeats: flat [{ beat, start }] for every beat, sorted by tick
+    // (960-ppq, bar 0 beat 0 == tick 0). Rebuilt on each scoreLoaded.
+    // _tvLastBeat: the beat the marker sits on, kept so a resize can
+    // re-place it without waiting for the next time tick.
     let _tvAtBeats = [];
     let _tvLastBeat = null;
 
-    // Latest beats snapshot — bundle.beats is the source of truth
-    // under Wave C (the bare `highway` global used in Wave B was the
-    // main-player's highway, not ours under splitscreen).
+    // Latest beats snapshot, per-instance — not the bare `highway` global,
+    // which under splitscreen is the main player's, not this panel's.
     let _tvLatestBeats = null;
 
-    // Monotonic init counter. Each init() bumps it; fetch / alphaTab
-    // callbacks capture the token and bail if a newer init has started
-    // since. Guards against a rapid arrangement switch where a pending
-    // fetch would otherwise install stale GP5 bytes over the new one.
+    // Monotonic init counter. Async continuations (CDN load, alphaTab's
+    // render pipeline) capture it and bail if a newer init/render has
+    // started since, so a rapid switch can't install a stale score.
     let _tvInitToken = 0;
 
     // ── Listener ref (per-instance so destroy() detach matches) ──
     const _onWinResize = () => _tvSizeContainer();
 
-    // Tell the core highway whether its canvas is currently covered by the
-    // tab view. We hide the host canvas with visibility:hidden (so alphaTab
-    // can still measure its width), but visibility:hidden doesn't trip the
-    // highway's offsetParent-based rAF gate — so without this the underlying
-    // renderer (e.g. the 3D Highway WebGL overlay) keeps rendering full-tilt
-    // behind the opaque tab view. setVisible(false) trips the gate (pausing
-    // the host draw) and fires highway:visibility so overlay renderers hide
-    // their sibling DOM; setVisible(null) restores DOM-based detection when
-    // we hand the highway back. Guarded for older cores without the API.
-    // (slopsmith#654)
+    // Tells the host highway whether it's covered by the tab: hiding it
+    // with visibility:hidden alone (so alphaTab can still measure width)
+    // doesn't trip the highway's rAF gate, so the underlying renderer
+    // (e.g. 3D WebGL) keeps rendering behind the opaque tab. setVisible
+    // trips that gate and fires highway:visibility for overlay renderers.
+    // Guarded for older cores without the API (slopsmith#654).
     function _tvSetHighwayVisible(v) {
-        // Splitscreen: window.highway is the *main-player* highway, not a
-        // per-panel instance, and panels expose no per-canvas setVisible
-        // (only panelChromeFor). So only *force-hide* (false) in single-
-        // player mode — where _tvHighwayCanvas IS window.highway's canvas;
-        // forcing it from a panel would pause the wrong renderer and panels
-        // would race the shared gate. Clearing the override (null) is always
-        // safe and idempotent, and MUST run even if splitscreen became
-        // active after a single-player hide, so a prior force-hide can't
-        // strand the global highway paused. (slopsmith#654)
+        // window.highway is the main-player highway, not per-panel, and
+        // panels expose no per-canvas setVisible — so only force-hide
+        // (false) in single-player mode. Clearing (null) is always safe
+        // and must run even if splitscreen activated since a single-player
+        // hide, so a prior force-hide can't strand the highway paused.
         if (v === false && _ssActive()) return;
         try {
             const hw = window.highway;
@@ -314,29 +239,23 @@ function createFactory() {
         const mount = _resolveMount(_tvHighwayCanvas);
         if (!mount) return null;
 
-        // The overlay is positioned with left:0/right:0 to inherit width
-        // from the mount; that requires the mount to be a positioned
-        // ancestor. Existing splitscreen/main-player mounts are; this
-        // is an idempotent guard so a future host with a static mount
-        // doesn't silently collapse our overlay to 0 width. The original
-        // inline position value is saved to _tvPrevMountPosition so
-        // _tvRemoveContainer() can restore it on teardown.
+        // left:0/right:0 needs a positioned mount ancestor; existing mounts
+        // are, this is an idempotent guard for a future static one. The
+        // original inline position is saved so _tvRemoveContainer() can
+        // restore it on teardown.
         if (getComputedStyle(mount).position === 'static') {
             _tvPrevMountPosition = mount.style.position; // save inline value (often '')
             mount.style.position = 'relative';
         }
 
         const c = document.createElement('div');
-        c.id = 'tabview-container-' + _instanceId;
-        c.className = 'tabview-container';
+        c.id = 'tabview-dev-container-' + _instanceId;
+        c.className = 'tabview-dev-container';
         c.dataset.tabviewInstance = String(_instanceId);
-        // visibility:hidden (not display:none) so alphaTab can measure
-        // the container's width during init. With display:none the
-        // element is out of layout and clientWidth is 0, which makes
-        // alphaTab skip the render entirely (warning: "AlphaTab skipped
-        // rendering because of width=0"). renderFinished swaps
-        // visibility to '' once the first paint lands, preserving the
-        // flash-free handoff this layer was originally designed for.
+        // visibility:hidden (not display:none) so alphaTab can still
+        // measure width during init — display:none gives clientWidth=0
+        // and alphaTab skips rendering entirely. renderFinished swaps
+        // this to '' once the first paint lands.
         c.style.cssText = [
             'visibility:hidden',
             'position:absolute',
@@ -349,18 +268,17 @@ function createFactory() {
         ].join(';');
 
         const inner = document.createElement('div');
-        inner.id = 'tabview-at-' + _instanceId;
-        inner.className = 'tabview-at';
+        inner.id = 'tabview-dev-at-' + _instanceId;
+        inner.className = 'tabview-dev-at';
         c.appendChild(inner);
 
-        // Playback marker overlay (slopsmith#734). A Songsterr-style
-        // vertical band: a translucent fill spanning the current beat's
-        // width + staff height, with a bright left border reading as the
-        // playhead at the beat's leading edge. Positioned from boundsLookup
-        // geometry in _tvUpdateMarker — NOT from alphaTab's internal cursor.
+        // Playback marker (slopsmith#734): a Songsterr-style vertical band,
+        // translucent fill over the beat's width/height with a bright
+        // left-border playhead. Positioned from boundsLookup geometry in
+        // _tvUpdateMarker, not alphaTab's own cursor.
         const hl = document.createElement('div');
-        hl.id = 'tabview-marker-' + _instanceId;
-        hl.className = 'tabview-marker';
+        hl.id = 'tabview-dev-marker-' + _instanceId;
+        hl.className = 'tabview-dev-marker';
         hl.style.cssText = [
             'position:absolute',
             'left:0',
@@ -397,14 +315,10 @@ function createFactory() {
         if (!_tvContainer) return;
         const mount = _resolveMount(_tvHighwayCanvas);
         if (!mount) return;
-        // Splitscreen: fill the panel chrome top-to-bottom (the panel bar
-        // layers on top via z-index). Main-player: clear #player-hud at
-        // the top and #player-controls at the bottom (slopsmith#336 —
-        // the previous code reserved the wrong edge, hiding the last
-        // tab row behind the controls bar). Measure dynamically so the
-        // controls' flex-wrap to a second row at narrow widths still
-        // leaves the last row visible. Fallbacks match the historical
-        // 60px top assumption + a single-row controls bar.
+        // Splitscreen fills the panel chrome; main-player insets
+        // #player-hud/#player-controls, measured dynamically so controls
+        // wrapping to a second row (slopsmith#336) still leaves the last
+        // tab row visible. Fallbacks match the historical single-row case.
         let topInset = 0;
         let bottomInset = 0;
         if (!_ssActive()) {
@@ -415,10 +329,9 @@ function createFactory() {
         }
         _tvContainer.style.top = topInset + 'px';
         _tvContainer.style.height = Math.max(0, mount.clientHeight - topInset - bottomInset) + 'px';
-        // After a resize alphaTab re-lays-out and rebuilds boundsLookup,
-        // so the marker's geometry changes even at the same tick. Re-place
-        // it from the last known beat; _tvSyncCursor skips redundant
-        // same-tick updates, so resize has to drive this itself.
+        // A resize rebuilds boundsLookup, changing marker geometry at the
+        // same tick; _tvSyncCursor skips redundant same-tick updates, so
+        // resize has to re-place the marker itself.
         _tvUpdateMarker();
     }
 
@@ -443,21 +356,17 @@ function createFactory() {
 
     // ── Error banner ────────────────────────────────────────────────
     //
-    // When the GP5 fetch or alphaTab render fails, we hide the tabview
-    // container so the 2D highway stays visible. That alone leaves the
-    // failure silent to anyone who can't open devtools. A small,
-    // auto-dismissing banner anchored to this instance's mount surfaces
-    // the error without covering the highway — living OUTSIDE the
-    // tabview container so it coexists with the fallback renderer
-    // instead of occluding it.
+    // A failed build/render hides the tab container so the 2D highway
+    // shows through. This banner surfaces the failure to anyone without
+    // devtools open — outside the container, so it doesn't occlude it.
 
     function _tvShowErrorBanner(message) {
         _tvRemoveErrorBanner();
         const mount = _resolveMount(_tvHighwayCanvas);
         if (!mount) return;
         const banner = document.createElement('div');
-        banner.id = 'tabview-error-banner-' + _instanceId;
-        banner.className = 'tabview-error-banner';
+        banner.id = 'tabview-dev-error-banner-' + _instanceId;
+        banner.className = 'tabview-dev-error-banner';
         banner.dataset.tabviewInstance = String(_instanceId);
         banner.setAttribute('role', 'alert');
         banner.style.cssText = [
@@ -493,224 +402,210 @@ function createFactory() {
         }
     }
 
-    // ── alphaTab init ───────────────────────────────────────────────
+    // ── Failure handling ─────────────────────────────────────────────
+    // Shared by a synchronous score-build failure and an async alphaTab
+    // render error: hide any stale overlay, fall back to the highway.
+    function _tvShowFailure(message) {
+        _tvReady = false;
+        if (_tvContainer) _tvContainer.style.visibility = 'hidden';
+        if (_tvHighwayCanvas) _tvHighwayCanvas.style.visibility = _tvPrevVisibility || '';
+        _tvSetHighwayVisible(null);
+        console.warn('[TabView dev] ' + message);
+        _tvShowErrorBanner(message);
+    }
 
-    async function _tvInitAlphaTab(arrayBuffer, myToken) {
-        const c = _tvCreateContainer();
-        if (!c) return;
+    // Detaches the current render's listeners from the persistent _tvApi —
+    // called before a new render's listeners, on failure, and on teardown,
+    // so none are ever left dangling on the live api.
+    function _tvUnsubscribeAll() {
+        if (!_tvUnsubscribe) return;
+        for (const off of _tvUnsubscribe) { try { off(); } catch (_) {} }
+        _tvUnsubscribe = null;
+    }
 
-        // Destroy previous API before re-init so scoreLoaded / error
-        // handlers from the old lifetime don't fire into stale DOM.
-        if (_tvApi) {
-            try { _tvApi.destroy(); } catch (_) {}
-            _tvApi = null;
+    // ── alphaTab init / render ───────────────────────────────────────
+
+    // Caller must have already confirmed _tvContainer exists.
+    //
+    // _tvApi persists across chart rebuilds (only destroyed in
+    // _teardown()) — renderScore() on a live instance is alphaTab's own
+    // documented way to switch content. Each render still registers its
+    // own scoreLoaded/renderFinished/error closures (they capture this
+    // call's notesRef/myToken), so the previous render's listeners are
+    // unregistered first.
+    //
+    // We don't clear _tvAtMount's DOM ourselves before re-rendering:
+    // alphaTab creates its own canvas once and each render pass removes
+    // its own stale child elements (verified against the pinned source).
+    // Clearing it here would desync that bookkeeping instead.
+    function _tvInitAlphaTab(score, notesRef, myToken) {
+        if (!_tvApi) {
+            _tvApi = new alphaTab.AlphaTabApi(_tvAtMount, {
+                core: {
+                    fontDirectory: ALPHATAB_CDN_BASE + '/font/',
+                    // Builds boundsLookup during layout, mapping beat ->
+                    // pixel geometry for our own marker (slopsmith#734).
+                    includeNoteBounds: true,
+                },
+                display: {
+                    layoutMode: alphaTab.LayoutMode.Page,
+                    scale: 0.9,
+                },
+                player: {
+                    // No alphaTab synth: slopsmith owns audio. Disabling it
+                    // skips the soundfont download and the player-ready
+                    // dependency the old cursor relied on (slopsmith#734).
+                    enablePlayer: false,
+                },
+            });
         }
+
+        _tvUnsubscribeAll();
         _tvReady = false;
         _tvAtBeats = [];
         _tvLastBeat = null;
-        if (_tvAtMount) _tvAtMount.innerHTML = '';
-
-        _tvApi = new alphaTab.AlphaTabApi(_tvAtMount, {
-            core: {
-                fontDirectory: ALPHATAB_CDN_BASE + '/font/',
-                // Build the bounds lookup during layout so we can map a
-                // beat → rendered pixel geometry for our own marker
-                // (slopsmith#734). Without this api.boundsLookup is null.
-                includeNoteBounds: true,
-            },
-            display: {
-                layoutMode: alphaTab.LayoutMode.Page,
-                scale: 0.9,
-            },
-            player: {
-                // No alphaTab synth: slopsmith owns audio. Disabling the
-                // player drops the soundfont CDN download entirely and,
-                // crucially, removes the player-ready dependency that the
-                // old .at-cursor-bar marker relied on (slopsmith#734).
-                enablePlayer: false,
-            },
-        });
-
-        // On load, flatten the score into a tick-sorted beat timeline so
-        // _tvSyncCursor can resolve the current playback tick → Beat →
-        // boundsLookup geometry. Single track (rs2gp emits one).
-        _tvApi.scoreLoaded.on(function (score) {
+        // Set once renderFinished fires for this generation — distinguishes
+        // a fresh chart (reset scroll, below) from a same-chart resize
+        // re-layout (must NOT reset it).
+        let isFirstRenderForThisGeneration = true;
+
+        // Flattens into a tick-sorted beat timeline so _tvSyncCursor can
+        // resolve tick -> Beat -> boundsLookup geometry.
+        const offScoreLoaded = _tvApi.scoreLoaded.on(function (loadedScore) {
             if (_tvInitToken !== myToken) return;
-            _tvAtBeats = _tvBuildBeatTimeline(score);
+            _tvAtBeats = _tvBuildBeatTimeline(loadedScore);
             _tvLastBeat = null;
         });
 
-        _tvApi.renderFinished.on(function () {
+        const offRenderFinished = _tvApi.renderFinished.on(function () {
             if (_tvInitToken !== myToken) return;
             _tvReady = true;
-            // Start the self-driven cursor loop here (not in init()): _tvReady
-            // is only true once the score has rendered, so starting earlier
-            // just idle-spins for the whole async GP5 fetch. Idempotent, so
-            // the resize-driven re-fires of renderFinished are harmless.
+            // Started here, not init(): _tvReady only becomes true once
+            // rendered, so starting earlier idle-spins through the render.
             _tvStartCursorLoop();
-            // Swap visibility only once alphaTab has actually produced
-            // output. _tvApi.load() kicks off rendering synchronously
-            // but the first frame lands several rAFs later; if we hid
-            // the highway in _tvFetchAndInit right after load() returned
-            // (the previous behaviour) the player flashed blank for
-            // the duration of the render, or stayed blank forever if
-            // renderFinished never fired. Doing it here guarantees a
-            // painted-to-painted handoff and lets the error path below
-            // fall back to the still-visible 2D highway.
+            // Swap visibility only once alphaTab has actual output — the
+            // first frame lands several rAFs later, or never on failure.
             if (_tvContainer) _tvContainer.style.visibility = '';
             if (_tvHighwayCanvas) _tvHighwayCanvas.style.visibility = 'hidden';
             _tvSetHighwayVisible(false);
-            _tvFailedFile = null;
-            _tvFailedArr = null;
-            // A successful render supersedes any prior error banner.
+            if (isFirstRenderForThisGeneration) {
+                isFirstRenderForThisGeneration = false;
+                // Reset scroll now, after the new chart replaces the old
+                // (any earlier would visibly snap the still-displayed old
+                // chart) — so a shorter arrangement doesn't stay scrolled
+                // past its content until playback catches up.
+                if (_tvContainer) { _tvContainer.scrollTop = 0; _tvContainer.scrollLeft = 0; }
+            }
+            _tvCurrentNotesRef = notesRef;
+            _tvPendingNotesRef = _NO_NOTES_REF;
+            _tvFailedNotesRef = _NO_NOTES_REF;
             _tvRemoveErrorBanner();
-            // renderFinished fires after EVERY (re)layout, including a
-            // resize-driven re-render. boundsLookup is freshly valid at
-            // this point, so re-place the marker from the last known beat:
-            // a width-change resize transiently nulls boundsLookup, and
-            // _tvSizeContainer's _tvUpdateMarker() call mid-relayout hides
-            // the marker — without this it would stay hidden while paused
-            // (or until _tvSyncCursor's tick advances >30) (slopsmith#734).
-            // No-op on the first render (_tvLastBeat is null → marker hidden).
+            // renderFinished also fires on a resize re-layout, where
+            // boundsLookup is freshly valid — re-place the marker so it
+            // doesn't stay hidden after a resize while paused
+            // (slopsmith#734). No-op on the first render.
             _tvUpdateMarker();
         });
 
-        _tvApi.error.on(function (e) {
+        const offError = _tvApi.error.on(function (e) {
             if (_tvInitToken !== myToken) return;
-            console.error('[TabView] alphaTab error:', e);
-            // Render or parse error after GP5 fetch succeeded: tabview
-            // can't display anything for this target. Mark it failed so
-            // draw()'s change-detection doesn't re-fetch on every rAF,
-            // hide our (possibly empty) overlay, and restore highway
-            // visibility so the player isn't stranded blank. Use
-            // _tvCurrentFile/Arr if set (post-fetch) else fall back to
-            // the in-flight _tvLoadingFile/Arr so we always remember
-            // what went wrong.
-            const failedFile = _tvCurrentFile || _tvLoadingFile;
-            const failedArr = _tvCurrentArr != null ? _tvCurrentArr : _tvLoadingArr;
-            _tvReady = false;
-            _tvCurrentFile = null;
-            _tvCurrentArr = null;
-            if (failedFile != null) {
-                _tvFailedFile = failedFile;
-                _tvFailedArr = failedArr;
-            }
-            if (_tvContainer) _tvContainer.style.visibility = 'hidden';
-            if (_tvHighwayCanvas) _tvHighwayCanvas.style.visibility = _tvPrevVisibility || '';
-            _tvSetHighwayVisible(null);
+            console.error('[TabView dev] alphaTab error:', e);
+            // This generation has failed — detach its listeners now rather
+            // than leaving them until a later render happens to clean up.
+            _tvUnsubscribeAll();
+            _tvPendingNotesRef = _NO_NOTES_REF;
+            _tvFailedNotesRef = notesRef;
             const msg = (e && e.message) ? e.message : (typeof e === 'string' ? e : 'render failed');
-            _tvShowErrorBanner(msg);
+            _tvShowFailure(msg);
         });
 
-        _tvApi.load(new Uint8Array(arrayBuffer));
-    }
+        _tvUnsubscribe = [offScoreLoaded, offRenderFinished, offError];
 
-    async function _tvFetchAndInit(filename, arrIdx, myToken) {
-        if (!filename) {
-            console.warn('[TabView] no filename known yet; skipping fetch');
-            return;
-        }
-        // Mount-availability guard. In splitscreen the panel chrome
-        // can be null transiently (panel mid-creation, screen
-        // transitions) — _resolveMount returns null in that case.
-        // Bail BEFORE setting _tvLoading* / hitting the network so
-        // draw()'s change-detect doesn't treat us as in-flight, and
-        // so we don't spam the GP5 endpoint with fetches that would
-        // immediately discard their results because _tvCreateContainer
-        // returns null too. The next draw() retries cleanly once the
-        // panel chrome resolves; load state stays "needs fetch" via
-        // _tvCurrentFile/_tvCurrentArr remaining unset.
-        if (!_resolveMount(_tvHighwayCanvas)) {
-            return;
+        try {
+            score.finish(_tvApi.settings);
+            _tvApi.renderScore(score, [0]);
+        } catch (e) {
+            // _tvUnsubscribe unambiguously refers to the 3 listeners just
+            // registered — safe to detach here (unlike the caller's catch,
+            // reachable without this function running). Re-throw so
+            // failure bookkeeping happens once, in the caller.
+            _tvUnsubscribeAll();
+            throw e;
         }
-        _tvLoadingFile = filename;
-        _tvLoadingArr = arrIdx;
+    }
+
+    // Builds the score from `bundle` and renders it. Awaits the CDN script
+    // load first: buildScoreFromBundle and _tvInitAlphaTab both need
+    // window.alphaTab, and _tvLoadScript is the only place that requests it.
+    async function _tvRenderFromBundle(bundle, myToken) {
+        if (!bundle) return;
+        if (!_resolveMount(_tvHighwayCanvas)) return;
+
+        // One snapshot for the whole attempt — draw()'s dirty-check and
+        // every ref below must agree on the same value, so a
+        // falsy-but-not-null bundle.notes can't desync the guards.
+        const notesRef = bundle.notes || null;
+
+        // Marked in flight for the WHOLE attempt, before the CDN-load
+        // await — otherwise every draw() frame during a cold network wait
+        // re-invokes this, stacking redundant attempts.
+        _tvPendingNotesRef = notesRef;
+
         try {
             await _tvLoadScript();
             if (_tvInitToken !== myToken) return;
 
-            // Decode first — filename may already be URI-encoded from
-            // the data-play attribute — then re-encode for the request
-            // path. decodeURIComponent throws URIError on stray % or
-            // bare `%xx` where xx isn't valid hex; fall back to the raw
-            // filename so a rare encoding edge case doesn't land in the
-            // (_tvFailedFile, _tvFailedArr) cache and permanently block
-            // retries for that song / arrangement.
-            let decoded = filename;
-            try {
-                decoded = decodeURIComponent(filename);
-            } catch (e) {
-                console.warn('[TabView] decodeURIComponent failed; using raw filename:', filename, e);
+            const score = buildScoreFromBundle(window.alphaTab && window.alphaTab.model, bundle);
+            if (!score) {
+                _tvPendingNotesRef = _NO_NOTES_REF;
+                _tvFailedNotesRef = notesRef;
+                return;
             }
-            const url = '/api/plugins/tabview/gp5/' + encodeURIComponent(decoded) +
-                '?arrangement=' + arrIdx;
-            const resp = await fetch(url);
-            if (_tvInitToken !== myToken) return;
-            if (!resp.ok) throw new Error(await resp.text());
-            const data = await resp.arrayBuffer();
-            if (_tvInitToken !== myToken) return;
 
-            // _tvCreateContainer returns null when the mount target
-            // isn't in the DOM (player screen closed, unusual timing
-            // during screen transitions). Without this guard the next
-            // line's _tvContainer.style.visibility = '' would throw on
-            // null and the failure path below would cache this as a
-            // permanent failure for the song, even though the real
-            // issue is transient DOM state.
+            // null mount target (player closed, transition timing) — clear
+            // pending so the next draw() retries cleanly.
             const container = _tvCreateContainer();
             if (!container) {
-                console.warn('[TabView] mount container missing; leaving highway visible');
+                _tvPendingNotesRef = _NO_NOTES_REF;
+                console.warn('[TabView dev] mount container missing; leaving highway visible');
                 if (_tvHighwayCanvas) _tvHighwayCanvas.style.visibility = _tvPrevVisibility || '';
                 _tvSetHighwayVisible(null);
                 return;
             }
             _tvSizeContainer();
-            await _tvInitAlphaTab(data, myToken);
 
-            if (_tvInitToken !== myToken) return;
-            _tvCurrentFile = filename;
-            _tvCurrentArr = arrIdx;
-            // DO NOT show the container or hide the highway here:
-            // _tvApi.load() inside _tvInitAlphaTab kicks off rendering
-            // but resolves before the first frame is painted, so doing
-            // the visibility swap at this point would flash the player
-            // blank during the render setup (or forever if render never
-            // completes). The renderFinished handler inside
-            // _tvInitAlphaTab takes over: on success it swaps in the
-            // overlay, on error it keeps the highway visible.
+            // Stays in flight until renderFinished/error resolves it (async
+            // from here). Don't swap visibility here — that happens in
+            // those handlers so the player isn't stranded blank mid-render.
+            _tvInitAlphaTab(score, notesRef, myToken);
+
+            // Watchdog: a width=0 mount makes alphaTab skip rendering without
+            // ever firing renderFinished/error, leaving _tvPendingNotesRef
+            // stuck. No-op once this attempt resolves normally.
+            setTimeout(() => {
+                if (_tvInitToken !== myToken) return;
+                if (_tvPendingNotesRef !== notesRef) return;
+                _tvPendingNotesRef = _NO_NOTES_REF;
+            }, 6000);
         } catch (e) {
             if (_tvInitToken !== myToken) return;
-            console.error('[TabView] GP5 fetch/init failed:', e);
-            _tvFailedFile = filename;
-            _tvFailedArr = arrIdx;
-            // Hide any stale tab overlay (either a prior successful load
-            // that's being reloaded into a failing song, or the freshly
-            // created empty container from an initial failed load) so
-            // the highway fallback actually becomes visible.
-            if (_tvContainer) _tvContainer.style.visibility = 'hidden';
-            if (_tvHighwayCanvas) _tvHighwayCanvas.style.visibility = _tvPrevVisibility || '';
-            _tvSetHighwayVisible(null);
-            const msg = (e && e.message) ? e.message : String(e);
-            console.warn('[TabView] ' + msg);
-            _tvShowErrorBanner(msg);
-        } finally {
-            // Only clear the loading-target if this fetch is still the
-            // latest in-flight one — a newer token bump already cleared /
-            // re-set these fields for a subsequent fetch.
-            if (_tvInitToken === myToken) {
-                _tvLoadingFile = null;
-                _tvLoadingArr = null;
-            }
+            console.error('[TabView dev] render failed:', e);
+            // Don't _tvUnsubscribeAll() here: if this threw before
+            // _tvInitAlphaTab ran, _tvUnsubscribe still belongs to a
+            // different, live generation — detaching would drop its
+            // listeners. _tvInitAlphaTab owns its own cleanup on a
+            // finish()/renderScore() failure.
+            _tvPendingNotesRef = _NO_NOTES_REF;
+            _tvFailedNotesRef = notesRef;
+            _tvShowFailure((e && e.message) ? e.message : String(e));
         }
     }
 
     // ── Beat timeline (tick → Beat) ─────────────────────────────────
 
-    // Flatten the loaded score into a tick-sorted [{ beat, start }] list.
-    // `start` is absoluteDisplayStart in 960-ppq MIDI ticks (bar 0 beat 0
-    // == tick 0). One track only (rs2gp emits a single guitar/bass track);
-    // voice 0 carries the notes. Returns [] on any unexpected shape so the
-    // marker simply stays hidden rather than throwing on the rAF path.
+    // Flattens into a tick-sorted [{ beat, start }] list (960-ppq MIDI
+    // ticks, bar 0 beat 0 == tick 0). Single track/voice 0. Returns [] on
+    // any unexpected shape so the marker just stays hidden.
     function _tvBuildBeatTimeline(score) {
         const out = [];
         try {
@@ -742,12 +637,7 @@ function createFactory() {
         const arr = _tvAtBeats;
         if (!arr || arr.length === 0) return null;
         if (tick < arr[0].start) return arr[0].beat;
-        let lo = 0, hi = arr.length - 1, ans = 0;
-        while (lo <= hi) {
-            const mid = (lo + hi) >> 1;
-            if (arr[mid].start <= tick) { ans = mid; lo = mid + 1; }
-            else { hi = mid - 1; }
-        }
+        const ans = _countLE(arr, tick, b => b.start) - 1;
         return arr[ans].beat;
     }
 
@@ -757,46 +647,31 @@ function createFactory() {
         if (!_tvApi || !_tvReady) return;
 
         const tick = _tvTimeToTick(currentTime, _tvLatestBeats);
-        // Skip the (relatively expensive) beat lookup + marker reposition
-        // when the tick hasn't advanced — at 60fps × N splitscreen
-        // instances that's meaningful cost for state that doesn't change
-        // between frames. Resize-driven movement still re-places the
-        // marker via _onWinResize → _tvSizeContainer → _tvUpdateMarker.
+        // Skips the (relatively expensive) lookup+reposition when the tick
+        // hasn't advanced — meaningful at 60fps x N splitscreen instances.
+        // Resize still re-places the marker via _onWinResize.
         if (Math.abs(tick - _tvLastTick) <= 30) return;
         _tvLastTick = tick;
-        // _tvTimeToTick adds a one-beat baseline because rs2gp starts the
-        // first measure at tick TICKS_PER_BEAT; alphaTab's
-        // absoluteDisplayStart is 0-based, so subtract it back out before
-        // looking the beat up. Floor at 0 for the very first beat.
-        const lookupTick = Math.max(0, tick - TICKS_PER_BEAT);
-        _tvLastBeat = _tvFindBeatAtTick(lookupTick);
+        _tvLastBeat = _tvFindBeatAtTick(tick);
         _tvUpdateMarker();
     }
 
     // ── Self-driven cursor loop (slopsmith#734 follow-up) ────────────
     //
-    // Single-player Tab View hides the highway via setVisible(false) so the
-    // occluded underlying renderer stops burning GPU behind the opaque tab
-    // (slopsmith#654). But that same flag gates the host's per-frame draw
-    // pump (`highway.js`: `if (!_lastVisible) return` *before* it calls the
-    // active renderer's draw(bundle)) — and we ARE the active renderer. So
-    // our draw(bundle) stopped being called the instant the first render
-    // finished, and the boundsLookup marker silently froze / never appeared.
+    // setVisible(false) (slopsmith#654) also gates the host's draw() pump,
+    // so once we're the active renderer, our own draw(bundle) stops being
+    // called after the first render and the marker would freeze. We
+    // advance it from our own rAF loop instead, reading clock+beats
+    // straight off window.highway.
     //
-    // Fix: advance the marker from our own requestAnimationFrame loop,
-    // reading the clock + beats straight off window.highway, so the cursor
-    // no longer depends on whether the host pumps draw().
+    // Time source is getTime() (audio-aligned chartTime), NOT
+    // bundle.currentTime (chartTime + avOffset — non-zero on stem songs,
+    // which drags the marker onto the previous note).
     //
-    // Time source is getTime() (chartTime — the AUDIO-aligned clock), NOT
-    // bundle.currentTime. bundle.currentTime is the *render* clock
-    // (chartTime + avOffset); on stem songs avOffset is non-zero (e.g.
-    // −215 ms), which dragged the marker onto the previous note. getTime()
-    // is exactly the audio position, so the marker sits on the note you hear.
-    //
-    // Splitscreen still rides the per-panel draw(bundle) path: setVisible
-    // (false) is skipped there (so draw() keeps flowing), and window.highway
-    // is the *main* player's instance — wrong clock/beats for a panel — so
-    // the loop bows out when _ssActive().
+    // Splitscreen rides the per-panel draw(bundle) path instead:
+    // setVisible is skipped there, and window.highway is the main
+    // player's (wrong clock/beats for a panel), so this loop bows out
+    // under _ssActive().
     function _tvCursorLoop() {
         _tvCursorRAF = window.requestAnimationFrame(_tvCursorLoop);
         if (!_isReady || !_tvReady) return;
@@ -808,9 +683,8 @@ function createFactory() {
             if (b) _tvLatestBeats = b;
         }
         // getTime() can return NaN in transient states (pre-anchor boot,
-        // mid-seek flush — see highway.js). Feeding NaN to _tvSyncCursor
-        // resolves to lookupTick 0 and snaps the marker back to beat 0, so
-        // skip the frame instead.
+        // mid-seek flush — see highway.js); skip the frame rather than
+        // snapping the marker to beat 0.
         const t = hw.getTime();
         if (t == null || !isFinite(t)) return;
         _tvSyncCursor(t);
@@ -834,20 +708,15 @@ function createFactory() {
         if (!_tvHighlight || !_tvContainer || !_tvAtMount) return;
         if (!_tvLastBeat) { _tvHighlight.style.display = 'none'; return; }
 
-        // boundsLookup is rebuilt on every (re)layout; it can be briefly
-        // null between a resize and the next renderFinished. Bail quietly.
+        // Can be briefly null between a resize and the next renderFinished.
         const bl = _tvApi && _tvApi.boundsLookup;
         const bb = bl ? bl.findBeat(_tvLastBeat) : null;
         const vb = bb && bb.visualBounds;
         if (!vb) { _tvHighlight.style.display = 'none'; return; }
 
-        // visualBounds are in the rendered surface's coordinate space,
-        // whose origin is _tvAtMount's content box. Both the marker and
-        // _tvAtMount are absolutely positioned children of the scrolling
-        // _tvContainer, so they share its scrolled space — add _tvAtMount's
-        // offset, no scroll math needed. The translucent band spans the
-        // beat's width; the bright left border (static CSS) reads as the
-        // playhead at the beat's leading edge.
+        // visualBounds share _tvAtMount's coordinate space; both it and the
+        // marker are absolutely positioned inside the scrolling
+        // _tvContainer, so adding _tvAtMount's offset needs no scroll math.
         const baseX = _tvAtMount.offsetLeft;
         const baseY = _tvAtMount.offsetTop;
 
@@ -898,16 +767,16 @@ function createFactory() {
     function _teardown(restoreCanvas) {
         _tvStopCursorLoop();
         _tvReady = false;
-        _tvLastTick = -1;
-        _tvCurrentFile = null;
-        _tvCurrentArr = null;
-        _tvLoadingFile = null;
-        _tvLoadingArr = null;
-        _tvFailedFile = null;
-        _tvFailedArr = null;
+        _tvLastTick = -9999;
+        _tvCurrentNotesRef = _NO_NOTES_REF;
+        _tvPendingNotesRef = _NO_NOTES_REF;
+        _tvFailedNotesRef = _NO_NOTES_REF;
         _tvLatestBeats = null;
         _tvAtBeats = [];
         _tvLastBeat = null;
+        // Detach before destroying the api — don't rely on destroy() to
+        // also clear its own event emitters' subscriber lists.
+        _tvUnsubscribeAll();
         if (_tvApi) {
             try { _tvApi.destroy(); } catch (_) {}
             _tvApi = null;
@@ -926,120 +795,80 @@ function createFactory() {
 
     return {
         init(canvas, bundle) {
-            // Always run teardown at init start, even when there's
-            // no visible container/API to tear down. A previous
-            // activation that failed BEFORE alphaTab initialised
-            // (e.g. CDN load error, fetch error pre-container) would
-            // otherwise leak _tvFailedFile / _tvFailedArr into this
-            // lifetime — the new fetch would hit the previouslyFailed
-            // guard in draw() and silently skip, so re-picking Tab
-            // View would appear to do nothing.
+            // Token bumps BEFORE teardown, not after: _teardown() destroys
+            // _tvApi, and if that synchronously re-fires a still-attached
+            // listener, its staleness guard must already see a mismatched
+            // token.
+            const myToken = ++_tvInitToken;
+
+            // Always tears down, even with nothing visible: a previous
+            // activation that failed before alphaTab initialized would
+            // otherwise leak _tvFailedNotesRef into this lifetime, hitting
+            // draw()'s previouslyFailed guard and silently doing nothing.
             //
-            // restoreCanvas=true (not false) is critical here: a
-            // prior successful render hid the highway canvas via
-            // renderFinished, and skipping the restore would leave
-            // the canvas at visibility:hidden when the new init
-            // captures _tvPrevVisibility below — so a subsequent
-            // failed fetch / destroy would "restore" the canvas to
-            // hidden and strand the player blank. The
-            // _tvHighwayCanvas reference is also nulled by the
-            // restore branch, freeing the new init() to install
-            // the freshly-passed canvas without aliasing.
+            // restoreCanvas=true is required: a prior successful render
+            // hid the highway canvas, so skipping the restore would
+            // capture _tvPrevVisibility as "hidden" below, stranding the
+            // player blank on a later failure.
             _teardown(/* restoreCanvas */ true);
             window.removeEventListener('resize', _onWinResize);
 
-            const myToken = ++_tvInitToken;
             _tvHighwayCanvas = canvas;
             _tvPrevVisibility = canvas ? canvas.style.visibility : '';
 
-            // DON'T hide the 2D highway yet — if GP5 fetch, CDN load,
-            // or alphaTab init fails (missing filename, server down,
-            // network error), we want the default visible as a
-            // fallback so the player isn't stranded blank. The hide
-            // happens inside renderFinished on success, and a failed
-            // fetch restores _tvPrevVisibility explicitly.
+            // Don't hide the highway yet — if the build/render fails we
+            // want it still visible as a fallback. renderFinished hides
+            // it on success; a failure restores _tvPrevVisibility.
 
-            _tvLastTick = -1;
             window.addEventListener('resize', _onWinResize);
 
-            const songInfo = (bundle && bundle.songInfo) || {};
-            const filename = (typeof songInfo.filename === 'string' && songInfo.filename)
-                || _tvFilename;
-            const arrIdx = Number.isInteger(songInfo.arrangement_index)
-                ? songInfo.arrangement_index : 0;
-            _tvFetchAndInit(filename, arrIdx, myToken);
+            _tvRenderFromBundle(bundle, myToken);
 
             _isReady = true;
-            // The self-driven cursor loop (the marker can't rely on the host
-            // draw() pump once the highway is hidden — slopsmith#654 gate) is
-            // started from renderFinished, once _tvReady is true, so it
-            // doesn't idle-spin through the async GP5 fetch.
+            // Started from renderFinished (once _tvReady is true), not
+            // here, so it doesn't idle-spin through the async render.
         },
         draw(bundle) {
             if (!_isReady || !bundle) return;
 
-            // Cache beats per frame so cursor sync uses the
-            // filter-aware beats from THIS instance's bundle, not
-            // the main-player's `highway` global (which under
-            // splitscreen belongs to the hidden default highway and
-            // wouldn't reflect this panel's arrangement).
+            // Per-instance, not the main-player `highway` global, which
+            // under splitscreen belongs to the hidden default highway.
             _tvLatestBeats = bundle.beats || null;
 
-            // Detect arrangement / song change: re-fetch GP5 when the
-            // active (filename, arrangement_index) differs from the
-            // one the currently-displayed score was loaded for. Guard
-            // against per-frame retry loops — while a fetch is in
-            // flight for the same target, skip. draw() runs every rAF
-            // and a typical fetch takes well over one frame; without
-            // this check we'd spam the endpoint and keep bumping the
-            // init token, invalidating each request before it lands.
-            //
-            // Prefer bundle.songInfo.filename when present and fall
-            // back to the _tvFilename cache from our playSong wrap.
-            // slopsmith core doesn't expose filename in song_info
-            // today, but routing through bundle first means we pick
-            // it up automatically when/if core adds it, and it
-            // eliminates the small race where _tvFilename lags
-            // bundle.songInfo during a rapid song switch.
-            const songInfo = bundle.songInfo || {};
-            const filename = (typeof songInfo.filename === 'string' && songInfo.filename)
-                || _tvFilename;
-            const arrIdx = Number.isInteger(songInfo.arrangement_index)
-                ? songInfo.arrangement_index : 0;
-            const chartChanged = filename &&
-                (filename !== _tvCurrentFile || arrIdx !== _tvCurrentArr);
-            const loadInFlight = _tvLoadingFile !== null &&
-                _tvLoadingFile === filename && _tvLoadingArr === arrIdx;
-            const previouslyFailed = _tvFailedFile === filename &&
-                _tvFailedArr === arrIdx;
-            if (chartChanged && !loadInFlight && !previouslyFailed) {
-                // Defense-in-depth mount check. _tvFetchAndInit also
-                // guards (and is the single source of truth), but
-                // doing the check here too saves a per-frame
-                // _tvInitToken bump while the panel chrome is
-                // transient-null; tokens are cheap but the bump+bail
-                // pattern is dead work.
+            // Rebuilds whenever bundle.notes' identity differs — covers a
+            // song switch and a chart-transform provider rerunning, since
+            // highway.js restages a fresh array either way. Guarded
+            // against retry storms: skip while in flight or previously
+            // failed for this exact ref.
+            const notesRef = bundle.notes || null;
+            const chartChanged = notesRef !== _tvCurrentNotesRef;
+            const buildInFlight = _tvPendingNotesRef === notesRef;
+            const previouslyFailed = _tvFailedNotesRef === notesRef;
+            if (chartChanged && !buildInFlight && !previouslyFailed) {
+                // Defense-in-depth: _tvRenderFromBundle also checks this,
+                // but avoids a wasted token bump while the mount is
+                // transiently null.
                 if (_resolveMount(_tvHighwayCanvas)) {
                     const myToken = ++_tvInitToken;
-                    _tvLastTick = -1;
-                    _tvFetchAndInit(filename, arrIdx, myToken);
+                    _tvLastTick = -9999;
+                    _tvRenderFromBundle(bundle, myToken);
                     // fall through — cursor sync below will be a no-op
-                    // until _tvReady flips true again after the re-init.
+                    // until _tvReady flips true again after the re-render.
                 }
             }
 
-            // Splitscreen only. In single-player the rAF loop
-            // (_tvCursorLoop) owns the marker, driven from the
-            // audio-aligned highway.getTime(). Letting draw() ALSO drive
-            // it would double-sync from a second clock: bundle.currentTime
-            // is the render clock (chartTime + avOffset), so on a core
-            // where the host pump isn't gated off (no highway.setVisible,
-            // or the one transition frame before the highway hides) the
-            // marker would flip a beat back and forth every frame between
-            // audio time and render time. The loop bows out under
-            // _ssActive(), so the two paths stay mutually exclusive.
+            // Splitscreen only — single-player's _tvCursorLoop owns the
+            // marker from the audio-aligned clock. Letting draw() ALSO
+            // drive it would double-sync from bundle.currentTime (render
+            // clock), flipping the marker each frame when the host pump
+            // isn't gated off. The loop bows out under _ssActive(),
+            // keeping the two mutually exclusive.
             if (_ssActive()) {
-                _tvSyncCursor(bundle.currentTime);
+                // Same NaN guard as _tvCursorLoop: a NaN currentTime would
+                // pin _tvLastTick to NaN, permanently breaking the "skip
+                // redundant frame" check above.
+                const t = bundle.currentTime;
+                if (t != null && isFinite(t)) _tvSyncCursor(t);
             }
         },
         resize(/* w, h */) {
@@ -1048,7 +877,7 @@ function createFactory() {
         },
         destroy() {
             _isReady = false;
-            _tvInitToken++;  // invalidate in-flight fetches
+            _tvInitToken++;  // invalidate in-flight builds/renders
             window.removeEventListener('resize', _onWinResize);
             _teardown(/* restoreCanvas */ true);
         },
@@ -1058,8 +887,8 @@ function createFactory() {
 // Arrangement-agnostic — Auto mode should not auto-select tabview.
 // (The static matchesArrangement is intentionally absent.)
 
-window.slopsmithViz_tabview = createFactory;
+window.slopsmithViz_tabview_dev = createFactory;
 // slopsmith→feedBack rename: host viz picker looks up `window.feedBackViz_<id>`.
-window.feedBackViz_tabview = window.slopsmithViz_tabview;
+window.feedBackViz_tabview_dev = window.slopsmithViz_tabview_dev;
 
 })();
diff --git a/src/chart-quantize.js b/src/chart-quantize.js
new file mode 100644
index 0000000..58c446e
--- /dev/null
+++ b/src/chart-quantize.js
@@ -0,0 +1,177 @@
+// Pure chart math for score-builder.js: grouping beats into measures,
+// merging notes/chords into a time-sorted event list, quantizing note
+// onsets to a 32nd-note grid, decomposing a 32nd-note count into
+// alphaTab Duration/dots pairs, and building a tuning table. No alphaTab
+// dependency — see test/chart-quantize.test.mjs.
+
+export const SUBDIV = 8; // 32nd-note slots per beat
+
+// GP string 1 (highest) to N (lowest); index0 = highest pitch, matching
+// alphaTab's Tuning.tunings convention (staff.stringTuning: "the first
+// item is the most top tablature line").
+const GUITAR_STANDARD = [64, 59, 55, 50, 45, 40, 35, 30];
+const BASS_STANDARD = {
+    4: [43, 38, 33, 28],
+    5: [43, 38, 33, 28, 23],
+    6: [48, 43, 38, 33, 28, 23],
+};
+
+// ── Measure / tempo parsing ─────────────────────────────────────────────
+
+export function parseMeasures(beats) {
+    if (!beats || !beats.length) return [];
+    const groups = [];
+    let cur = [];
+    for (const b of beats) {
+        if (typeof b.measure === 'number' && b.measure >= 0 && cur.length) { groups.push(cur); cur = []; }
+        cur.push(b);
+    }
+    if (cur.length) groups.push(cur);
+
+    const result = [];
+    for (let i = 0; i < groups.length; i++) {
+        const grp = groups[i];
+        const start = grp[0].time;
+        let end;
+        if (i + 1 < groups.length) {
+            end = groups[i + 1][0].time;
+        } else if (grp.length > 1) {
+            const avg = (grp[grp.length - 1].time - grp[0].time) / (grp.length - 1);
+            end = grp[grp.length - 1].time + avg;
+        } else if (result.length) {
+            const prev = result[result.length - 1];
+            end = start + (prev.endTime - prev.startTime);
+        } else {
+            end = start + 2.0;
+        }
+
+        const n = grp.length;
+        let bpm;
+        if (n > 1) {
+            const interval = (grp[n - 1].time - grp[0].time) / (n - 1);
+            bpm = interval > 0 ? 60.0 / interval : 120.0;
+        } else if (result.length) {
+            bpm = result[result.length - 1].bpm;
+        } else {
+            bpm = 120.0;
+        }
+
+        result.push({ startTime: start, endTime: end, numBeats: n, beatTimes: grp.map(b => b.time), bpm });
+    }
+    return result;
+}
+
+export function fallbackMeasure(length) {
+    // Falls back to a default span for any non-positive/invalid length.
+    // `length || 60.0` isn't equivalent: it also lets a negative length
+    // through (only 0/NaN/null/undefined are falsy), producing a measure
+    // that ends before it starts.
+    const len = (typeof length === 'number' && length > 0) ? length : 60.0;
+    const numBeats = 4;
+    return {
+        startTime: 0.0,
+        endTime: len,
+        numBeats,
+        // One entry per numBeats, evenly spanning the measure —
+        // quantizeThirtySecond treats the last entry's next boundary as
+        // endTime, so a length mismatch here left late slots unreachable.
+        beatTimes: Array.from({ length: numBeats }, (_, i) => (len * i) / numBeats),
+        bpm: 120.0,
+    };
+}
+
+// ── Event merging (notes/chords are already wire-shaped: t/s/f/sus/sl/... ) ──
+
+export function mergeEvents(notes, chords) {
+    const events = [];
+    for (const n of (notes || [])) {
+        events.push({ time: n.t, type: 'note', note: n });
+    }
+    for (const ch of (chords || [])) {
+        if (ch.hd) continue; // high-density chords are a rendering aid, not real notation
+        events.push({ time: ch.t, type: 'chord', chordNotes: ch.notes || [] });
+    }
+    events.sort((a, b) => a.time - b.time);
+    return events;
+}
+
+// ── Rhythm quantization (32nd-note grid) ────────────────────────────────
+
+export function quantizeThirtySecond(eventTime, beatTimes, measureEnd) {
+    let best = 0, bestDist = Infinity;
+    for (let i = 0; i < beatTimes.length; i++) {
+        const bt = beatTimes[i];
+        const next = i + 1 < beatTimes.length ? beatTimes[i + 1] : measureEnd;
+        const dur = next - bt;
+        for (let sub = 0; sub < SUBDIV; sub++) {
+            const t = bt + (dur * sub) / SUBDIV;
+            const d = Math.abs(eventTime - t);
+            if (d < bestDist) { bestDist = d; best = i * SUBDIV + sub; }
+        }
+    }
+    return best;
+}
+
+// {duration, dots} pairs using alphaTab's own Duration enum values
+// (1=whole, 2=half, 4=quarter, 8=eighth, 16, 32 — same numeric convention
+// GP5 uses, so these values need no translation at the call site).
+export function decomposeThirtySeconds(count) {
+    if (count <= 0) return [{ duration: 4, dots: 0 }];
+    const durs = [];
+    let rem = count;
+    while (rem > 0) {
+        let duration, dots = 0;
+        if (rem >= 32) { duration = 1; rem -= 32; }
+        else if (rem >= 24) { duration = 2; dots = 1; rem -= 24; }
+        else if (rem >= 16) { duration = 2; rem -= 16; }
+        else if (rem >= 12) { duration = 4; dots = 1; rem -= 12; }
+        else if (rem >= 8) { duration = 4; rem -= 8; }
+        else if (rem >= 6) { duration = 8; dots = 1; rem -= 6; }
+        else if (rem >= 4) { duration = 8; rem -= 4; }
+        else if (rem >= 3) { duration = 16; dots = 1; rem -= 3; }
+        else if (rem >= 2) { duration = 16; rem -= 2; }
+        else { duration = 32; rem -= 1; }
+        durs.push({ duration, dots });
+    }
+    return durs;
+}
+
+const BASE_THIRTY_SECONDS = { 1: 32, 2: 16, 4: 8, 8: 4, 16: 2, 32: 1 };
+
+export function thirtySecondsForDuration(part) {
+    let v = BASE_THIRTY_SECONDS[part.duration] ?? 8;
+    if (part.dots) v = Math.trunc(v * 1.5);
+    return Math.max(v, 1);
+}
+
+// ── Tuning table ─────────────────────────────────────────────────────────
+
+// tuningOffsets: per-RS-string semitone offsets from standard (index 0 =
+// lowest string, same convention as songInfo.tuning). Returns tunings[]
+// ordered index0 = highest pitch, matching alphaTab's Tuning.tunings.
+export function buildTuning(tuningOffsets, isBass, stringCount) {
+    let standard;
+    if (isBass) {
+        standard = BASS_STANDARD[stringCount];
+        if (!standard) {
+            const keys = Object.keys(BASS_STANDARD).map(Number);
+            const nearest = keys.reduce((a, b) => (Math.abs(b - stringCount) < Math.abs(a - stringCount) ? b : a));
+            const base = BASS_STANDARD[nearest].slice();
+            while (base.length < stringCount) base.push(base[base.length - 1] - 5);
+            standard = base.slice(0, stringCount);
+        }
+    } else {
+        standard = GUITAR_STANDARD;
+    }
+    const tunings = [];
+    for (let gpIdx = 0; gpIdx < stringCount; gpIdx++) {
+        const rsIdx = stringCount - 1 - gpIdx;
+        const baseMidi = gpIdx < standard.length
+            ? standard[gpIdx]
+            : standard[standard.length - 1] - 5 * (gpIdx - standard.length + 1);
+        const raw = rsIdx < tuningOffsets.length ? tuningOffsets[rsIdx] : 0;
+        const offset = Number.isFinite(raw) ? raw : 0;
+        tunings.push(baseMidi + offset);
+    }
+    return tunings;
+}
diff --git a/src/score-builder.js b/src/score-builder.js
new file mode 100644
index 0000000..24934ec
--- /dev/null
+++ b/src/score-builder.js
@@ -0,0 +1,220 @@
+// Builds an alphaTab Score directly from the highway's chart bundle
+// (notes/chords/tuning/stringCount/beats/songInfo), in place of the old
+// GP5-via-pyguitarpro round trip. The bundle is already chart-transform-
+// applied, so any registered provider's remap reaches the tab, and
+// alphaTab's model has no GP5-style string-count ceiling.
+//
+// Rhythm/tuning math lives in chart-quantize.js (no alphaTab dependency,
+// see test/chart-quantize.test.mjs); this file is the alphaTab
+// object-construction half (see test/score-builder.test.mjs).
+
+import {
+    SUBDIV, parseMeasures, fallbackMeasure, mergeEvents,
+    decomposeThirtySeconds, thirtySecondsForDuration, quantizeThirtySecond,
+    buildTuning,
+} from './chart-quantize.js';
+
+// RS bend is semitones; alphaTab BendPoint.value is quarter-tones (same
+// *2 scale GP5 used). A 3-point curve (flat -> full bend held) mirrors the
+// old GP5 output's shape.
+function applyNoteEffects(note, wire, atModel) {
+    if (wire.ho || wire.po) note.isHammerPullOrigin = true;
+    if (Number.isInteger(wire.sl) && wire.sl >= 0) note.slideOutType = atModel.SlideOutType.Shift;
+    const bendVal = wire.bn;
+    if (bendVal && bendVal > 0) {
+        const quarterTones = bendVal * 2;
+        note.bendType = atModel.BendType.Bend;
+        // addBendPoint (not a direct bendPoints assignment) so it also
+        // updates maxBendPoint, which alphaTab's own bend rendering reads.
+        note.addBendPoint(new atModel.BendPoint(0, 0));
+        note.addBendPoint(new atModel.BendPoint(30, quarterTones));
+        note.addBendPoint(new atModel.BendPoint(60, quarterTones));
+    }
+    if (wire.hm) note.harmonicType = atModel.HarmonicType.Natural;
+    else if (wire.hp) note.harmonicType = atModel.HarmonicType.Pinch;
+    if (wire.pm) note.isPalmMute = true;
+    if (wire.mt) note.isDead = true;
+    if (wire.ac) note.accentuated = atModel.AccentuationType.Normal;
+    if (wire.tp) note.isLeftHandTapped = true;
+}
+
+function restBeat(atModel, part) {
+    const b = new atModel.Beat();
+    b.duration = part.duration;
+    b.dots = part.dots;
+    return b;
+}
+
+function restBeats(atModel, thirtySeconds) {
+    return decomposeThirtySeconds(thirtySeconds).map(part => restBeat(atModel, part));
+}
+
+// Continuation beats for a split duration (e.g. a 17-slot gap) must keep
+// ringing, not go silent — ties each note back to the origin instead of
+// replaying one-shot attack effects. No origins -> a rest, like restBeat.
+function tieContinuationBeat(atModel, origins, part) {
+    const b = new atModel.Beat();
+    b.duration = part.duration;
+    b.dots = part.dots;
+    for (const origin of origins) {
+        const note = new atModel.Note();
+        note.string = origin.string;
+        note.fret = origin.fret;
+        note.isTieDestination = true;
+        if (origin.isPalmMute) note.isPalmMute = true;
+        if (origin.isDead) note.isDead = true;
+        b.addNote(note);
+    }
+    return b;
+}
+
+// One measure's events -> alphaTab Beat[] (rests filling gaps, one Note
+// per sounded string per slot — mirrors the old GP5 path's one-note-per-
+// string-per-beat limit). wire.s/wire.f are validated (integer, in-range):
+// a chart-transform provider is less trusted than the original chart
+// file, and an invalid string would otherwise index past staff.tuning
+// and land on NaN pitch instead of being dropped.
+function createBeats(atModel, events, measureInfo, stringCount) {
+    const total = measureInfo.numBeats * SUBDIV;
+    if (!events.length) return restBeats(atModel, total);
+
+    const slots = new Map();
+    for (const ev of events) {
+        let pos = quantizeThirtySecond(ev.time, measureInfo.beatTimes, measureInfo.endTime);
+        pos = Math.max(0, Math.min(pos, total - 1));
+        if (!slots.has(pos)) slots.set(pos, []);
+        slots.get(pos).push(ev);
+    }
+    const positions = [...slots.keys()].sort((a, b) => a - b);
+
+    const beats = [];
+    let cursor = 0;
+    for (let i = 0; i < positions.length; i++) {
+        const pos = positions[i];
+        if (pos > cursor) {
+            beats.push(...restBeats(atModel, pos - cursor));
+            cursor = pos;
+        }
+        const next = i + 1 < positions.length ? positions[i + 1] : total;
+        const gap = Math.max(1, next - pos);
+        const decomposed = decomposeThirtySeconds(gap);
+
+        const beat = new atModel.Beat();
+        beat.duration = decomposed[0].duration;
+        beat.dots = decomposed[0].dots;
+
+        // Beat.tremoloPicking is per-beat, not per-note, so a mixed chord
+        // (one tremolo string among plain ones) can't be represented
+        // exactly. Require EVERY sounded note to request it: dropping a
+        // lone flag is a smaller error than marking strings that didn't.
+        let tremoloCount = 0;
+        const seen = new Set();
+        const soundedNotes = [];
+        for (const ev of slots.get(pos)) {
+            const wireNotes = ev.type === 'chord' ? ev.chordNotes : [ev.note];
+            for (const wire of wireNotes) {
+                if (!Number.isInteger(wire.s) || wire.s < 0 || wire.s >= stringCount) continue;
+                if (!Number.isInteger(wire.f) || wire.f < 0) continue;
+                if (seen.has(wire.s)) continue;
+                seen.add(wire.s);
+                const note = new atModel.Note();
+                // RS string index 0 = lowest; alphaTab Note.string 1 = lowest.
+                note.string = wire.s + 1;
+                note.fret = wire.f;
+                applyNoteEffects(note, wire, atModel);
+                if (wire.tr) tremoloCount++;
+                beat.addNote(note);
+                soundedNotes.push(note);
+            }
+        }
+        if (soundedNotes.length > 0 && tremoloCount === soundedNotes.length) {
+            const t = new atModel.TremoloPickingEffect();
+            t.marks = 1;
+            t.style = atModel.TremoloPickingStyle.Default;
+            beat.tremoloPicking = t;
+        }
+
+        beats.push(beat);
+        cursor += thirtySecondsForDuration(decomposed[0]);
+        for (let j = 1; j < decomposed.length; j++) {
+            beats.push(tieContinuationBeat(atModel, soundedNotes, decomposed[j]));
+            cursor += thirtySecondsForDuration(decomposed[j]);
+        }
+    }
+    if (cursor < total) beats.push(...restBeats(atModel, total - cursor));
+    return beats;
+}
+
+// ── Main entry point ─────────────────────────────────────────────────────
+
+// atModel: the `alphaTab.model` namespace (from the loaded alphaTab CDN
+// bundle). bundle: a highway/renderer bundle (notes/chords/tuning/
+// stringCount/beats/songInfo) — the same one passed to a custom
+// renderer's init(canvas, bundle)/draw(bundle).
+export function buildScoreFromBundle(atModel, bundle) {
+    if (!bundle) return null;
+    const { Score, Track, Staff, Bar, Voice, MasterBar, Tuning, Automation } = atModel;
+
+    const songInfo = bundle.songInfo || {};
+    const stringCount = Number.isFinite(bundle.stringCount) && bundle.stringCount >= 1
+        ? Math.trunc(bundle.stringCount) : 6;
+    const tuningOffsets = Array.isArray(bundle.tuning) && bundle.tuning.length
+        ? bundle.tuning : new Array(stringCount).fill(0);
+    // Word-boundary match (not a bare substring) so e.g. "BasslineKeys"
+    // doesn't misclassify as bass. No more-authoritative signal is
+    // available: bundle.songInfo carries only the arrangement's display
+    // name, not an instrument-type flag (that only existed server-side).
+    const isBass = /\bbass\b/i.test(songInfo.arrangement || '');
+
+    let measures = parseMeasures(bundle.beats);
+    if (!measures.length) measures = [fallbackMeasure(songInfo.duration)];
+    const events = mergeEvents(bundle.notes, bundle.chords);
+
+    const score = new Score();
+    score.title = songInfo.title || '';
+    score.artist = songInfo.artist || '';
+
+    const track = new Track();
+    track.name = songInfo.arrangement || (isBass ? 'Bass' : 'Guitar');
+    score.addTrack(track);
+    track.playbackInfo.primaryChannel = isBass ? 1 : 0;
+    track.playbackInfo.secondaryChannel = isBass ? 3 : 2;
+    track.playbackInfo.program = isBass ? 33 : 30;
+
+    const staff = new Staff();
+    staff.stringTuning = new Tuning('', buildTuning(tuningOffsets, isBass, stringCount));
+    track.addStaff(staff);
+
+    // events/measures are both time-sorted and contiguous, so a single
+    // forward pointer partitions events measure-by-measure in O(n+m)
+    // instead of rescanning per measure.
+    let eventIdx = 0;
+    while (eventIdx < events.length && measures.length && events[eventIdx].time < measures[0].startTime) eventIdx++;
+
+    let prevBpm = null;
+    for (const info of measures) {
+        const masterBar = new MasterBar();
+        masterBar.timeSignatureNumerator = info.numBeats;
+        masterBar.timeSignatureDenominator = 4;
+        const bpm = Math.max(30, Math.min(300, Math.round(info.bpm)));
+        if (prevBpm === null || bpm !== prevBpm) {
+            masterBar.tempoAutomations = [Automation.buildTempoAutomation(false, 0, bpm, bpm)];
+        }
+        prevBpm = bpm;
+        score.addMasterBar(masterBar);
+
+        const bar = new Bar();
+        staff.addBar(bar);
+        const voice = new Voice();
+        bar.addVoice(voice);
+
+        const measureEvents = [];
+        while (eventIdx < events.length && events[eventIdx].time < info.endTime) {
+            measureEvents.push(events[eventIdx]);
+            eventIdx++;
+        }
+        for (const beat of createBeats(atModel, measureEvents, info, stringCount)) voice.addBeat(beat);
+    }
+
+    return score;
+}
diff --git a/test/chart-quantize.test.mjs b/test/chart-quantize.test.mjs
new file mode 100644
index 0000000..e6b9fe2
--- /dev/null
+++ b/test/chart-quantize.test.mjs
@@ -0,0 +1,176 @@
+// src/chart-quantize.js: measure/tempo parsing, event merging, 32nd-note
+// quantization, duration decomposition, tuning tables. No alphaTab
+// dependency — see score-builder.test.mjs for the parts that need
+// real alphaTab model classes.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+    parseMeasures, fallbackMeasure, mergeEvents,
+    quantizeThirtySecond, decomposeThirtySeconds, thirtySecondsForDuration,
+    buildTuning,
+} from '../src/chart-quantize.js';
+
+test('parseMeasures: empty input', () => {
+    assert.deepEqual(parseMeasures([]), []);
+    assert.deepEqual(parseMeasures(null), []);
+});
+
+test('parseMeasures: groups by measure marker', () => {
+    const beats = [
+        { time: 0.0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 },
+        { time: 2.0, measure: 1 }, { time: 2.5 }, { time: 3.0 }, { time: 3.5 },
+    ];
+    const measures = parseMeasures(beats);
+    assert.equal(measures.length, 2);
+    assert.equal(measures[0].numBeats, 4);
+    assert.equal(measures[0].startTime, 0.0);
+    assert.equal(measures[0].endTime, 2.0);
+    assert.equal(measures[1].startTime, 2.0);
+});
+
+test('parseMeasures: a null measure field does not start a new group', () => {
+    // null >= 0 is true in JS, so an unguarded check would wrongly treat a
+    // beat with measure:null as a measure boundary.
+    const beats = [
+        { time: 0.0, measure: 0 }, { time: 0.5, measure: null }, { time: 1.0 }, { time: 1.5 },
+    ];
+    const measures = parseMeasures(beats);
+    assert.equal(measures.length, 1);
+    assert.equal(measures[0].numBeats, 4);
+});
+
+test('parseMeasures: estimates bpm from beat interval', () => {
+    const beats = [{ time: 0.0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 }];
+    const measures = parseMeasures(beats);
+    assert.ok(Math.abs(measures[0].bpm - 120.0) < 0.01);
+});
+
+test('parseMeasures: last measure extrapolates end time', () => {
+    const beats = [{ time: 0.0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 }];
+    const measures = parseMeasures(beats);
+    assert.equal(measures[measures.length - 1].endTime, 2.0);
+});
+
+test('parseMeasures: single-beat final measure reuses prior interval', () => {
+    const beats = [
+        { time: 0.0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 },
+        { time: 2.0, measure: 1 },
+    ];
+    const measures = parseMeasures(beats);
+    assert.equal(measures[1].numBeats, 1);
+    assert.equal(measures[1].endTime, 2.0 + (measures[0].endTime - measures[0].startTime));
+    assert.equal(measures[1].bpm, measures[0].bpm);
+});
+
+test('fallbackMeasure: defaults and custom length', () => {
+    const m = fallbackMeasure(null);
+    assert.equal(m.endTime, 60.0);
+    assert.equal(m.numBeats, 4);
+    assert.equal(m.bpm, 120.0);
+    assert.equal(fallbackMeasure(30.0).endTime, 30.0);
+});
+
+test('fallbackMeasure: beatTimes has exactly numBeats entries spanning the full length', () => {
+    const m = fallbackMeasure(40.0);
+    assert.equal(m.beatTimes.length, m.numBeats);
+    assert.deepEqual(m.beatTimes, [0, 10, 20, 30]);
+});
+
+test('fallbackMeasure: non-positive/invalid length falls back to the default span', () => {
+    assert.equal(fallbackMeasure(0).endTime, 60.0);
+    assert.equal(fallbackMeasure(-5).endTime, 60.0);
+    assert.equal(fallbackMeasure(NaN).endTime, 60.0);
+    assert.equal(fallbackMeasure(undefined).endTime, 60.0);
+});
+
+test('mergeEvents: sorts notes and chords by time', () => {
+    const events = mergeEvents(
+        [{ t: 1.0, s: 0, f: 0 }, { t: 0.0, s: 1, f: 2 }],
+        [{ t: 0.5, hd: false, notes: [{ s: 2, f: 1 }] }],
+    );
+    assert.deepEqual(events.map(e => e.time), [0.0, 0.5, 1.0]);
+    assert.equal(events[0].type, 'note');
+    assert.equal(events[1].type, 'chord');
+});
+
+test('mergeEvents: skips high-density chords', () => {
+    assert.deepEqual(mergeEvents([], [{ t: 0.0, hd: true, notes: [] }]), []);
+});
+
+test('quantizeThirtySecond: snaps to nearest subdivision', () => {
+    const beatTimes = [0.0, 1.0, 2.0, 3.0];
+    assert.equal(quantizeThirtySecond(0.0, beatTimes, 4.0), 0);
+    assert.equal(quantizeThirtySecond(1.0, beatTimes, 4.0), 8); // SUBDIV=8 -> exactly beat 2
+});
+
+test('decomposeThirtySeconds: non-positive yields a quarter-note filler', () => {
+    assert.deepEqual(decomposeThirtySeconds(0), [{ duration: 4, dots: 0 }]);
+});
+
+test('decomposeThirtySeconds/thirtySecondsForDuration: round-trip common counts', () => {
+    for (const count of [1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 17, 33]) {
+        const total = decomposeThirtySeconds(count).reduce((sum, d) => sum + thirtySecondsForDuration(d), 0);
+        assert.equal(total, count, `count=${count} -> summed to ${total}`);
+    }
+});
+
+test('thirtySecondsForDuration: dotted multiplier', () => {
+    assert.equal(thirtySecondsForDuration({ duration: 4, dots: 1 }), 12); // base 8 * 1.5
+});
+
+test('buildTuning: standard 6-string guitar, no offsets', () => {
+    const tunings = buildTuning([0, 0, 0, 0, 0, 0], false, 6);
+    assert.deepEqual(tunings, [64, 59, 55, 50, 45, 40]);
+});
+
+test('buildTuning: offset shifts the right RS string', () => {
+    // RS string 0 (lowest) raised 2 semitones -> lands on the LAST (lowest-pitch) tuning slot.
+    const tunings = buildTuning([2, 0, 0, 0, 0, 0], false, 6);
+    assert.equal(tunings[5], 42);
+});
+
+test('buildTuning: 4-string bass uses the bass table', () => {
+    assert.deepEqual(buildTuning([0, 0, 0, 0], true, 4), [43, 38, 33, 28]);
+});
+
+test('buildTuning: 8-string guitar (no GP5-style string cap)', () => {
+    const tunings = buildTuning(new Array(8).fill(0), false, 8);
+    assert.deepEqual(tunings, [64, 59, 55, 50, 45, 40, 35, 30]);
+});
+
+test('buildTuning: 9-string guitar extrapolates beyond the known table', () => {
+    const tunings = buildTuning(new Array(9).fill(0), false, 9);
+    assert.equal(tunings.length, 9);
+    assert.equal(tunings[8], 25); // one more perfect fourth (5 semitones) below 30
+});
+
+test('buildTuning: bass beyond the known table (4/5/6) extends and nearest-matches', () => {
+    const tunings = buildTuning(new Array(7).fill(0), true, 7);
+    assert.equal(tunings.length, 7);
+    // nearest known key is 6 ([48,43,38,33,28,23]), extended one more fourth down.
+    assert.deepEqual(tunings, [48, 43, 38, 33, 28, 23, 18]);
+});
+
+test('buildTuning: RS-XML pads tuning to length 6 even for a 4-string instrument', () => {
+    // Known real-world shape: only the first 4 offsets (indices 0-3,
+    // lowest-string-first) are meaningful; indices 4-5 are padding that
+    // must be ignored, not read as extra strings.
+    const tunings = buildTuning([1, 2, 0, 0, 0, 0], true, 4);
+    // rsIdx 0 (offset 1) lands on the lowest-pitch (last) slot, rsIdx 1
+    // (offset 2) on the next one up — buildTuning's index0=highest-pitch
+    // convention, opposite of the RS-string-index (lowest-first) input.
+    assert.deepEqual(tunings, [43, 38, 33 + 2, 28 + 1]);
+});
+
+test('buildTuning: tuning array shorter than stringCount defaults missing offsets to 0', () => {
+    const tunings = buildTuning([3], false, 6);
+    assert.deepEqual(tunings, [64, 59, 55, 50, 45, 40 + 3]);
+});
+
+test('buildTuning: non-finite offsets (untrusted chart-transform output) fall back to 0', () => {
+    // Indexed by rsIdx (lowest string first): only tuningOffsets[5], the
+    // highest string, is a finite value — everything else must default to 0
+    // instead of propagating NaN/Infinity into the tunings array.
+    const tunings = buildTuning([NaN, Infinity, -Infinity, undefined, 'x', 2], false, 6);
+    assert.deepEqual(tunings, [64 + 2, 59, 55, 50, 45, 40]);
+});
diff --git a/test/score-builder.test.mjs b/test/score-builder.test.mjs
new file mode 100644
index 0000000..cde3e19
--- /dev/null
+++ b/test/score-builder.test.mjs
@@ -0,0 +1,291 @@
+// buildScoreFromBundle against the REAL alphaTab model classes (pinned to
+// the same version screen.js loads from the CDN — see package.json). Runs
+// entirely in Node; alphaTab's model classes need no browser/canvas.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as alphaTab from '@coderline/alphatab';
+import { buildScoreFromBundle } from '../src/score-builder.js';
+
+function note(overrides) {
+    return { s: 0, f: 0, sus: 0, sl: -1, slu: -1, bn: 0, ho: false, po: false,
+        hm: false, hp: false, pm: false, mt: false, tr: false, ac: false, tp: false, ...overrides };
+}
+
+function finish(score) {
+    score.finish(new alphaTab.Settings());
+    return score;
+}
+
+function bars(score) {
+    return score.tracks[0].staves[0].bars;
+}
+
+test('buildScoreFromBundle: title/artist/track name/tuning/tempo', () => {
+    const score = finish(buildScoreFromBundle(alphaTab.model, {
+        stringCount: 6,
+        tuning: [0, 0, 0, 0, 0, 0],
+        beats: [{ time: 0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 }],
+        notes: [], chords: [],
+        songInfo: { title: 'My Song', artist: 'Someone', arrangement: 'Lead', duration: 2.0 },
+    }));
+    assert.equal(score.title, 'My Song');
+    assert.equal(score.artist, 'Someone');
+    assert.equal(score.tracks[0].name, 'Lead');
+    assert.equal(score.tempo, 120);
+    assert.deepEqual(score.tracks[0].staves[0].tuning, [64, 59, 55, 50, 45, 40]);
+});
+
+test('buildScoreFromBundle: bass detection sets bass tuning and channel', () => {
+    const score = finish(buildScoreFromBundle(alphaTab.model, {
+        stringCount: 4,
+        tuning: [0, 0, 0, 0],
+        beats: [{ time: 0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 }],
+        notes: [], chords: [],
+        songInfo: { arrangement: 'Bass', duration: 2.0 },
+    }));
+    assert.deepEqual(score.tracks[0].staves[0].tuning, [43, 38, 33, 28]);
+    assert.equal(score.tracks[0].playbackInfo.primaryChannel, 1);
+});
+
+test('buildScoreFromBundle: bass detection requires a whole word, not a substring', () => {
+    // "BasslineKeys" contains "bass" as a substring but isn't a bass
+    // arrangement.
+    const score = finish(buildScoreFromBundle(alphaTab.model, {
+        stringCount: 6,
+        tuning: [0, 0, 0, 0, 0, 0],
+        beats: [{ time: 0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 }],
+        notes: [], chords: [],
+        songInfo: { arrangement: 'BasslineKeys', duration: 2.0 },
+    }));
+    assert.deepEqual(score.tracks[0].staves[0].tuning, [64, 59, 55, 50, 45, 40]); // guitar, not bass
+    assert.equal(score.tracks[0].playbackInfo.primaryChannel, 0);
+});
+
+test('buildScoreFromBundle: note lands on the right string/fret', () => {
+    const score = finish(buildScoreFromBundle(alphaTab.model, {
+        stringCount: 6,
+        tuning: [0, 0, 0, 0, 0, 0],
+        beats: [{ time: 0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 }],
+        notes: [{ t: 0.0, ...note({ s: 0, f: 3 }) }],
+        chords: [],
+        songInfo: {},
+    }));
+    const n = bars(score)[0].voices[0].beats[0].notes[0];
+    assert.equal(n.string, 1); // RS string 0 (lowest) -> alphaTab string 1 (lowest)
+    assert.equal(n.fret, 3);
+});
+
+test('buildScoreFromBundle: chord notes land in one beat, each with its own fret', () => {
+    const score = finish(buildScoreFromBundle(alphaTab.model, {
+        stringCount: 6,
+        tuning: [0, 0, 0, 0, 0, 0],
+        beats: [{ time: 0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 }],
+        notes: [],
+        chords: [{ t: 0.0, hd: false, notes: [note({ s: 0, f: 2 }), note({ s: 5, f: 7 })] }],
+        songInfo: {},
+    }));
+    const beat = bars(score)[0].voices[0].beats[0];
+    assert.equal(beat.notes.length, 2);
+    // Cross-check fret-to-string pairing, not just which strings sounded —
+    // distinct frets (2 vs 7) so a cross-assignment bug can't pass by
+    // coincidence the way two equal/default frets could.
+    const byString = new Map(beat.notes.map(n => [n.string, n.fret]));
+    assert.equal(byString.get(1), 2); // RS string 0 -> alphaTab string 1
+    assert.equal(byString.get(6), 7); // RS string 5 -> alphaTab string 6
+});
+
+test('buildScoreFromBundle: an out-of-range string index is dropped, not corrupted', () => {
+    const score = finish(buildScoreFromBundle(alphaTab.model, {
+        stringCount: 6,
+        tuning: [0, 0, 0, 0, 0, 0],
+        beats: [{ time: 0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 }],
+        notes: [
+            { t: 0.0, ...note({ s: 8, f: 3 }) },  // out of range for stringCount=6
+            { t: 0.5, ...note({ s: 2, f: 1 }) },  // valid
+        ],
+        chords: [],
+        songInfo: {},
+    }));
+    const beats = bars(score)[0].voices[0].beats;
+    assert.equal(beats[0].notes.length, 0); // dropped, not a corrupted/NaN-pitch note
+    assert.equal(beats[1].notes.length, 1);
+    assert.equal(beats[1].notes[0].string, 3); // s:2 -> alphaTab string 3
+    assert.equal(Number.isFinite(beats[1].notes[0].realValue), true);
+});
+
+test('buildScoreFromBundle: NaN/non-integer string or fret is dropped, not a crash', () => {
+    // wire.s < 0 || wire.s >= stringCount alone lets NaN through (NaN fails
+    // both comparisons), and wire.f had no validation at all.
+    const score = finish(buildScoreFromBundle(alphaTab.model, {
+        stringCount: 6,
+        tuning: [0, 0, 0, 0, 0, 0],
+        beats: [{ time: 0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 }],
+        notes: [
+            { t: 0.0, ...note({ s: NaN, f: 3 }) },
+            { t: 0.5, ...note({ s: 2, f: NaN }) },
+            { t: 1.0, ...note({ s: 2, f: 1 }) },  // valid
+        ],
+        chords: [],
+        songInfo: {},
+    }));
+    const beats = bars(score)[0].voices[0].beats;
+    assert.equal(beats[0].notes.length, 0);
+    assert.equal(beats[1].notes.length, 0);
+    assert.equal(beats[2].notes.length, 1);
+});
+
+test('buildScoreFromBundle: an odd gap (17 32nd-notes) ties the sustain, not silence', () => {
+    const score = finish(buildScoreFromBundle(alphaTab.model, {
+        stringCount: 6,
+        tuning: [0, 0, 0, 0, 0, 0],
+        beats: [{ time: 0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 }],
+        notes: [
+            { t: 0.0, ...note({ s: 0, f: 5 }) },
+            { t: 1.0625, ...note({ s: 1, f: 2 }) },  // quantizes 17 slots after t=0.0
+        ],
+        chords: [],
+        songInfo: {},
+    }));
+    const beats = bars(score)[0].voices[0].beats;
+    // decomposeThirtySeconds(17) -> [half note, 32nd note]: origin + one tied continuation.
+    assert.equal(beats[0].duration, alphaTab.model.Duration.Half);
+    assert.equal(beats[0].notes[0].isTieDestination, false);
+
+    assert.equal(beats[1].duration, alphaTab.model.Duration.ThirtySecond);
+    assert.equal(beats[1].notes.length, 1);
+    const tied = beats[1].notes[0];
+    assert.equal(tied.isTieDestination, true);
+    assert.equal(tied.string, 1);
+    assert.equal(tied.fret, 5);
+    assert.equal(tied.tieOrigin, beats[0].notes[0]);
+});
+
+test('buildScoreFromBundle: hammer-on/slide auto-resolve to the next note on the same string', () => {
+    const score = finish(buildScoreFromBundle(alphaTab.model, {
+        stringCount: 6,
+        tuning: [0, 0, 0, 0, 0, 0],
+        beats: [{ time: 0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 }],
+        notes: [
+            { t: 0.0, ...note({ s: 0, f: 3, ho: true, sl: 1 }) },
+            { t: 0.5, ...note({ s: 0, f: 5 }) },
+        ],
+        chords: [],
+        songInfo: {},
+    }));
+    const beats = bars(score)[0].voices[0].beats;
+    const origin = beats[0].notes[0];
+    assert.equal(origin.isHammerPullOrigin, true);
+    assert.equal(origin.hammerPullDestination.fret, 5);
+    assert.equal(origin.slideTarget.fret, 5);
+});
+
+test('buildScoreFromBundle: bend/harmonic/accent/palm-mute map onto the note', () => {
+    const score = finish(buildScoreFromBundle(alphaTab.model, {
+        stringCount: 6,
+        tuning: [0, 0, 0, 0, 0, 0],
+        beats: [{ time: 0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 }],
+        notes: [{ t: 0.0, ...note({ s: 0, f: 2, bn: 2, hm: true, ac: true, pm: true }) }],
+        chords: [],
+        songInfo: {},
+    }));
+    const n = bars(score)[0].voices[0].beats[0].notes[0];
+    assert.equal(n.hasBend, true);
+    assert.deepEqual(n.bendPoints.map(p => [p.offset, p.value]), [[0, 0], [30, 4], [60, 4]]);
+    assert.equal(n.harmonicType, alphaTab.model.HarmonicType.Natural);
+    assert.equal(n.accentuated, alphaTab.model.AccentuationType.Normal);
+    assert.equal(n.isPalmMute, true);
+});
+
+test('buildScoreFromBundle: mute and tap map onto the note', () => {
+    const score = finish(buildScoreFromBundle(alphaTab.model, {
+        stringCount: 6,
+        tuning: [0, 0, 0, 0, 0, 0],
+        beats: [{ time: 0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 }],
+        notes: [
+            { t: 0.0, ...note({ s: 0, f: 2, mt: true }) },
+            { t: 0.5, ...note({ s: 1, f: 3, tp: true }) },
+        ],
+        chords: [],
+        songInfo: {},
+    }));
+    const beats = bars(score)[0].voices[0].beats;
+    assert.equal(beats[0].notes[0].isDead, true);
+    assert.equal(beats[1].notes[0].isLeftHandTapped, true);
+});
+
+test('buildScoreFromBundle: tremolo only marks the beat when every note requests it', () => {
+    const score = finish(buildScoreFromBundle(alphaTab.model, {
+        stringCount: 6,
+        tuning: [0, 0, 0, 0, 0, 0],
+        beats: [{ time: 0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 }],
+        notes: [],
+        chords: [
+            // Mixed: only one of two notes wants tremolo -> not applied.
+            { t: 0.0, hd: false, notes: [note({ s: 0, f: 1, tr: true }), note({ s: 1, f: 2, tr: false })] },
+            // Uniform: both notes want tremolo -> applied.
+            { t: 0.5, hd: false, notes: [note({ s: 0, f: 3, tr: true }), note({ s: 1, f: 4, tr: true })] },
+        ],
+        songInfo: {},
+    }));
+    const beats = bars(score)[0].voices[0].beats;
+    assert.equal(beats[0].tremoloPicking, undefined);
+    assert.notEqual(beats[1].tremoloPicking, undefined);
+    assert.equal(beats[1].tremoloPicking.marks, 1);
+});
+
+test('buildScoreFromBundle: events partition correctly across measures (and outliers drop)', () => {
+    // Notes before the first measure's start and after the last measure's
+    // end are dropped (matches the old per-measure >= start && < end
+    // filter); one note lands in each real measure.
+    const score = finish(buildScoreFromBundle(alphaTab.model, {
+        stringCount: 6,
+        tuning: [0, 0, 0, 0, 0, 0],
+        beats: [
+            { time: 0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 },
+            { time: 2.0, measure: 1 }, { time: 2.5 }, { time: 3.0 }, { time: 3.5 },
+        ],
+        notes: [
+            { t: -1.0, ...note({ s: 0, f: 9 }) },  // before measure 0 -> dropped
+            { t: 0.0, ...note({ s: 0, f: 1 }) },   // measure 0
+            { t: 2.0, ...note({ s: 0, f: 2 }) },   // measure 1
+            { t: 99.0, ...note({ s: 0, f: 9 }) },  // after the last measure -> dropped
+        ],
+        chords: [],
+        songInfo: { duration: 4.0 },
+    }));
+    const b = bars(score);
+    assert.equal(b[0].voices[0].beats[0].notes[0].fret, 1);
+    assert.equal(b[1].voices[0].beats[0].notes[0].fret, 2);
+    const allFrets = b.flatMap(bar => bar.voices[0].beats.flatMap(beat => beat.notes.map(n => n.fret)));
+    assert.deepEqual(allFrets.sort((x, y) => x - y), [1, 2]);
+});
+
+test('buildScoreFromBundle: an empty measure renders as a rest, not a dropped bar', () => {
+    const score = finish(buildScoreFromBundle(alphaTab.model, {
+        stringCount: 6,
+        tuning: [0, 0, 0, 0, 0, 0],
+        beats: [
+            { time: 0, measure: 0 }, { time: 0.5 }, { time: 1.0 }, { time: 1.5 },
+            { time: 2.0, measure: 1 }, { time: 2.5 }, { time: 3.0 }, { time: 3.5 },
+        ],
+        notes: [{ t: 0.0, ...note({ s: 0, f: 1 }) }], // only measure 0 has content
+        chords: [],
+        songInfo: { duration: 4.0 },
+    }));
+    const b = bars(score);
+    assert.equal(b.length, 2);
+    assert.equal(b[1].voices[0].beats.every(beat => beat.isRest), true);
+});
+
+test('buildScoreFromBundle: no beats falls back to a single default measure', () => {
+    const score = finish(buildScoreFromBundle(alphaTab.model, {
+        stringCount: 6,
+        tuning: [0, 0, 0, 0, 0, 0],
+        beats: [],
+        notes: [{ t: 0.0, ...note({ s: 0, f: 0 }) }],
+        chords: [],
+        songInfo: { duration: 4.0 },
+    }));
+    assert.equal(bars(score).length, 1);
+    assert.equal(score.masterBars[0].timeSignatureNumerator, 4);
+});
diff --git a/tests/conftest.py b/tests/conftest.py
deleted file mode 100644
index 8bf4d8c..0000000
--- a/tests/conftest.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import sys
-import types
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-
-# rs2gp.py imports `from song import arrangement_string_count` at module
-# top-level — `song` is a host-provided lib module (lib/song.py, loaded via
-# the desktop app's sys.path setup at runtime), not something this plugin
-# repo ships or that's pip-installable. Stub just the one symbol rs2gp
-# actually uses so the module — and the pure helper functions we're
-# testing — can be imported standalone in CI.
-if "song" not in sys.modules:
-    stub = types.ModuleType("song")
-    stub.arrangement_string_count = lambda arr: 6
-    sys.modules["song"] = stub
diff --git a/tests/test_rs2gp_helpers.py b/tests/test_rs2gp_helpers.py
deleted file mode 100644
index 1b0e882..0000000
--- a/tests/test_rs2gp_helpers.py
+++ /dev/null
@@ -1,149 +0,0 @@
-"""Pure/deterministic helpers in rs2gp.py: measure parsing, event merging,
-sixteenth-note quantization and duration decomposition. guitarpro's Duration
-objects are used directly (real dependency, pip-installable) but nothing
-here touches the GP5 binary writer or the host `song` module beyond the
-stub in conftest.py."""
-
-from types import SimpleNamespace
-
-import guitarpro
-import rs2gp
-
-
-def beat(time, measure=-1):
-    return SimpleNamespace(time=time, measure=measure)
-
-
-# ── _parse_measures ───────────────────────────────────────────────────────────
-
-def test_parse_measures_empty_input():
-    assert rs2gp._parse_measures([]) == []
-    assert rs2gp._parse_measures(None) == []
-
-
-def test_parse_measures_groups_by_measure_marker():
-    beats = [
-        beat(0.0, measure=0), beat(0.5), beat(1.0), beat(1.5),
-        beat(2.0, measure=1), beat(2.5), beat(3.0), beat(3.5),
-    ]
-    measures = rs2gp._parse_measures(beats)
-    assert len(measures) == 2
-    assert measures[0]["num_beats"] == 4
-    assert measures[0]["start_time"] == 0.0
-    assert measures[0]["end_time"] == 2.0
-    assert measures[1]["start_time"] == 2.0
-
-
-def test_parse_measures_estimates_bpm_from_beat_interval():
-    # 0.5s between beats -> 120 BPM.
-    beats = [beat(0.0, measure=0), beat(0.5), beat(1.0), beat(1.5)]
-    measures = rs2gp._parse_measures(beats)
-    assert abs(measures[0]["bpm"] - 120.0) < 0.01
-
-
-def test_parse_measures_last_measure_extrapolates_end_time():
-    beats = [beat(0.0, measure=0), beat(0.5), beat(1.0), beat(1.5)]
-    measures = rs2gp._parse_measures(beats)
-    # avg beat interval 0.5 -> end_time = last beat + 0.5
-    assert measures[-1]["end_time"] == 2.0
-
-
-def test_parse_measures_single_beat_final_measure_reuses_prior_interval():
-    beats = [
-        beat(0.0, measure=0), beat(0.5), beat(1.0), beat(1.5),
-        beat(2.0, measure=1),  # lone trailing beat, no follow-up
-    ]
-    measures = rs2gp._parse_measures(beats)
-    assert measures[1]["num_beats"] == 1
-    # reuses measure 0's duration (2.0s) since there's no next group or 2nd beat
-    assert measures[1]["end_time"] == 2.0 + (measures[0]["end_time"] - measures[0]["start_time"])
-    assert measures[1]["bpm"] == measures[0]["bpm"]
-
-
-def test_fallback_measure_defaults_and_custom_length():
-    m = rs2gp._fallback_measure(None)
-    assert m["end_time"] == 60.0
-    assert m["num_beats"] == 4
-    assert m["bpm"] == 120.0
-
-    m2 = rs2gp._fallback_measure(30.0)
-    assert m2["end_time"] == 30.0
-
-
-# ── _note_dict / _merge_events / _used_string_indices ──────────────────────────
-
-def make_note(string=0, fret=3, sustain=0.0, time=0.0, **extra):
-    defaults = dict(slide_to=None, bend=None, hammer_on=False, pull_off=False,
-                     harmonic=False, harmonic_pinch=False, palm_mute=False,
-                     mute=False, tremolo=False, accent=False, tap=False)
-    defaults.update(extra)
-    return SimpleNamespace(string=string, fret=fret, sustain=sustain, time=time, **defaults)
-
-
-def test_note_dict_carries_declared_fields_and_defaults_missing_to_false():
-    n = SimpleNamespace(string=1, fret=5, sustain=0.2)  # no effect flags set
-    d = rs2gp._note_dict(n)
-    assert d["string"] == 1
-    assert d["fret"] == 5
-    assert d["hammer_on"] is False
-    assert d["accent"] is False
-
-
-def test_merge_events_sorts_notes_and_chords_by_time():
-    arr = SimpleNamespace(
-        notes=[make_note(time=1.0), make_note(time=0.0)],
-        chords=[SimpleNamespace(time=0.5, high_density=False,
-                                 notes=[make_note(time=0.5, string=2)])],
-    )
-    events = rs2gp._merge_events(arr)
-    assert [e["time"] for e in events] == [0.0, 0.5, 1.0]
-    assert events[1]["type"] == "chord"
-    assert events[0]["type"] == "note"
-
-
-def test_merge_events_skips_high_density_chords():
-    arr = SimpleNamespace(
-        notes=[],
-        chords=[SimpleNamespace(time=0.0, high_density=True, notes=[])],
-    )
-    assert rs2gp._merge_events(arr) == []
-
-
-def test_used_string_indices_covers_notes_and_chord_members():
-    events = [
-        {"type": "note", "string": 0},
-        {"type": "chord", "chord_notes": [{"string": 2}, {"string": 3}]},
-    ]
-    assert rs2gp._used_string_indices(events) == {0, 2, 3}
-
-
-# ── _quantize_sixteenth ────────────────────────────────────────────────────────
-
-def test_quantize_sixteenth_snaps_to_the_nearest_subdivision():
-    beat_times = [0.0, 1.0, 2.0, 3.0]
-    # SUBDIV=8 32nd-note slots per beat, so beat 0 spans indices 0..7.
-    idx = rs2gp._quantize_sixteenth(0.0, beat_times, measure_end=4.0)
-    assert idx == 0
-    idx_mid = rs2gp._quantize_sixteenth(1.0, beat_times, measure_end=4.0)
-    assert idx_mid == rs2gp.SUBDIV  # exactly on beat 2 -> index SUBDIV*1
-
-
-# ── _decompose_sixteenths / _dur_sixteenths round-trip ──────────────────────────
-
-def test_decompose_sixteenths_zero_or_negative_yields_a_whole_rest():
-    durs = rs2gp._decompose_sixteenths(0)
-    assert len(durs) == 1
-    assert durs[0].value == 4
-
-
-def test_decompose_and_dur_sixteenths_round_trip_common_counts():
-    for count in [1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 17, 33]:
-        durs = rs2gp._decompose_sixteenths(count)
-        total = sum(rs2gp._dur_sixteenths(d) for d in durs)
-        assert total == count, f"count={count} -> durs summed to {total}"
-
-
-def test_dur_sixteenths_applies_dotted_multiplier():
-    d = guitarpro.Duration(value=4)
-    d.isDotted = True
-    assert rs2gp._dur_sixteenths(d) == 12  # base 8 * 1.5