@ciphore/radiocli 0.1.2 → 0.1.4

package/dist/ui/App.js

@@ -3,7 +3,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Box, Text, useApp, useStdin, useStdout, useWindowSize } from 'ink';
 import { ProviderManager } from '../providers/provider-manager.js';
 import { PlayerController } from '../player/player-controller.js';
-import { playbackBackendInstallHint } from '../player/backend-install.js';
+import { playbackBackendInstallHint, playbackBackendLabel } from '../player/backend-install.js';
 import { JsonLibraryStore, stationKey } from '../storage/store.js';
 import { receiverStyleNames } from '../types.js';
 import { appBackground, nextReceiverStyle, nextTheme, panelBackground, textDim, themeAccent } from './theme.js';
@@ -17,7 +17,10 @@ import { pageFooterText } from './page-footer.js';
 import { disableMouseReporting, enableMouseReporting, exploreCursorForMouseCell } from './terminal-mouse.js';
 import { useAppInput } from './use-app-input.js';
 import { useCommandExecutor } from './use-command-executor.js';
-import { activeTabForScreen, addMediaKeyBinding, applyStationFilters, clamp, clampVolume, defaultExploreCursor, formatExploreCursor, formatFilterLabel, formatTimeLeft, initialStationContexts, mediaActionLabel, moveExploreCursor as shiftExploreCursor, nextSleepTimerMinutes, normalizeMediaKeyBindings, shouldAnimateReceiver, stationApproximateTime, stationContextKeyForScreen, topTabs } from './app-state.js';
+import { isAirPlayCodePromptActive } from './screens/AirPlayCodeScreen.js';
+import { isAirPlayBackendAvailable } from './airplay-settings.js';
+import { audioOutputLabel, resolvedAudioOutput } from './audio-output.js';
+import { activeTabForScreen, addMediaKeyBinding, applyStationFilters, clamp, clampVolume, defaultExploreCursor, formatExploreCursor, formatFilterLabel, formatTimeLeft, initialStationContexts, mediaActionLabel, moveExploreCursor as shiftExploreCursor, nextSleepTimerMinutes, normalizeMediaKeyBindings, shouldAnimateReceiver, shouldSkipAfterTuneError, stationApproximateTime, stationContextKeyForScreen, topTabs } from './app-state.js';
 const LIVE_RECEIVER_STYLES = new Set(receiverStyleNames);
 const LIVE_RECEIVER_PULSE_MS = 80;
 const AMBIENT_RECEIVER_PULSE_MS = 140;
