@ciphore/radiocli 0.1.3 → 0.1.4

package/dist/ui/App.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, nextAirPlayDeviceId, nextPlaybackBackend, 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;
@@ -56,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);
@@ -118,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 = {
@@ -131,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]);
@@ -193,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;
@@ -237,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]);
@@ -264,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);
@@ -475,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');
             }
@@ -486,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);
@@ -494,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) {
@@ -510,6 +551,16 @@ export function App({ store: providedStore, providers: providedProviders }) {
             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);
         void player.setVolume(clamped).then(result => {
@@ -549,24 +600,96 @@ export function App({ store: providedStore, providers: providedProviders }) {
         updateSettings({ enableNearbyLocation });
         setMessage(`Nearby location lookup ${enableNearbyLocation ? 'enabled' : 'disabled'}.`);
     }, [updateSettings]);
-    const cyclePlaybackBackend = useCallback(() => {
-        const preferredBackend = nextPlaybackBackend(settingsRef.current.preferredBackend);
-        updateSettings({ preferredBackend });
-        setMessage(`Playback backend: ${preferredBackend}`);
-    }, [updateSettings]);
-    const cycleAirPlayTarget = useCallback(() => {
-        void player.refreshAirPlayDevices().then(devices => {
+    const refreshAirPlayTargets = useCallback(async (announce = true) => {
+        try {
+            const devices = await player.refreshAirPlayDevices();
             setAvailableAirPlayDevices(devices);
-            const preferredAirPlayDevice = nextAirPlayDeviceId(settingsRef.current.preferredAirPlayDevice, devices);
-            updateSettings({ preferredAirPlayDevice });
-            const selectedAirPlayDevice = devices.find(device => device.id === preferredAirPlayDevice);
-            setMessage(`AirPlay target: ${selectedAirPlayDevice?.name ?? 'auto'}`);
-        }).catch(() => {
+            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([]);
-            updateSettings({ preferredAirPlayDevice: undefined });
-            setMessage('No AirPlay receivers found.');
-        });
-    }, [player, updateSettings]);
+            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 });
+        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 });
@@ -605,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);
@@ -623,6 +749,7 @@ export function App({ store: providedStore, providers: providedProviders }) {
         countries,
         go,
         loadCountry,
+        openAirPlaySettings,
         openLibrary,
         player,
         playingStation,
@@ -669,14 +796,15 @@ export function App({ store: providedStore, providers: providedProviders }) {
     }, [playStation, playingStation, queueContainsStation, queueFromCurrentList, rememberQueueSelection]);
     useAppInput({
         adjustVolume,
+        airPlayCode,
+        canEnterAirPlayCode,
         beginLearningTransportKey,
         capturingTransportAction,
         commandMode,
         commandText,
         currentItemCount,
-        cycleAirPlayTarget,
         cycleDisplayColor,
-        cyclePlaybackBackend,
+        cycleAudioOutput,
         cycleReceiverStyle,
         cycleSleepTimer,
         editingCountryFilter,
@@ -688,6 +816,8 @@ export function App({ store: providedStore, providers: providedProviders }) {
         lastSubmittedSearchRef,
         loadCountry,
         openAdjacentTab,
+        openAirPlayCode,
+        openAirPlaySettings,
         openScreen,
         playAdjacent,
         playStation,
@@ -696,6 +826,9 @@ export function App({ store: providedStore, providers: providedProviders }) {
         moveExploreCursor: moveExploreMapCursor,
         moveExploreCursorToCell: moveExploreMapCursorToCell,
         refreshProviderHealth,
+        refreshAirPlayTargets: () => {
+            void refreshAirPlayTargets();
+        },
         resetLearnedTransportKeys,
         runSearch,
         saveLearnedTransportKey,
@@ -703,16 +836,19 @@ 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,
@@ -743,6 +879,7 @@ export function App({ store: providedStore, providers: providedProviders }) {
         spinnerFrame
     });
     const pageFooter = pageFooterText({
+        canEnterAirPlayCode,
         capturingTransportAction,
         commandMode,
         commandText,
@@ -751,7 +888,7 @@ export function App({ store: providedStore, providers: providedProviders }) {
         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: `${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, 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 = [];
@@ -798,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,8 +10,11 @@ import { StationScreen } from './screens/StationScreen.js';
 import { NowPlayingScreen } from './screens/NowPlayingScreen.js';
 import { StatsScreen } from './screens/StatsScreen.js';
 import { SettingsScreen } from './screens/SettingsScreen.js';
+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, 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 }) {
+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 ", playbackBackendLabel(playback.backend)] }), _jsx(Text, { color: "gray", children: "q quit \u00B7 Ctrl+C always exits" })] }));
     }
@@ -42,5 +45,11 @@ export function AppContent({ airPlayDevices, backends, countryFilter, diagnostic
     if (screen === 'settings') {
         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: [],
@@ -92,20 +93,6 @@ export function nextPlaybackBackend(current) {
     const index = playbackBackendOptions.indexOf(current);
     return playbackBackendOptions[(index + 1) % playbackBackendOptions.length] ?? 'auto';
 }
-export function nextAirPlayDeviceId(current, devices) {
-    if (devices.length === 0) {
-        return undefined;
-    }
-    const ids = devices.map(device => device.id);
-    if (!current) {
-        return ids[0];
-    }
-    const index = ids.indexOf(current);
-    if (index === -1 || index === ids.length - 1) {
-        return undefined;
-    }
-    return ids[index + 1];
-}
 export function moveExploreCursor(cursor, direction, fast = false) {
     const latitudeStep = fast ? 6 : 1;
     const longitudeStep = fast ? 12 : 2;
@@ -152,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;
+}

package/dist/ui/page-footer.js

@@ -1,5 +1,5 @@
 import { mediaActionLabel } from './app-state.js';
-export function pageFooterText({ capturingTransportAction, commandMode, commandText, editingCountryFilter, editingSearch, playbackBackend, screen }) {
+export function pageFooterText({ capturingTransportAction, commandMode, commandText, editingCountryFilter, editingSearch, canEnterAirPlayCode, playbackBackend, screen }) {
     if (capturingTransportAction) {
         return `Learn ${mediaActionLabel(capturingTransportAction)} key: press key · Esc cancel`;
     }
@@ -42,7 +42,15 @@ export function pageFooterText({ capturingTransportAction, commandMode, commandT
         return 'space/F8 pause · f favorite · m mute · s sleep · d diagnostics · b home';
     }
     if (screen === 'settings') {
-        return 'Enter change selected · g Radio Garden · l location · x skip · o backend · a AirPlay · r health · b home';
+        return 'Enter change selected · g Radio Garden · l location · x skip · o output · a AirPlay · r health · b home';
+    }
+    if (screen === 'airplay-settings') {
+        return canEnterAirPlayCode
+            ? '↑/↓ choose · Enter select receiver · c code · r refresh · b settings'
+            : '↑/↓ choose · Enter select receiver · r refresh · b settings';
+    }
+    if (screen === 'airplay-code') {
+        return 'Type receiver code · Backspace edit · Enter submit · Esc AirPlay';
     }
     if (screen === 'stats') {
         return 'b home';

package/dist/ui/screen-items.js

@@ -6,15 +6,15 @@ export const homeItems = [
     { screen: 'countries', label: 'Countries', detail: 'Browse by country list with a world-map toggle' },
     { screen: 'nearby', label: 'Nearby', detail: 'Opt-in approximate location for local stations' },
     { screen: 'stats', label: 'Stats', detail: 'Listening graph, stations, streaks, hours' },
-    { screen: 'settings', label: 'Settings', detail: 'Playback backend, colors, providers' }
+    { screen: 'settings', label: 'Settings', detail: 'Audio output, colors, providers' }
 ];
 export const settingsItems = [
     'Cycle display color',
     'Cycle receiver style',
     'Toggle Radio Garden experimental adapter',
     'Toggle nearby location lookup',
-    'Cycle playback backend',
-    'Cycle AirPlay target',
+    'Audio output',
+    'AirPlay receiver',
     'Volume up',
     'Volume down',
     'Mute or unmute',

package/dist/ui/screens/AirPlayCodeScreen.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { ScreenHeader } from '../components/ScreenHeader.js';
+import { truncate } from '../format.js';
+import { textDim, themeAccent } from '../theme.js';
+export function AirPlayCodeScreen({ code, playback, selectedDevice, theme, width }) {
+    const accent = themeAccent(theme);
+    const lineWidth = Math.max(24, width - 4);
+    const promptActive = isAirPlayCodePromptActive(playback);
+    const receiverName = playback.airPlayDeviceName ?? selectedDevice?.name ?? 'selected receiver';
+    const masked = code.length > 0 ? '*'.repeat(code.length) : '';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ScreenHeader, { title: "AirPlay Code", subtitle: "Enter the code shown on the receiver", right: promptActive ? 'Waiting for code' : 'Not requested', width: width, theme: theme }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { color: "gray", children: ["Receiver: ", _jsx(Text, { color: accent, children: truncate(receiverName, Math.max(8, lineWidth - 10)) })] }), _jsxs(Text, { color: "gray", children: ["Playback: ", _jsx(Text, { color: accent, children: playback.backend }), " / ", playback.state] }), _jsx(Text, { color: promptActive ? accent : 'yellow', children: promptActive
+                            ? 'The receiver is asking for a code now.'
+                            : 'Tune a station with AirPlay first; this screen is used once the receiver asks for a code.' })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: "gray", bold: true, children: "Code" }), _jsx(Text, { color: code ? accent : textDim, children: code ? masked : 'type the code from the receiver' }), _jsx(Text, { color: textDim, children: "Enter submits \u00B7 Backspace edits \u00B7 Esc returns to AirPlay" })] })] }));
+}
+export function isAirPlayCodePromptActive(playback) {
+    return playback.backend === 'airplay' && playback.message === 'AirPlay code required. Use :airplay-code 1234.';
+}