refactor(app): carve the playback transport out of app.js — and RETIRE 8 host hooks (R3a) (#894)

static/js/transport.js (377) — bodies VERBATIM. app.js 6,643 → 6,316.

THIS IS THE FIRST CARVE THAT SUBTRACTS HOOKS INSTEAD OF ADDING THEM.

Every carve before this one added host hooks: a module pulled out of app.js still had
to call back into it. But four modules were all reaching through the seam for the SAME
handful of names — _audioSeek, _audioTime, setPlayButtonState, _songEventPayload,
jucePlayer. Those names have an owner, and it isn't app.js. Give them one, and the
consumers import them directly:

    count-in.js           5 hooks -> 0     (host import deleted)
    juce-audio.js         4 hooks -> 0     (host import deleted)
    loops.js              6 hooks -> 4
    section-practice.js  10 hooks -> 7
    ----------------------------------------------------------
    configureHost()      20 hooks -> 12

A hook is a cycle you agreed to live with. An import is a dependency you actually have.
Prefer the import whenever the name has a real owner.

_audioSeekGen now stays PRIVATE. It has exactly one writer — _resetAudioSeekState(),
which moved with it — so readers get audioSeekGen() and nobody outside can desync it.
Strictly better than the hook it replaces, which handed out a getter and left the writer
behind in app.js.

THE SCAN HAD A HOLE, AND IT BIT. Picking the carve by dependency closure over app.js's
own top-level decls said this cluster was downward-closed. It wasn't:
_currentPlaybackSnapshot reads loopA/loopB — which live in ./js/loops.js, and loops.js
imports transport. The scan saw nothing, because loopA STOPPED BEING an app.js decl the
moment loops.js was carved out. Any dependency scan of a partly-carved monolith has to
resolve the imports too, or it will confidently hand you a cycle. Added that pass; it
found exactly one back-edge, and _currentPlaybackSnapshot stays in app.js (as does
restartCurrentSong, which calls _cancelCountIn). app.js is the root — it imports both
sides for free.

TESTS. Four harnesses retargeted (play_button_reroute_guard, song_event_payload,
song_seek -> transport.js; playback_app_adapter SPLIT, since
_installPlaybackTransportAdapter stayed behind).

The two CENSUS tests — "≥8 song:* emit sites", "every seek callsite passes a reason" —
now scan app.js AND every static/js/*.js, not one file. Pointed at a single file, their
count silently shrinks as code leaves, which reads as "someone deleted an emit" or, worse,
passes while genuinely missing sites. Both bite-tested: stripping a _songEventPayload()
from an emit and adding a reason-less _audioSeek() each fail the suite.

VERIFIED. A/B against origin/main, real song, real playback: song:play payload is exactly
{audioT, chartT, perfNow, time}; song:seek carries reason "seek-by" with finite from/to;
all five song:* events fire; seekBy advances the clock; restartCurrentSong returns to zero;
the play button's aria-pressed tracks state. IDENTICAL on all 21 probes, zero page errors.

pytest 2396, node 1040/1040, host contract 2/2, ESLint 0 (no-cycle clean), Codex 0.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

static/js/juce-audio.js

@@ -24,7 +24,7 @@
 // See ./host.js: reading an unwired hook THROWS, and tests/js/host_contract.test.js
 // fails CI if the hooks used here and the hooks app.js wires ever drift apart.
 import { audio } from './audio-el.js';
-import { host } from './host.js';
+import { _audioSeek, _songEventPayload, jucePlayer, setPlayButtonState } from './transport.js';
 import { setSpeed } from './player-controls.js';
 import { S } from './player-state.js';
 
@@ -199,23 +199,23 @@ import { S } from './player-state.js';
             // transport off a stale `wasPlaying` snapshot would resume a song
             // the user just paused. Only start it if playback is still wanted.
             if (S.isPlaying) {
-                const started = await host.jucePlayer().play();
+                const started = await jucePlayer.play();
                 if (started === false) {
                     if (!_isStale(songAudio) && S.isPlaying) {
                         try { await audio.play(); } catch (_) { /* ignore */ }
                     }
-                    throw new Error('host.jucePlayer().play() failed (transient transport start)');
+                    throw new Error('jucePlayer.play() failed (transient transport start)');
                 }
             }
             if (_isStale(songAudio)) {
                 // Song changed while JUCE was spinning up — undo and bail.
-                await host.jucePlayer().pause().catch(() => {});
+                await jucePlayer.pause().catch(() => {});
                 return 'stale';
             }
             if (window.jucePlayer) {
-                host.jucePlayer()._dur = dur;
-                host.jucePlayer()._pos = pos;
-                host.jucePlayer()._pollAt = performance.now();
+                jucePlayer._dur = dur;
+                jucePlayer._pos = pos;
+                jucePlayer._pollAt = performance.now();
             }
             window._juceMode = true;
             window._juceAudioUrl = url;