@@ -35,6 +38,7 @@ export function App({ store: providedStore, providers: providedProviders }) {
     const player = useMemo(() => new PlayerController(() => settingsRef.current), []);
     const [playback, setPlayback] = useState(() => player.getState());
     const [availableBackends, setAvailableBackends] = useState(() => player.detectedBackends());
+    const [availableAirPlayDevices, setAvailableAirPlayDevices] = useState(() => player.detectedAirPlayDevices());
     const [screen, setScreen] = useState('home');
     const [selected, setSelected] = useState(0);
     const [message, setMessage] = useState(null);
@@ -55,6 +59,7 @@ export function App({ store: providedStore, providers: providedProviders }) {
     const [spinnerFrame, setSpinnerFrame] = useState(0);
     const [commandMode, setCommandMode] = useState(false);
     const [commandText, setCommandText] = useState('');
+    const [airPlayCode, setAirPlayCode] = useState('');
     const [filters, setFilters] = useState({ codec: null, language: null, minBitrate: null });
     const [sleepUntil, setSleepUntil] = useState(null);
     const [showDiagnostics, setShowDiagnostics] = useState(false);
@@ -117,6 +122,8 @@ export function App({ store: providedStore, providers: providedProviders }) {
         'now-playing': 1,
         library: 0,
         stats: 1,
+        'airplay-settings': 0,
+        'airplay-code': 1,
         settings: settingsItems.length
     });
     itemCountsRef.current = {
@@ -130,12 +137,17 @@ export function App({ store: providedStore, providers: providedProviders }) {
         'now-playing': 1,
         library: stationCounts.library,
         stats: 1,
+        'airplay-settings': availableAirPlayDevices.length,
+        'airplay-code': 1,
         settings: settingsItems.length
     };
     const displayStations = useMemo(() => applyStationFilters(stationContext.stations, filters), [filters, stationContext.stations]);
     displayStationsRef.current = displayStations;
     const sleepLabel = sleepUntil ? `Sleep ${formatTimeLeft(sleepUntil - Date.now())}` : 'Sleep off';
     const showPlaybackFooter = shouldShowPlaybackFooter(playingStation, playback);
+    const selectedAirPlayDevice = useMemo(() => availableAirPlayDevices.find(device => device.id === library.settings.preferredAirPlayDevice), [availableAirPlayDevices, library.settings.preferredAirPlayDevice]);
+    const canEnterAirPlayCode = isAirPlayCodePromptActive(playback) ||
+        Boolean(isAirPlayBackendAvailable(availableBackends) && selectedAirPlayDevice?.requiresPassword && !selectedAirPlayDevice.local);
     const layout = computeTerminalLayout(columns, rows, showPlaybackFooter ? 3 : 2);
     const frameWidth = Math.max(40, layout.columns - 2);
     useEffect(() => player.onChange(setPlayback), [player]);
@@ -192,7 +204,7 @@ export function App({ store: providedStore, providers: providedProviders }) {
     }, []);
     useEffect(() => {
         setSelected(value => clamp(value, currentItemCount(screen) - 1));
-    }, [displayStations.length, filteredCountries.length, screen]);
+    }, [availableAirPlayDevices.length, displayStations.length, filteredCountries.length, screen]);
     useEffect(() => {
         if (!sleepUntil) {
             return;
@@ -214,6 +226,7 @@ export function App({ store: providedStore, providers: providedProviders }) {
     useEffect(() => {
         const backends = player.refreshDetectedBackends();
         setAvailableBackends(backends);
+        void player.refreshAirPlayDevices().then(setAvailableAirPlayDevices).catch(() => setAvailableAirPlayDevices([]));
         if (backends.length === 0) {
             setMessage(`No playback backend found. ${playbackBackendInstallHint()}`);
         }
@@ -235,6 +248,18 @@ export function App({ store: providedStore, providers: providedProviders }) {
         setLibrary(nextLibrary);
         return nextLibrary;
     }, [store]);
+    useEffect(() => {
+        if (!selectedAirPlayDevice?.local || settingsRef.current.preferredBackend !== 'airplay') {
+            return;
+        }
+        const preferredBackend = preferredLocalPlaybackBackend(availableBackends);
+        if (!preferredBackend) {
+            setMessage(`${selectedAirPlayDevice.name} is this Mac. Install mpv to use local playback instead of AirPlay.`);
+            return;
+        }
+        updateSettings({ preferredBackend });
+        setMessage(`${selectedAirPlayDevice.name} is this Mac. Audio output: ${audioOutputLabel(preferredBackend)}.`);
+    }, [availableBackends, selectedAirPlayDevice, updateSettings]);
     const updateMediaKeys = useCallback((mediaKeys) => {
         updateSettings({ mediaKeys: normalizeMediaKeyBindings(mediaKeys) });
     }, [updateSettings]);
@@ -262,6 +287,15 @@ export function App({ store: providedStore, providers: providedProviders }) {
             setMessage(null);
         }
     }, []);
+    const openAirPlayCode = useCallback(() => {
+        setAirPlayCode('');
+        go('airplay-code', { resetSelection: true, clearMessage: false });
+    }, [go]);
+    useEffect(() => {
+        if (isAirPlayCodePromptActive(playback) && screenRef.current !== 'airplay-code') {
+            openAirPlayCode();
+        }
+    }, [openAirPlayCode, playback.backend, playback.message]);
     const shutdown = useCallback(() => {
         store.finishActiveListeningSession();
         player.stop().finally(exit);
@@ -473,7 +507,16 @@ export function App({ store: providedStore, providers: providedProviders }) {
             setPlayingStation(station);
             playbackQueueRef.current = queue;
             store.startListeningSession(station);
-            setLibrary(store.addRecent(station));
+            const nextLibrary = store.addRecent(station);
+            if (screenRef.current === 'library') {
+                const nextLibraryStations = applyStationFilters(buildLibraryStations(nextLibrary), filters);
+                const nextLibraryIndex = nextLibraryStations.findIndex(item => stationMatches(item, station));
+                if (nextLibraryIndex >= 0) {
+                    selectedByScreenRef.current.library = nextLibraryIndex;
+                    setSelected(nextLibraryIndex);
+                }
+            }
+            setLibrary(nextLibrary);
             if (options.openNowPlaying) {
                 go('now-playing');
             }
@@ -484,7 +527,7 @@ export function App({ store: providedStore, providers: providedProviders }) {
             const currentList = queue.stations;
             const currentIndex = currentList.findIndex(item => stationKey(item) === stationKey(station));
             const nextStation = currentIndex >= 0 ? currentList[currentIndex + 1] : undefined;
-            if (settingsRef.current.skipBrokenStreams && nextStation) {
+            if (shouldSkipAfterTuneError(error, settingsRef.current.skipBrokenStreams, nextStation)) {
                 setMessage(`${message} Skipping to ${nextStation.name}.`);
                 rememberQueueSelection(queue, currentIndex + 1);
                 setTimeout(() => playStationRef.current(nextStation, { ...options, queue }), 250);
@@ -492,7 +535,7 @@ export function App({ store: providedStore, providers: providedProviders }) {
             }
             setMessage(message);
         }
-    }, [go, player, providers, queueFromCurrentList, rememberQueueSelection, store]);
+    }, [filters, go, player, providers, queueFromCurrentList, rememberQueueSelection, stationMatches, store]);
     playStationRef.current = playStation;
     const toggleFavorite = useCallback((station) => {
         if (!station) {
@@ -503,17 +546,39 @@ export function App({ store: providedStore, providers: providedProviders }) {
         setLibrary(store.toggleFavorite(station));
         setMessage(`${wasFavorite ? 'Removed from' : 'Added to'} favorites: ${station.name}`);
     }, [store]);
+    const showControlResult = useCallback((result) => {
+        if (!result.ok && result.message) {
+            setMessage(result.message);
+        }
+    }, []);
+    const submitAirPlayCode = useCallback((code) => {
+        const result = player.submitAirPlayPasscode(code);
+        if (result.ok) {
+            setAirPlayCode('');
+            setMessage(result.message ?? 'AirPlay code sent.');
+            go('now-playing', { clearMessage: false });
+            return;
+        }
+        showControlResult(result);
+    }, [go, player, showControlResult]);
     const setVolume = useCallback((volume) => {
         const clamped = clampVolume(volume);
-        updateSettings({ volume: clamped });
-        void player.setVolume(clamped);
-    }, [player, updateSettings]);
+        void player.setVolume(clamped).then(result => {
+            if (result.ok) {
+                updateSettings({ volume: clamped });
+            }
+            showControlResult(result);
+        });
+    }, [player, showControlResult, updateSettings]);
     const adjustVolume = useCallback((delta) => {
         setVolume((player.getState().volume || library.settings.volume) + delta);
     }, [library.settings.volume, player, setVolume]);
     const toggleMute = useCallback(() => {
-        void player.toggleMute();
-    }, [player]);
+        void player.toggleMute().then(showControlResult);
+    }, [player, showControlResult]);
+    const togglePause = useCallback(() => {
+        void player.togglePause().then(showControlResult);
+    }, [player, showControlResult]);
     const cycleDisplayColor = useCallback(() => {
         const theme = nextTheme(settingsRef.current.theme);
         updateSettings({ theme });
@@ -535,12 +600,96 @@ export function App({ store: providedStore, providers: providedProviders }) {
         updateSettings({ enableNearbyLocation });
         setMessage(`Nearby location lookup ${enableNearbyLocation ? 'enabled' : 'disabled'}.`);
     }, [updateSettings]);
-    const cyclePlaybackBackend = useCallback(() => {
-        const current = settingsRef.current.preferredBackend;
-        const preferredBackend = current === 'auto' ? 'mpv' : current === 'mpv' ? 'ffplay' : 'auto';
+    const refreshAirPlayTargets = useCallback(async (announce = true) => {
+        try {
+            const devices = await player.refreshAirPlayDevices();
+            setAvailableAirPlayDevices(devices);
+            const preferredIndex = devices.findIndex(device => device.id === settingsRef.current.preferredAirPlayDevice);
+            if (preferredIndex >= 0) {
+                selectedByScreenRef.current['airplay-settings'] = preferredIndex;
+                if (screenRef.current === 'airplay-settings') {
+                    setSelected(clamp(preferredIndex, devices.length - 1));
+                }
+            }
+            if (announce) {
+                setMessage(devices.length > 0 ? `AirPlay receivers refreshed: ${devices.length} found.` : 'No AirPlay receivers found.');
+            }
+            return devices;
+        }
+        catch {
+            setAvailableAirPlayDevices([]);
+            if (announce) {
+                setMessage('AirPlay receiver refresh failed.');
+            }
+            return [];
+        }
+    }, [player]);
+    const openAirPlaySettings = useCallback(() => {
+        const preferredIndex = availableAirPlayDevices.findIndex(device => device.id === settingsRef.current.preferredAirPlayDevice);
+        selectedByScreenRef.current['airplay-settings'] = Math.max(0, preferredIndex);
+        go('airplay-settings', { resetSelection: false });
+        void refreshAirPlayTargets(false);
+    }, [availableAirPlayDevices, go, refreshAirPlayTargets]);
+    const selectAirPlayDeviceAt = useCallback((index) => {
+        const device = availableAirPlayDevices[index];
+        if (!device) {
+            setMessage('No AirPlay receiver selected.');
+            return;
+        }
+        updateSettings({ preferredAirPlayDevice: device.id });
+        selectedByScreenRef.current['airplay-settings'] = index;
+        if (device.local) {
+            const preferredBackend = preferredLocalPlaybackBackend(availableBackends);
+            if (!preferredBackend) {
+                setMessage(`${device.name} is this Mac. Install mpv to use local playback instead of AirPlay.`);
+                return;
+            }
+            updateSettings({ preferredBackend });
+            if (playingStation && shouldRetuneForAudioOutput(playback.state)) {
+                const queue = playbackQueueRef.current ?? queueFromCurrentList(playingStation);
+                setMessage(`${device.name} is this Mac. Switching audio to ${audioOutputLabel(preferredBackend)}...`);
+                void playStation(playingStation, { queue });
+                return;
+            }
+            setMessage(`${device.name} is this Mac. Audio output: ${audioOutputLabel(preferredBackend)}.`);
+            return;
+        }
+        if (!isAirPlayBackendAvailable(availableBackends)) {
+            setMessage(`AirPlay receiver: ${device.name}. AirPlay playback is unavailable; run radiocli doctor.`);
+            return;
+        }
+        updateSettings({ preferredBackend: 'airplay' });
+        if (playingStation && shouldRetuneForAudioOutput(playback.state)) {
+            const queue = playbackQueueRef.current ?? queueFromCurrentList(playingStation);
+            setMessage(`Switching audio to AirPlay: ${device.name}...`);
+            void playStation(playingStation, { queue });
+            return;
+        }
+        setMessage(`AirPlay receiver: ${device.name}. Audio output: AirPlay.`);
+    }, [availableAirPlayDevices, availableBackends, playback.state, playStation, playingStation, queueFromCurrentList, updateSettings]);
+    const cycleAudioOutput = useCallback(() => {
+        const currentOutput = settingsRef.current.preferredBackend;
+        const activeNeedsSelectedOutput = Boolean(playingStation &&
+            shouldRetuneForAudioOutput(playback.state) &&
+            audioOutputCanApply(currentOutput, settingsRef.current) &&
+            audioOutputNeedsActiveSwitch(currentOutput, playback.backend, availableBackends));
+        const preferredBackend = activeNeedsSelectedOutput
+            ? currentOutput
+            : nextAvailablePlaybackBackend(currentOutput, availableBackends);
         updateSettings({ preferredBackend });
-        setMessage(`Playback backend: ${preferredBackend}`);
-    }, [updateSettings]);
+        if (preferredBackend === 'airplay' && !settingsRef.current.preferredAirPlayDevice) {
+            setMessage('Choose an AirPlay receiver first. Your current station will keep playing until you pick one.');
+            openAirPlaySettings();
+            return;
+        }
+        if (playingStation && shouldRetuneForAudioOutput(playback.state)) {
+            const queue = playbackQueueRef.current ?? queueFromCurrentList(playingStation);
+            setMessage(`Switching audio to ${audioOutputSwitchLabel(preferredBackend, availableBackends)}...`);
+            void playStation(playingStation, { queue });
+            return;
+        }
+        setMessage(`Audio output: ${audioOutputSwitchLabel(preferredBackend, availableBackends)}.`);
+    }, [availableBackends, openAirPlaySettings, playback.backend, playback.state, playStation, playingStation, queueFromCurrentList, updateSettings]);
     const toggleSkipBrokenStreams = useCallback(() => {
         const skipBrokenStreams = !settingsRef.current.skipBrokenStreams;
         updateSettings({ skipBrokenStreams });
@@ -579,10 +728,13 @@ export function App({ store: providedStore, providers: providedProviders }) {
         else if (target === 'library') {
             openLibrary();
         }
+        else if (target === 'airplay-settings') {
+            openAirPlaySettings();
+        }
         else {
             go(target);
         }
-    }, [go, loadExplore, loadNearby, openLibrary]);
+    }, [go, loadExplore, loadNearby, openAirPlaySettings, openLibrary]);
     const openAdjacentTab = useCallback((direction) => {
         const active = activeTabForScreen(screen);
         const currentIndex = topTabs.findIndex(tab => tab.screen === active);
@@ -597,6 +749,7 @@ export function App({ store: providedStore, providers: providedProviders }) {
         countries,
         go,
         loadCountry,
+        openAirPlaySettings,
         openLibrary,
         player,
         playingStation,
@@ -643,13 +796,15 @@ export function App({ store: providedStore, providers: providedProviders }) {
     }, [playStation, playingStation, queueContainsStation, queueFromCurrentList, rememberQueueSelection]);
     useAppInput({
         adjustVolume,
+        airPlayCode,
+        canEnterAirPlayCode,
         beginLearningTransportKey,
         capturingTransportAction,
         commandMode,
         commandText,
         currentItemCount,
         cycleDisplayColor,
-        cyclePlaybackBackend,
+        cycleAudioOutput,
         cycleReceiverStyle,
         cycleSleepTimer,
         editingCountryFilter,
@@ -661,6 +816,8 @@ export function App({ store: providedStore, providers: providedProviders }) {
         lastSubmittedSearchRef,
         loadCountry,
         openAdjacentTab,
+        openAirPlayCode,
+        openAirPlaySettings,
         openScreen,
         playAdjacent,
         playStation,
@@ -669,6 +826,9 @@ export function App({ store: providedStore, providers: providedProviders }) {
         moveExploreCursor: moveExploreMapCursor,
         moveExploreCursorToCell: moveExploreMapCursorToCell,
         refreshProviderHealth,
+        refreshAirPlayTargets: () => {
+            void refreshAirPlayTargets();
+        },
         resetLearnedTransportKeys,
         runSearch,
         saveLearnedTransportKey,
@@ -676,21 +836,25 @@ export function App({ store: providedStore, providers: providedProviders }) {
         searchQuery,
         selected,
         selectedStation,
+        selectAirPlayDeviceAt,
         setCapturingTransportAction,
         setCommandMode,
         setCommandText,
         setCountryFilter,
+        setAirPlayCode,
         setEditingCountryFilter,
         setEditingSearch,
         setMessage,
         setSearchQuery,
         setSelected,
         setShowDiagnostics,
+        submitAirPlayCode,
         settingsRef,
         shutdown,
         stdin,
         toggleFavorite,
         toggleMute,
+        togglePause,
         toggleNearbyLocation,
         toggleRadioGarden,
         toggleSkipBrokenStreams
@@ -699,7 +863,11 @@ export function App({ store: providedStore, providers: providedProviders }) {
         return itemCountsRef.current[currentScreen] ?? 0;
     }
     const hasTopTabs = !layout.compact;
-    const globalFooter = '←/→ tabs · F7/F9 or ,/. station · F8 pause · t/v display · +/- volume · q quit';
+    const globalFooter = playback.backend === 'ffplay'
+        ? '←/→ tabs · F7/F9 or ,/. station · ffplay fallback: limited controls · t/v display · q quit'
+        : playback.backend === 'airplay'
+            ? '←/→ tabs · F7/F9 or ,/. station · AirPlay: +/- volume, m mute · t/v display · q quit'
+            : '←/→ tabs · F7/F9 or ,/. station · F8 pause · t/v display · +/- volume · q quit';
     const playbackFooter = playbackFooterText({
         station: playingStation,
         playback,
@@ -711,14 +879,16 @@ export function App({ store: providedStore, providers: providedProviders }) {
         spinnerFrame
     });
     const pageFooter = pageFooterText({
+        canEnterAirPlayCode,
         capturingTransportAction,
         commandMode,
         commandText,
         editingCountryFilter,
         editingSearch,
+        playbackBackend: playback.backend,
         screen
     });
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: layout.rows, width: layout.columns, overflow: "hidden", backgroundColor: appBackground, children: [hasTopTabs ? (_jsx(Box, { height: 3, marginBottom: 1, flexShrink: 0, backgroundColor: appBackground, children: _jsx(TopTabs, { tabs: topTabs, active: activeTabForScreen(screen), theme: theme, width: frameWidth, rightLabel: `${playback.backend || 'no backend'} · ${playback.state}` }) })) : null, _jsxs(Box, { height: layout.contentRows, width: frameWidth, flexDirection: "column", overflowY: "hidden", flexShrink: 0, backgroundColor: appBackground, children: [_jsx(AppContent, { backends: availableBackends, countryFilter: countryFilter, diagnostics: diagnostics, displayStations: displayStations, editingCountryFilter: editingCountryFilter, editingSearch: editingSearch, favoriteKeys: favoriteKeys, filterLabel: filterLabel, filteredCountries: filteredCountries, frameWidth: frameWidth, layout: layout, library: library, loadingCountries: loadingCountries, loadingStations: loadingStations, nowPlaying: nowPlaying, playback: playback, playingStation: playingStation, providerHealth: providerHealth, pulse: pulse, searchQuery: searchQuery, screen: screen, selected: selected, showDiagnostics: showDiagnostics, sleepLabel: sleepLabel, stationContext: stationContext, exploreCursor: exploreCursor, stationFavorite: store.isFavorite(playingStation), stationTime: stationApproximateTime(playingStation), storePath: store.filePath, theme: theme }), message ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: themeAccent(theme), children: message }) })) : null] }), _jsxs(Box, { height: layout.footerRows, width: frameWidth, flexDirection: "column", flexShrink: 0, backgroundColor: panelBackground, children: [playbackFooter ? _jsx(Text, { color: themeAccent(theme), children: playbackFooter }) : null, _jsx(Text, { color: commandMode || capturingTransportAction ? themeAccent(theme) : 'gray', children: truncate(pageFooter, frameWidth) }), _jsx(Text, { color: textDim, children: truncate(globalFooter, frameWidth) })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, height: layout.rows, width: layout.columns, overflow: "hidden", backgroundColor: appBackground, children: [hasTopTabs ? (_jsx(Box, { height: 3, marginBottom: 1, flexShrink: 0, backgroundColor: appBackground, children: _jsx(TopTabs, { tabs: topTabs, active: activeTabForScreen(screen), theme: theme, width: frameWidth, rightLabel: `${playbackBackendLabel(playback.backend)} · ${playback.state}` }) })) : null, _jsxs(Box, { height: layout.contentRows, width: frameWidth, flexDirection: "column", overflowY: "hidden", flexShrink: 0, backgroundColor: appBackground, children: [_jsx(AppContent, { airPlayDevices: availableAirPlayDevices, airPlayCode: airPlayCode, backends: availableBackends, countryFilter: countryFilter, diagnostics: diagnostics, displayStations: displayStations, editingCountryFilter: editingCountryFilter, editingSearch: editingSearch, favoriteKeys: favoriteKeys, filterLabel: filterLabel, filteredCountries: filteredCountries, frameWidth: frameWidth, layout: layout, library: library, loadingCountries: loadingCountries, loadingStations: loadingStations, nowPlaying: nowPlaying, playback: playback, playingStation: playingStation, providerHealth: providerHealth, pulse: pulse, searchQuery: searchQuery, screen: screen, selected: selected, showDiagnostics: showDiagnostics, sleepLabel: sleepLabel, stationContext: stationContext, exploreCursor: exploreCursor, stationFavorite: store.isFavorite(playingStation), stationTime: stationApproximateTime(playingStation), storePath: store.filePath, theme: theme }), message ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: themeAccent(theme), children: message }) })) : null] }), _jsxs(Box, { height: layout.footerRows, width: frameWidth, flexDirection: "column", flexShrink: 0, backgroundColor: panelBackground, children: [playbackFooter ? _jsx(Text, { color: themeAccent(theme), children: playbackFooter }) : null, _jsx(Text, { color: commandMode || capturingTransportAction ? themeAccent(theme) : 'gray', children: truncate(pageFooter, frameWidth) }), _jsx(Text, { color: textDim, children: truncate(globalFooter, frameWidth) })] })] }));
 }
 function buildLibraryStations(library) {
     const stations = [];
@@ -765,6 +935,42 @@ function formatDistanceKm(distanceKm) {
     }
     return `${Math.round(distanceKm).toLocaleString()} km`;
 }
+function nextAvailablePlaybackBackend(current, backends) {
+    const options = ['auto'];
+    for (const backend of ['mpv', 'ffplay', 'airplay']) {
+        if (backends.includes(backend)) {
+            options.push(backend);
+        }
+    }
+    const index = options.indexOf(current);
+    return options[(index + 1) % options.length] ?? 'auto';
+}
+function shouldRetuneForAudioOutput(state) {
+    return state === 'loading' || state === 'playing' || state === 'paused';
+}
+function audioOutputNeedsActiveSwitch(selectedOutput, activeBackend, backends) {
+    const resolved = resolvedAudioOutput(selectedOutput, backends);
+    return Boolean(resolved && activeBackend !== 'none' && activeBackend !== resolved);
+}
+function audioOutputCanApply(output, settings) {
+    return output !== 'airplay' || Boolean(settings.preferredAirPlayDevice);
+}
+function preferredLocalPlaybackBackend(backends) {
+    if (backends.includes('mpv')) {
+        return 'mpv';
+    }
+    if (backends.includes('ffplay')) {
+        return 'ffplay';
+    }
+    return null;
+}
+function audioOutputSwitchLabel(output, backends) {
+    const resolved = resolvedAudioOutput(output, backends);
+    if (output === 'auto' && resolved) {
+        return `${audioOutputLabel(resolved)} (automatic)`;
+    }
+    return audioOutputLabel(output);
+}
 function librarySubtitle(library) {
     return `${library.favorites.length} favorites · ${library.recent.length} recent · ${library.imported.length} imported · favorites first`;
 }