@@ -270,7 +270,7 @@ import { S } from './player-state.js';
     async function _switchJuceToHtml5(songAudio) {
         const url = songAudio.url;
         const wasPlaying = S.isPlaying;
-        const pos = (window.jucePlayer ? host.jucePlayer().currentTime : 0) || 0;
+        const pos = (window.jucePlayer ? jucePlayer.currentTime : 0) || 0;
         window.feedBack?.playback?.recordRouteChange?.({
             routeKind: 'browser-media',
             state: 'switching',
@@ -296,7 +296,7 @@ import { S } from './player-state.js';
         };
         let _resumeScheduled = false;
         try {
-            await host.jucePlayer().pause().catch(() => {});
+            await jucePlayer.pause().catch(() => {});
             if (_isStale(songAudio)) return;           // song changed mid-pause
             window._juceMode = false;
             window._juceAudioUrl = null;
@@ -875,18 +875,18 @@ export let _resetJuceAudioShimChain = function () {};
         const seekTime = batch.seekTime;
         if (wantsPause && seekTime !== undefined) {
             enqueue(async (gen) => {
-                const r = await host._audioSeek(seekTime, 'audio-element-shim');
+                const r = await _audioSeek(seekTime, 'audio-element-shim');
                 if (!r.completed) return; // seek cancelled by teardown
                 if (gen !== _juceShimGen) return;
                 if (!forUpcomingPlay) {
-                    await host.jucePlayer().pause();
+                    await jucePlayer.pause();
                     if (gen !== _juceShimGen) return;
                     S.isPlaying = false;
-                    host.setPlayButtonState(false);
+                    setPlayButtonState(false);
                     const sm = window.feedBack;
                     if (sm) {
                         sm.isPlaying = false;
-                        sm.emit('song:pause', host._songEventPayload());
+                        sm.emit('song:pause', _songEventPayload());
                     }
                 }
                 audio.dispatchEvent(new Event('seeked'));
@@ -895,21 +895,21 @@ export let _resetJuceAudioShimChain = function () {};
         }
         if (wantsPause) {
             enqueue(async (gen) => {
-                await host.jucePlayer().pause();
+                await jucePlayer.pause();
                 if (gen !== _juceShimGen) return;
                 S.isPlaying = false;
-                host.setPlayButtonState(false);
+                setPlayButtonState(false);
                 const sm = window.feedBack;
                 if (sm) {
                     sm.isPlaying = false;
-                    sm.emit('song:pause', host._songEventPayload());
+                    sm.emit('song:pause', _songEventPayload());
                 }
             });
             return;
         }
         if (seekTime !== undefined) {
             enqueue(async (gen) => {
-                const r = await host._audioSeek(seekTime, 'audio-element-shim');
+                const r = await _audioSeek(seekTime, 'audio-element-shim');
                 if (!r.completed) return; // seek cancelled by teardown
                 if (gen !== _juceShimGen) return;
                 audio.dispatchEvent(new Event('seeked'));
@@ -937,7 +937,7 @@ export let _resetJuceAudioShimChain = function () {};
 
     Object.defineProperty(audio, 'currentTime', {
         get() {
-            if (window._juceMode) return host.jucePlayer().currentTime;
+            if (window._juceMode) return jucePlayer.currentTime;
             return ctDesc.get.call(this);
         },
         set(v) {
@@ -975,14 +975,14 @@ export let _resetJuceAudioShimChain = function () {};
         if (window._juceMode) {
             if (_juceShimBatch != null) flushJuceShimBatchNow({ forUpcomingPlay: true });
             const p = enqueue(async (gen) => {
-                const started = await host.jucePlayer().play();
+                const started = await jucePlayer.play();
                 if (gen !== _juceShimGen || !started) return;
                 S.isPlaying = true;
-                host.setPlayButtonState(true);
+                setPlayButtonState(true);
                 const sm = window.feedBack;
                 if (sm) {
                     sm.isPlaying = true;
-                    const payload = host._songEventPayload();
+                    const payload = _songEventPayload();
                     sm.emit('song:play', payload);
                     sm.emit('song:resume', payload);
                 }