package/dist/ui/AppContent.js

@@ -10,9 +10,13 @@ import { StationScreen } from './screens/StationScreen.js';
 import { NowPlayingScreen } from './screens/NowPlayingScreen.js';
 import { StatsScreen } from './screens/StatsScreen.js';
 import { SettingsScreen } from './screens/SettingsScreen.js';
-export function AppContent({ backends, countryFilter, diagnostics, displayStations, editingCountryFilter, editingSearch, exploreCursor, favoriteKeys, filterLabel, filteredCountries, frameWidth, layout, library, loadingCountries, loadingStations, nowPlaying, playback, playingStation, providerHealth, pulse, searchQuery, screen, selected, showDiagnostics, sleepLabel, stationContext, stationFavorite, stationTime, storePath, theme }) {
+import { AirPlaySettingsScreen } from './screens/AirPlaySettingsScreen.js';
+import { AirPlayCodeScreen } from './screens/AirPlayCodeScreen.js';
+import { selectedAirPlayDevice } from './airplay-settings.js';
+import { playbackBackendLabel } from '../player/backend-install.js';
+export function AppContent({ airPlayDevices, airPlayCode, backends, countryFilter, diagnostics, displayStations, editingCountryFilter, editingSearch, exploreCursor, favoriteKeys, filterLabel, filteredCountries, frameWidth, layout, library, loadingCountries, loadingStations, nowPlaying, playback, playingStation, providerHealth, pulse, searchQuery, screen, selected, showDiagnostics, sleepLabel, stationContext, stationFavorite, stationTime, storePath, theme }) {
     if (layout.compact) {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "RadioCLI" }), _jsxs(Text, { color: themeAccent(theme), children: ["Terminal too small: ", layout.columns, "x", layout.rows] }), _jsx(Text, { color: "gray", children: "Resize to at least 64x18 for the full receiver UI." }), _jsxs(Text, { color: "gray", children: ["Playback: ", playback.state, " \u00B7 ", playback.backend] }), _jsx(Text, { color: "gray", children: "q quit \u00B7 Ctrl+C always exits" })] }));
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "RadioCLI" }), _jsxs(Text, { color: themeAccent(theme), children: ["Terminal too small: ", layout.columns, "x", layout.rows] }), _jsx(Text, { color: "gray", children: "Resize to at least 64x18 for the full receiver UI." }), _jsxs(Text, { color: "gray", children: ["Playback: ", playback.state, " \u00B7 ", playbackBackendLabel(playback.backend)] }), _jsx(Text, { color: "gray", children: "q quit \u00B7 Ctrl+C always exits" })] }));
     }
     if (screen === 'home') {
         return _jsx(HomeScreen, { selected: selected, theme: theme, library: library, playback: playback });
@@ -39,7 +43,13 @@ export function AppContent({ backends, countryFilter, diagnostics, displayStatio
         return _jsx(StatsScreen, { library: library, theme: theme, width: frameWidth, height: layout.contentRows });
     }
     if (screen === 'settings') {
-        return (_jsx(SettingsScreen, { selected: selected, settings: library.settings, storePath: storePath, playback: playback, backends: backends, providerHealth: providerHealth, theme: theme, diagnostics: diagnostics, width: frameWidth }));
+        return (_jsx(SettingsScreen, { selected: selected, settings: library.settings, storePath: storePath, playback: playback, backends: backends, airPlayDevices: airPlayDevices, providerHealth: providerHealth, theme: theme, diagnostics: diagnostics, width: frameWidth }));
+    }
+    if (screen === 'airplay-settings') {
+        return (_jsx(AirPlaySettingsScreen, { selected: selected, settings: library.settings, backends: backends, devices: airPlayDevices, theme: theme, width: frameWidth }));
+    }
+    if (screen === 'airplay-code') {
+        return (_jsx(AirPlayCodeScreen, { code: airPlayCode, playback: playback, selectedDevice: selectedAirPlayDevice(library.settings, airPlayDevices), theme: theme, width: frameWidth }));
     }
     return _jsx(Text, { children: "Unknown screen." });
 }

package/dist/ui/airplay-settings.js

@@ -0,0 +1,56 @@
+export function isAirPlayBackendAvailable(backends) {
+    return backends.includes('airplay');
+}
+export function selectedAirPlayDevice(settings, devices) {
+    return devices.find(device => device.id === settings.preferredAirPlayDevice);
+}
+export function airPlayReceiverSettingValue(settings, devices, backends) {
+    const device = selectedAirPlayDevice(settings, devices);
+    const count = airPlayDeviceCountLabel(devices.length);
+    const playbackStatus = isAirPlayBackendAvailable(backends) ? undefined : 'playback unavailable';
+    if (device) {
+        return [device.name, device.local ? 'this Mac' : playbackStatus ?? count].join(' · ');
+    }
+    if (settings.preferredAirPlayDevice) {
+        return ['Saved receiver missing', playbackStatus ?? count].join(' · ');
+    }
+    if (devices.length > 0) {
+        return ['Choose receiver...', playbackStatus ?? count].join(' · ');
+    }
+    return playbackStatus ? `No receivers found · ${playbackStatus}` : 'No receivers found';
+}
+export function airPlayAvailability(backends, devices) {
+    if (!isAirPlayBackendAvailable(backends)) {
+        const detail = devices.length > 0
+            ? 'RadioCLI can see receivers, but this install cannot start AirPlay yet. Run radiocli doctor.'
+            : 'AirPlay is not ready on this install. Run radiocli doctor.';
+        return {
+            ready: false,
+            label: 'Not ready',
+            detail
+        };
+    }
+    if (devices.length === 0) {
+        return {
+            ready: true,
+            label: 'Ready',
+            detail: 'AirPlay is installed; no receivers are visible on this network.'
+        };
+    }
+    return {
+        ready: true,
+        label: 'Ready',
+        detail: `${airPlayDeviceCountLabel(devices.length)} visible on this network.`
+    };
+}
+export function airPlayDeviceDetail(device) {
+    if (device.local) {
+        return `${device.host}:${device.port} · this Mac · use local output`;
+    }
+    const security = device.requiresPassword ? 'code shown on receiver' : 'no code';
+    const protocol = device.airplay2 ? 'AirPlay 2' : 'AirPlay';
+    return `${device.host}:${device.port} · ${protocol} · ${security}`;
+}
+function airPlayDeviceCountLabel(count) {
+    return `${count} receiver${count === 1 ? '' : 's'}`;
+}

package/dist/ui/app-state.js

@@ -1,3 +1,4 @@
+import { isPlaybackOutputError } from '../player/player-controller.js';
 const emptyMediaKeyBindings = {
     previous: [],
     playPause: [],
@@ -5,6 +6,7 @@ const emptyMediaKeyBindings = {
 };
 const mediaTransportActions = ['previous', 'playPause', 'next'];
 const sleepTimerOptions = [null, 15, 30, 60];
+const playbackBackendOptions = ['auto', 'mpv', 'ffplay', 'airplay'];
 export const defaultExploreCursor = {
     latitude: 48.8566,
     longitude: 2.3522
@@ -87,6 +89,10 @@ export function nextSleepTimerMinutes(currentMinutes) {
     const nextIndex = currentIndex >= 0 ? (currentIndex + 1) % sleepTimerOptions.length : 0;
     return sleepTimerOptions[nextIndex] ?? null;
 }
+export function nextPlaybackBackend(current) {
+    const index = playbackBackendOptions.indexOf(current);
+    return playbackBackendOptions[(index + 1) % playbackBackendOptions.length] ?? 'auto';
+}
 export function moveExploreCursor(cursor, direction, fast = false) {
     const latitudeStep = fast ? 6 : 1;
     const longitudeStep = fast ? 12 : 2;
@@ -133,8 +139,17 @@ export function favoriteTarget(screen, selectedStation, playingStation) {
     }
     return playingStation;
 }
+export function shouldSkipAfterTuneError(error, skipBrokenStreams, nextStation) {
+    return Boolean(skipBrokenStreams && nextStation && !isPlaybackOutputError(error));
+}
 export function activeTabForScreen(screen) {
-    return screen === 'stations' || screen === 'map' ? 'countries' : screen;
+    if (screen === 'stations' || screen === 'map') {
+        return 'countries';
+    }
+    if (screen === 'airplay-settings' || screen === 'airplay-code') {
+        return 'settings';
+    }
+    return screen;
 }
 export function stationContextKeyForScreen(screen) {
     if (screen === 'explore' ||

package/dist/ui/audio-output.js

@@ -0,0 +1,42 @@
+import { playbackBackendLabel } from '../player/backend-install.js';
+export function audioOutputLabel(output) {
+    if (output === 'auto') {
+        return 'Automatic';
+    }
+    if (output === 'mpv') {
+        return 'This device (mpv)';
+    }
+    if (output === 'ffplay') {
+        return 'This device (ffplay fallback)';
+    }
+    if (output === 'airplay') {
+        return 'AirPlay';
+    }
+    if (!output || output === 'none') {
+        return 'No output';
+    }
+    return playbackBackendLabel(output);
+}
+export function resolvedAudioOutput(output, backends) {
+    if (output !== 'auto') {
+        return backends.includes(output) ? output : null;
+    }
+    for (const backend of ['mpv', 'ffplay']) {
+        if (backends.includes(backend)) {
+            return backend;
+        }
+    }
+    return null;
+}
+export function audioOutputSettingValue(settings, diagnostics, backends) {
+    const selected = settings.preferredBackend;
+    const selectedLabel = audioOutputLabel(selected);
+    const resolved = resolvedAudioOutput(selected, backends);
+    if (!resolved) {
+        return `${selectedLabel} · unavailable`;
+    }
+    if (diagnostics.active && diagnostics.backend !== 'none' && diagnostics.backend !== resolved) {
+        return `${selectedLabel} · currently ${audioOutputLabel(diagnostics.backend)}`;
+    }
+    return selectedLabel;
+}