@ciphore/radiocli 0.1.9 → 0.2.0

package/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-07-08
+
+### Added
+
+- Added update checks for npm releases, including a `radiocli update` command,
+  a `:update` command, and a Settings entry that reports the latest available
+  version and copies or runs the right npm or Homebrew update command.
+- Added lazy loading for long country station lists and search results, so
+  deeper directories continue loading as you scroll instead of stopping at the
+  first page.
+- Added mouse wheel scrolling across station, country, map, nearby, explore,
+  search, and library lists.
+
+### Changed
+
+- The footer now shows the installed RadioCLI version, and Settings includes
+  the current version beside update status.
+- Retuning now keeps the playback footer focused on the station currently
+  buffering, and mpv playback stays in loading until audio has actually started.
+
 ## [0.1.9] - 2026-07-03
 
 ### Changed
@@ -200,6 +220,7 @@ Initial public release.
 [0.1.7]: https://github.com/Ciphore/RadioCLI/releases/tag/v0.1.7
 [0.1.8]: https://github.com/Ciphore/RadioCLI/releases/tag/v0.1.8
 [0.1.9]: https://github.com/Ciphore/RadioCLI/releases/tag/v0.1.9
+[0.2.0]: https://github.com/Ciphore/RadioCLI/releases/tag/v0.2.0
 [0.1.4]: https://github.com/Ciphore/RadioCLI/releases/tag/v0.1.4
 [0.1.3]: https://github.com/Ciphore/RadioCLI/releases/tag/v0.1.3
 [0.1.2]: https://github.com/Ciphore/RadioCLI/releases/tag/v0.1.2

package/dist/cli.js

@@ -9,6 +9,7 @@ import { JsonLibraryStore } from './storage/store.js';
 import { parsePlaylistFile, stationFromUrl, writeM3u } from './playlists/playlist.js';
 import { detectPlaybackBackends, playbackBackendStatusLines } from './player/backend-install.js';
 import { appVersion } from './version.js';
+import { checkForUpdate, updateCommandForInstall } from './update-check.js';
 if (isDirectRun(process.argv[1], import.meta.url)) {
     const args = process.argv.slice(2);
     if (args.length > 0) {
@@ -47,6 +48,20 @@ export async function runCommand(args) {
         printPlaybackBackendStatus(backends);
         return;
     }
+    if (command === 'update') {
+        const updateCheck = await checkForUpdate();
+        const updateCommand = updateCommandForInstall();
+        if (updateCheck.error) {
+            console.log(`update_check=failed ${updateCheck.error}`);
+        }
+        else {
+            console.log(`installed=${appVersion()}`);
+            console.log(`latest=${updateCheck.latestVersion ?? 'unknown'}`);
+            console.log(`available=${updateCheck.updateAvailable ? 'yes' : 'no'}`);
+        }
+        console.log(`command=${updateCommand.command}`);
+        return;
+    }
     if (command === 'check') {
         const store = new JsonLibraryStore();
         const providers = new ProviderManager();
@@ -121,6 +136,7 @@ Usage:
   radiocli version         Print the installed version
   radiocli check           Show provider/backend health
   radiocli doctor          Show local playback setup guidance
+  radiocli update          Show update availability and install command
   radiocli countries       Print top countries
   radiocli search <query>  Search public stations
   radiocli import <file>   Import .m3u, .pls, or .xspf streams
@@ -140,7 +156,7 @@ export function isDirectRun(entryPath, moduleUrl) {
     }
 }
 function isKnownCommand(command) {
-    return ['check', 'doctor', 'countries', 'search', 'import', 'export', 'add-url'].includes(command);
+    return ['check', 'doctor', 'update', 'countries', 'search', 'import', 'export', 'add-url'].includes(command);
 }
 function printPlaybackBackendStatus(backends) {
     for (const line of playbackBackendStatusLines(backends)) {

package/dist/player/player-controller.js

@@ -10,6 +10,7 @@ import { discoverAirPlayDevices } from './airplay-discovery.js';
 import { airPlaySenderHealth } from './airplay-sender-health.js';
 import { encodeWorkerStart, parseWorkerMessage, serializeWorkerMessage } from './airplay-worker-protocol.js';
 const minAirPlayTuneTimeoutSeconds = 30;
+const mpvAudioStartFallbackMs = 1500;
 export class PlaybackOutputError extends Error {
     constructor(message) {
         super(message);
@@ -726,6 +727,7 @@ export class PlayerController {
     async waitForReady(backend) {
         const timeoutMs = this.getSettings().tuneTimeoutSeconds * 1000;
         const started = Date.now();
+        let mpvPathReadyAt = 0;
         while (Date.now() - started < timeoutMs) {
             if (!this.process) {
                 throw new Error('Player exited before the stream became ready.');
@@ -737,7 +739,13 @@ export class PlayerController {
             if (this.ipcPath) {
                 try {
                     await this.queryMpv({ command: ['get_property', 'path'] });
-                    return;
+                    mpvPathReadyAt = mpvPathReadyAt || Date.now();
+                    if (await this.hasMpvAudioStarted()) {
+                        return;
+                    }
+                    if (Date.now() - mpvPathReadyAt >= mpvAudioStartFallbackMs) {
+                        return;
+                    }
                 }
                 catch {
                     // The IPC socket can exist briefly before accepting commands.
@@ -748,6 +756,13 @@ export class PlayerController {
         await this.stop();
         throw new Error(`Timed out while opening stream after ${this.getSettings().tuneTimeoutSeconds}s.`);
     }
+    async hasMpvAudioStarted() {
+        const [timePos, audioPts] = await Promise.all([
+            this.queryMpv({ command: ['get_property', 'time-pos'] }).catch(() => null),
+            this.queryMpv({ command: ['get_property', 'audio-pts'] }).catch(() => null)
+        ]);
+        return typeof timePos === 'number' || typeof audioPts === 'number';
+    }
     startMpvMetadataPolling() {
         this.stopMpvPolling();
         this.metadataTimer = setInterval(() => {

package/dist/providers/provider-manager.js

@@ -13,8 +13,8 @@ export class ProviderManager {
     popular(limit) {
         return this.radioBrowser.popular(limit);
     }
-    byCountry(countryCode, limit) {
-        return this.radioBrowser.byCountry(countryCode, limit);
+    byCountry(countryCode, limit, offset) {
+        return this.radioBrowser.byCountry(countryCode, limit, offset);
     }
     nearby(location, limit) {
         return this.radioBrowser.nearby(location, limit);
@@ -24,7 +24,7 @@ export class ProviderManager {
     }
     async search(query, settings, options = {}) {
         const radioBrowser = await this.radioBrowser.search(query, options);
-        if (!settings.enableRadioGarden && !options.includeExperimental) {
+        if ((!settings.enableRadioGarden && !options.includeExperimental) || (options.offset ?? 0) > 0) {
             return radioBrowser;
         }
         const experimental = await Promise.allSettled([this.radioGarden.search(query, options)]);

package/dist/providers/radio-browser.js

@@ -87,11 +87,12 @@ export class RadioBrowserProvider {
         }, { maxAgeMs: 15 * 60 * 1000 });
         return this.normalizeStations(rows);
     }
-    async byCountry(countryCode, limit = 100) {
+    async byCountry(countryCode, limit = 100, offset = 0) {
         const rows = await this.request('/json/stations/search', {
             countrycode: countryCode.toUpperCase(),
             hidebroken: 'true',
             limit: String(limit),
+            offset: String(Math.max(0, offset)),
             order: 'clickcount',
             reverse: 'true'
         }, { maxAgeMs: 30 * 60 * 1000 });
@@ -106,6 +107,7 @@ export class RadioBrowserProvider {
         const baseParams = {
             hidebroken: 'true',
             limit: String(limit),
+            offset: String(Math.max(0, options.offset ?? 0)),
             order: 'clickcount',
             reverse: 'true',
             ...(options.codec ? { codec: options.codec } : {}),

package/dist/storage/store.js

@@ -172,6 +172,15 @@ const librarySchema = z.object({
     }))
         .default([]),
     searchHistory: z.array(z.string()).default([]),
+    updateCheck: z
+        .object({
+        checkedAt: z.string(),
+        currentVersion: z.string(),
+        latestVersion: z.string().optional(),
+        updateAvailable: z.boolean(),
+        error: z.string().optional()
+    })
+        .optional(),
     activity: z
         .object({
         sessions: z
@@ -220,6 +229,11 @@ export class JsonLibraryStore {
         this.write();
         return this.snapshot();
     }
+    updateCheckState(updateCheck) {
+        this.state = { ...this.state, updateCheck };
+        this.write();
+        return this.snapshot();
+    }
     addRecent(station) {
         const key = stationKey(station);
         const recent = [

package/dist/ui/App.js

@@ -22,12 +22,18 @@ import { isAirPlayCodePromptActive } from './screens/AirPlayCodeScreen.js';
 import { isAirPlayBackendAvailable } from './airplay-settings.js';
 import { audioOutputLabel, resolvedAudioOutput } from './audio-output.js';
 import { copyToClipboard, openExternal } from './system-actions.js';
+import { appVersion } from '../version.js';
+import { checkForUpdate, installUpdate, shouldCheckForUpdate, updateCommandForInstall } from '../update-check.js';
 import { activeTabForScreen, addMediaKeyBinding, applyStationFilters, clamp, clampVolume, defaultExploreCursor, formatExploreCursor, formatFilterLabel, formatTimeLeft, initialStationContexts, mediaActionLabel, moveExploreCursor as shiftExploreCursor, nextReceiverPulse, nextSleepTimerMinutes, normalizeMediaKeyBindings, shouldAnimateReceiver, shouldResetReceiverPulse, 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;
 const LOADING_SPINNER_MS = 120;
 const VISUALIZER_MESSAGE_MS = 4500;
+const COUNTRY_STATIONS_PAGE_SIZE = 120;
+const COUNTRY_STATIONS_LOAD_AHEAD = 12;
+const SEARCH_RESULTS_PAGE_SIZE = 90;
+const SEARCH_RESULTS_LOAD_AHEAD = 12;
 const settingToggleLabel = {
     resumeOnLaunch: 'Resume on launch',
     transparentBackground: 'Transparent background',
@@ -41,6 +47,7 @@ export function App({ store: providedStore, providers: providedProviders }) {
     const { columns, rows } = useWindowSize();
     const store = useMemo(() => providedStore ?? new JsonLibraryStore(), [providedStore]);
     const providers = useMemo(() => providedProviders ?? new ProviderManager(), [providedProviders]);
+    const installedVersion = useMemo(() => appVersion(), []);
     const [library, setLibrary] = useState(() => store.snapshot());
     const settingsRef = useRef(library.settings);
     settingsRef.current = library.settings;
@@ -74,9 +81,14 @@ export function App({ store: providedStore, providers: providedProviders }) {
     const [sleepUntil, setSleepUntil] = useState(null);
     const [showDiagnostics, setShowDiagnostics] = useState(false);
     const [capturingTransportAction, setCapturingTransportAction] = useState(null);
+    const announcedUpdateRef = useRef(false);
+    const installingUpdateRef = useRef(false);
     const displayStationsRef = useRef([]);
     const playbackQueueRef = useRef(null);
     const lastRawTransportAtRef = useRef(0);
+    const loadingStationsRef = useRef(false);
+    const countryPageRequestRef = useRef(null);
+    const searchPageRequestRef = useRef(null);
     const playStationRef = useRef(() => undefined);
     const screenRef = useRef(screen);
     const selectedRef = useRef(selected);
@@ -114,6 +126,7 @@ export function App({ store: providedStore, providers: providedProviders }) {
     }), [library, libraryStations, stationContexts]);
     screenRef.current = screen;
     selectedRef.current = selected;
+    loadingStationsRef.current = loadingStations;
     stationContextsRef.current = activeStationContexts;
     exploreCursorRef.current = exploreCursor;
     const renderedStationContextKey = stationContextKeyForScreen(screen);
@@ -179,14 +192,14 @@ export function App({ store: providedStore, providers: providedProviders }) {
         }
     }), [player, store]);
     useEffect(() => {
-        if (screen !== 'explore' || layout.compact || !stdout.isTTY) {
+        if (!stdout.isTTY) {
             return;
         }
         stdout.write(enableMouseReporting);
         return () => {
             stdout.write(disableMouseReporting);
         };
-    }, [layout.compact, screen, stdout]);
+    }, [stdout]);
     useEffect(() => {
         selectedByScreenRef.current[screen] = selected;
         if (renderedStationContextKey) {
@@ -283,6 +296,29 @@ export function App({ store: providedStore, providers: providedProviders }) {
     useEffect(() => {
         refreshProviderHealth();
     }, [refreshProviderHealth]);
+    const refreshUpdateCheck = useCallback(async () => {
+        const updateCheck = await checkForUpdate({ currentVersion: installedVersion });
+        setLibrary(store.updateCheckState(updateCheck));
+        return updateCheck;
+    }, [installedVersion, store]);
+    useEffect(() => {
+        if (!shouldCheckForUpdate(library.updateCheck)) {
+            return;
+        }
+        let cancelled = false;
+        void refreshUpdateCheck().then(updateCheck => {
+            if (cancelled) {
+                return;
+            }
+            if (updateCheck.updateAvailable && updateCheck.latestVersion && !announcedUpdateRef.current) {
+                announcedUpdateRef.current = true;
+                setMessage(`Update available: v${updateCheck.latestVersion} · run :update`);
+            }
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [library.updateCheck, refreshUpdateCheck]);
     const setStationContextFor = useCallback((key, context) => {
         setStationContexts(current => ({ ...current, [key]: context }));
     }, []);
@@ -433,12 +469,15 @@ export function App({ store: providedStore, providers: providedProviders }) {
     const loadCountry = useCallback(async (country) => {
         setLoadingStations(true);
         setMessage(null);
+        countryPageRequestRef.current = null;
         try {
-            const stations = await providers.byCountry(country.code, 120);
+            const stations = await providers.byCountry(country.code, COUNTRY_STATIONS_PAGE_SIZE, 0);
             showStationContext({
                 title: country.name,
-                subtitle: `${country.code} · ${country.stationCount.toLocaleString()} listed stations`,
-                stations
+                subtitle: formatCountryStationsSubtitle(country, stations.length, stations.length < country.stationCount),
+                stations,
+                country,
+                hasMore: stations.length >= COUNTRY_STATIONS_PAGE_SIZE && stations.length < country.stationCount
             }, 'stations');
         }
         catch (error) {
@@ -448,6 +487,61 @@ export function App({ store: providedStore, providers: providedProviders }) {
             setLoadingStations(false);
         }
     }, [providers, showStationContext]);
+    const loadMoreCountryStations = useCallback(async () => {
+        const context = stationContextsRef.current.stations;
+        const country = context.country;
+        if (!country || !context.hasMore || loadingStationsRef.current) {
+            return;
+        }
+        const offset = context.stations.length;
+        const requestKey = `${country.code}:${offset}`;
+        if (countryPageRequestRef.current === requestKey) {
+            return;
+        }
+        countryPageRequestRef.current = requestKey;
+        setLoadingStations(true);
+        try {
+            const page = await providers.byCountry(country.code, COUNTRY_STATIONS_PAGE_SIZE, offset);
+            const latest = stationContextsRef.current.stations;
+            if (latest.country?.code !== country.code || latest.stations.length !== offset) {
+                return;
+            }
+            const stations = appendUniqueStations(latest.stations, page);
+            const hasMore = page.length >= COUNTRY_STATIONS_PAGE_SIZE && stations.length < country.stationCount;
+            setStationContextFor('stations', {
+                ...latest,
+                subtitle: formatCountryStationsSubtitle(country, stations.length, hasMore),
+                stations,
+                hasMore
+            });
+        }
+        catch (error) {
+            if (stationContextsRef.current.stations.country?.code === country.code) {
+                setMessage(error instanceof Error ? error.message : `Could not load more ${country.name} stations.`);
+            }
+        }
+        finally {
+            if (countryPageRequestRef.current === requestKey) {
+                countryPageRequestRef.current = null;
+                setLoadingStations(false);
+            }
+        }
+    }, [providers, setStationContextFor]);
+    useEffect(() => {
+        if (screen === 'stations' &&
+            stationContexts.stations.country &&
+            stationContexts.stations.hasMore &&
+            stationContexts.stations.stations.length - selected <= COUNTRY_STATIONS_LOAD_AHEAD) {
+            void loadMoreCountryStations();
+        }
+    }, [
+        loadMoreCountryStations,
+        screen,
+        selected,
+        stationContexts.stations.country,
+        stationContexts.stations.hasMore,
+        stationContexts.stations.stations.length
+    ]);
     const runSearch = useCallback(async (query = searchQuery) => {
         if (!query.trim()) {
             setMessage('Enter a station, genre, language, or place.');
@@ -457,15 +551,18 @@ export function App({ store: providedStore, providers: providedProviders }) {
         setMessage(null);
         try {
             const stations = await providers.search(query, settingsRef.current, {
-                limit: 90,
+                limit: SEARCH_RESULTS_PAGE_SIZE,
+                offset: 0,
                 codec: filters.codec ?? undefined,
                 language: filters.language ?? undefined,
                 minBitrate: filters.minBitrate ?? undefined
             });
             setStationContextFor('search', {
                 title: `Search: ${query}`,
-                subtitle: 'Matches across enabled public station directories',
-                stations
+                subtitle: formatSearchSubtitle(stations.length, stations.length >= SEARCH_RESULTS_PAGE_SIZE),
+                stations,
+                query: query.trim(),
+                hasMore: stations.length >= SEARCH_RESULTS_PAGE_SIZE
             });
             selectedByScreenRef.current.search = 0;
             lastSubmittedSearchRef.current = query.trim();
@@ -481,6 +578,65 @@ export function App({ store: providedStore, providers: providedProviders }) {
             setLoadingStations(false);
         }
     }, [filters, providers, searchQuery, setStationContextFor, store]);
+    const loadMoreSearchResults = useCallback(async () => {
+        const context = stationContextsRef.current.search;
+        const query = context.query;
+        if (!query || !context.hasMore || loadingStationsRef.current) {
+            return;
+        }
+        const offset = context.stations.length;
+        const requestKey = `${query}:${offset}:${filters.codec ?? ''}:${filters.language ?? ''}:${filters.minBitrate ?? ''}`;
+        if (searchPageRequestRef.current === requestKey) {
+            return;
+        }
+        searchPageRequestRef.current = requestKey;
+        setLoadingStations(true);
+        try {
+            const page = await providers.search(query, settingsRef.current, {
+                limit: SEARCH_RESULTS_PAGE_SIZE,
+                offset,
+                codec: filters.codec ?? undefined,
+                language: filters.language ?? undefined,
+                minBitrate: filters.minBitrate ?? undefined
+            });
+            const latest = stationContextsRef.current.search;
+            if (latest.query !== query || latest.stations.length !== offset) {
+                return;
+            }
+            const stations = appendUniqueStations(latest.stations, page);
+            const hasMore = page.length >= SEARCH_RESULTS_PAGE_SIZE && stations.length > latest.stations.length;
+            setStationContextFor('search', {
+                ...latest,
+                subtitle: formatSearchSubtitle(stations.length, hasMore),
+                stations,
+                hasMore
+            });
+        }
+        catch (error) {
+            if (stationContextsRef.current.search.query === query) {
+                setMessage(error instanceof Error ? error.message : 'Could not load more search results.');
+            }
+        }
+        finally {
+            if (searchPageRequestRef.current === requestKey) {
+                searchPageRequestRef.current = null;
+                setLoadingStations(false);
+            }
+        }
+    }, [filters, providers, setStationContextFor]);
+    useEffect(() => {
+        if (screen === 'search' &&
+            stationContexts.search.hasMore &&
+            stationContexts.search.stations.length - selected <= SEARCH_RESULTS_LOAD_AHEAD) {
+            void loadMoreSearchResults();
+        }
+    }, [
+        loadMoreSearchResults,
+        screen,
+        selected,
+        stationContexts.search.hasMore,
+        stationContexts.search.stations.length
+    ]);
     const recallSearchHistory = useCallback((direction) => {
         const history = store.snapshot().searchHistory;
         if (history.length === 0) {
@@ -580,7 +736,6 @@ export function App({ store: providedStore, providers: providedProviders }) {
     }, []);
     const playStation = useCallback(async (station, options = {}) => {
         const queue = options.queue ?? queueFromCurrentList(station);
-        setMessage(`Tuning ${station.name}...`);
         setNowPlaying(null);
         try {
             const resolved = await providers.resolve(station);
@@ -901,6 +1056,55 @@ export function App({ store: providedStore, providers: providedProviders }) {
             openScreen(next.screen);
         }
     }, [openScreen, screen]);
+    const handleUpdateCommand = useCallback(async () => {
+        const updateCheck = library.updateCheck;
+        if (!updateCheck || shouldCheckForUpdate(updateCheck)) {
+            setMessage('Checking for updates...');
+            const latest = await refreshUpdateCheck();
+            if (latest.error) {
+                setMessage(`Update check failed: ${latest.error}`);
+                return;
+            }
+        }
+        const command = updateCommandForInstall();
+        const copied = copyToClipboard(command.command);
+        const latestVersion = store.snapshot().updateCheck?.latestVersion ?? updateCheck?.latestVersion;
+        const prefix = latestVersion ? `Latest v${latestVersion}. ` : '';
+        const method = command.method === 'homebrew' ? 'Homebrew' : command.method === 'npm' ? 'npm' : 'your install method';
+        setMessage(`${prefix}${copied ? 'Copied' : 'Run'} ${method} update: ${command.command}`);
+    }, [library.updateCheck, refreshUpdateCheck, store]);
+    const updateFromSettings = useCallback(async () => {
+        if (installingUpdateRef.current) {
+            setMessage('Update install already running.');
+            return;
+        }
+        const currentUpdateCheck = store.snapshot().updateCheck ?? library.updateCheck;
+        if (!currentUpdateCheck?.updateAvailable) {
+            setMessage('Checking for updates...');
+            const latest = await refreshUpdateCheck();
+            if (latest.error) {
+                setMessage(`Update check failed: ${latest.error}`);
+                return;
+            }
+            if (latest.updateAvailable && latest.latestVersion) {
+                setMessage(`Update available: v${latest.latestVersion}. Press Enter on Install update.`);
+                return;
+            }
+            setMessage(`RadioCLI is up to date at v${installedVersion}.`);
+            return;
+        }
+        const command = updateCommandForInstall();
+        installingUpdateRef.current = true;
+        setMessage(`Installing update with ${command.method === 'homebrew' ? 'Homebrew' : 'npm'}...`);
+        const result = await installUpdate(command.command);
+        installingUpdateRef.current = false;
+        if (result.ok) {
+            setMessage(`Update installed. Restart RadioCLI to use the new version.`);
+            return;
+        }
+        const detail = result.output ? ` ${result.output.split('\n').at(-1)}` : '';
+        setMessage(`Update install failed. Run manually: ${result.command}.${detail}`);
+    }, [installedVersion, library.updateCheck, refreshUpdateCheck, store]);
     const executeCommand = useCommandExecutor({
         beginLearningTransportKey,
         countries,
@@ -926,6 +1130,7 @@ export function App({ store: providedStore, providers: providedProviders }) {
         store,
         toggleFavorite,
         toggleMute,
+        updateCommand: handleUpdateCommand,
         updateSettings
     });
     const playAdjacent = useCallback((direction) => {
@@ -1018,7 +1223,8 @@ export function App({ store: providedStore, providers: providedProviders }) {
         toggleSetting,
         toggleNearbyLocation,
         toggleRadioGarden,
-        toggleSkipBrokenStreams
+        toggleSkipBrokenStreams,
+        updateFromSettings
     });
     function currentItemCount(currentScreen) {
         return itemCountsRef.current[currentScreen] ?? 0;
@@ -1049,7 +1255,7 @@ export function App({ store: providedStore, providers: providedProviders }) {
         playbackBackend: playback.backend,
         screen
     });
-    return (_jsx(DisplayContext.Provider, { value: displayMode, children: _jsxs(Box, { flexDirection: "column", paddingX: 1, height: layout.rows, width: layout.columns, overflow: "hidden", backgroundColor: displayMode.app, children: [hasTopTabs ? (_jsx(Box, { height: 3, marginBottom: 1, flexShrink: 0, backgroundColor: displayMode.app, 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: displayMode.app, 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 }), _jsx(Box, { height: 1, children: message ? _jsx(Text, { color: themeAccent(theme), children: truncate(message, frameWidth) }) : null })] }), _jsxs(Box, { height: layout.footerRows, width: frameWidth, flexDirection: "column", flexShrink: 0, backgroundColor: displayMode.app, children: [_jsx(Text, { color: themeAccent(theme), children: footerMessage ? truncate(footerMessage, frameWidth) : ' ' }), playbackFooter ? _jsx(Text, { color: themeAccent(theme), children: playbackFooter }) : null, _jsx(Text, { color: commandMode || capturingTransportAction ? themeAccent(theme) : textMuted, children: truncate(pageFooter, frameWidth) }), _jsx(Text, { color: textDim, children: truncate(globalFooter, frameWidth) })] })] }) }));
+    return (_jsx(DisplayContext.Provider, { value: displayMode, children: _jsxs(Box, { flexDirection: "column", paddingX: 1, height: layout.rows, width: layout.columns, overflow: "hidden", backgroundColor: displayMode.app, children: [hasTopTabs ? (_jsx(Box, { height: 3, marginBottom: 1, flexShrink: 0, backgroundColor: displayMode.app, 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: displayMode.app, children: [_jsx(AppContent, { airPlayDevices: availableAirPlayDevices, airPlayCode: airPlayCode, appVersion: installedVersion, 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, updateCheck: library.updateCheck }), _jsx(Box, { height: 1, children: message ? _jsx(Text, { color: themeAccent(theme), children: truncate(message, frameWidth) }) : null })] }), _jsxs(Box, { height: layout.footerRows, width: frameWidth, flexDirection: "column", flexShrink: 0, backgroundColor: displayMode.app, children: [_jsx(Text, { color: themeAccent(theme), children: footerMessage ? truncate(footerMessage, frameWidth) : ' ' }), playbackFooter ? _jsx(Text, { color: themeAccent(theme), children: playbackFooter }) : null, _jsx(Text, { color: commandMode || capturingTransportAction ? themeAccent(theme) : textMuted, children: truncate(pageFooter, frameWidth) }), _jsxs(Box, { children: [_jsx(Text, { color: textDim, children: truncate(globalFooter, Math.max(1, frameWidth - installedVersion.length - 3)) }), _jsx(Box, { flexGrow: 1 }), _jsxs(Text, { color: textDim, children: ["v", installedVersion] })] })] })] }) }));
 }
 function buildLibraryStations(library) {
     const stations = [];
@@ -1080,6 +1286,31 @@ function exploreCursorLocation(cursor) {
         source: 'explore cursor'
     };
 }
+function appendUniqueStations(current, page) {
+    const stations = [...current];
+    const seen = new Set(current.map(stationKey));
+    for (const station of page) {
+        const key = stationKey(station);
+        if (!seen.has(key)) {
+            seen.add(key);
+            stations.push(station);
+        }
+    }
+    return stations;
+}
+function formatCountryStationsSubtitle(country, loaded, hasMore) {
+    const total = country.stationCount.toLocaleString();
+    const loadedLabel = loaded.toLocaleString();
+    return hasMore
+        ? `${country.code} · ${loadedLabel} of ${total} listed stations loaded`
+        : `${country.code} · ${loadedLabel} of ${total} listed stations`;
+}
+function formatSearchSubtitle(loaded, hasMore) {
+    const count = loaded.toLocaleString();
+    return hasMore
+        ? `Matches across enabled public station directories · ${count}+ loaded`
+        : `Matches across enabled public station directories · ${count} loaded`;
+}
 function formatExploreSubtitle(cursor, stations) {
     if (stations.length === 0) {
         return `No geotagged stations near ${formatExploreCursor(cursor)}`;

package/dist/ui/AppContent.js

@@ -15,7 +15,7 @@ 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 }) {
+export function AppContent({ airPlayDevices, airPlayCode, appVersion, 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, updateCheck }) {
     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: textMuted, children: "Resize to at least 64x18 for the full receiver UI." }), _jsxs(Text, { color: textMuted, children: ["Playback: ", playback.state, " \u00B7 ", playbackBackendLabel(playback.backend)] }), _jsx(Text, { color: textMuted, children: "q quit \u00B7 Ctrl+C always exits" })] }));
     }
@@ -44,7 +44,7 @@ export function AppContent({ airPlayDevices, airPlayCode, backends, countryFilte
         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, airPlayDevices: airPlayDevices, providerHealth: providerHealth, theme: theme, diagnostics: diagnostics, width: frameWidth }));
+        return (_jsx(SettingsScreen, { selected: selected, settings: library.settings, appVersion: appVersion, updateCheck: updateCheck, storePath: storePath, playback: playback, backends: backends, airPlayDevices: airPlayDevices, providerHealth: providerHealth, theme: theme, diagnostics: diagnostics, width: frameWidth, height: layout.contentRows }));
     }
     if (screen === 'airplay-settings') {
         return (_jsx(AirPlaySettingsScreen, { selected: selected, settings: library.settings, backends: backends, devices: airPlayDevices, theme: theme, width: frameWidth }));

package/dist/ui/components/StationList.js

@@ -12,12 +12,12 @@ export function StationList({ stations, selected, theme, favorites, pageSize, wi
     const rowWidth = Math.max(42, width - 4);
     const nameWidth = Math.min(48, Math.max(18, Math.floor(rowWidth * 0.42)));
     const metaWidth = Math.max(12, rowWidth - nameWidth - 6);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: textMuted, children: ["Showing ", window.start + 1, "-", window.end, " of ", stations.length] }), _jsx(Menu, { items: window.items, selected: selected - window.start, keyFor: station => `${station.provider}:${station.id}`, render: (station, index, active) => {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: textMuted, children: ["Showing ", window.start + 1, "-", window.end, " of ", stations.length] }), _jsx(Menu, { items: window.items, selected: selected - window.start, keyFor: station => `${station.provider}:${station.id}`, render: (station, _index, active) => {
                     const favorite = favorites.has(`${station.provider}:${station.id}`);
                     const stationName = truncate(station.name, favorite ? Math.max(1, nameWidth - 2) : nameWidth);
                     const titleWidth = nameWidth + 2;
                     const titleUsed = stationName.length + (favorite ? 2 : 0);
                     const titlePadding = ' '.repeat(Math.max(1, titleWidth - titleUsed));
-                    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Pointer, { active: active }), _jsx(Text, { color: active ? themeAccent(theme) : undefined, bold: active, children: stationName }), favorite ? _jsx(Text, { color: "yellow", children: " \u2605" }) : null, _jsx(Text, { children: titlePadding }), _jsx(Text, { color: textMuted, children: truncate(`${stationLocation(station)} · ${stationTech(station)}`, metaWidth) })] }), active ? (_jsx(Box, { marginLeft: 4, children: _jsxs(Text, { color: textMuted, children: ["#", window.start + index + 1, " \u00B7 ", truncate(stationTags(station), rowWidth - 8)] }) })) : null] }));
+                    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Pointer, { active: active }), _jsx(Text, { color: active ? themeAccent(theme) : undefined, bold: active, children: stationName }), favorite ? _jsx(Text, { color: "yellow", children: " \u2605" }) : null, _jsx(Text, { children: titlePadding }), _jsx(Text, { color: textMuted, children: truncate(`${stationLocation(station)} · ${stationTech(station)}`, metaWidth) })] }), active ? (_jsx(Box, { marginLeft: 4, children: _jsx(Text, { color: textMuted, children: truncate(stationTags(station), rowWidth - 4) }) })) : null] }));
                 } })] }));
 }

package/dist/ui/help-content.js

@@ -66,6 +66,7 @@ export const commandHelp = [
     { name: 'map', description: 'Open the world map' },
     { name: 'stats', description: 'Open listening stats' },
     { name: 'settings', description: 'Open settings' },
+    { name: 'update', description: 'Show the install command for the latest release' },
     { name: 'stop', description: 'Stop playback' },
     { name: 'help', description: 'Open this help' }
 ];

package/dist/ui/playback-footer.js

@@ -16,7 +16,9 @@ export function shouldShowPlaybackFooter(station, playback) {
     return Boolean((station || playback.stationName) && visiblePlaybackStates.has(playback.state));
 }
 export function playbackFooterText({ station, playback, metadata, sleepLabel, width, spinnerFrame }) {
-    const stationName = station?.name ?? playback.stationName;
+    const stationName = playback.state === 'loading'
+        ? playback.stationName ?? station?.name
+        : station?.name ?? playback.stationName;
     if (!stationName || !visiblePlaybackStates.has(playback.state)) {
         return null;
     }

package/dist/ui/screen-items.js

@@ -23,6 +23,7 @@ export const settingsItems = [
     'Transparent background',
     'ASCII-safe display',
     'Reduce motion',
+    'Check for updates',
     'Refresh provider health',
     'Learn previous media key',
     'Learn play/pause media key',

package/dist/ui/screens/SettingsScreen.js

@@ -8,16 +8,35 @@ import { textMuted, themeAccent } from '../theme.js';
 import { playbackBackendCapabilities } from '../../player/backend-install.js';
 import { airPlayReceiverSettingValue } from '../airplay-settings.js';
 import { audioOutputLabel, audioOutputSettingValue } from '../audio-output.js';
-export function SettingsScreen({ selected, settings, storePath, playback, backends, airPlayDevices, providerHealth, theme, diagnostics, width }) {
+import { updateStatusText } from '../../update-check.js';
+export function SettingsScreen({ selected, settings, appVersion, updateCheck, storePath, playback, backends, airPlayDevices, providerHealth, theme, diagnostics, width, height }) {
     const accent = themeAccent(theme);
     const lineWidth = Math.max(32, width - 4);
     const health = Object.entries(providerHealth);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ScreenHeader, { title: "Settings", subtitle: "Enter changes the highlighted setting \u00B7 shortcuts in the footer", width: width, theme: theme }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(Menu, { items: settingsItems, selected: selected, keyFor: item => item, render: (item, _index, active) => {
-                        const value = settingValue(item, settings, diagnostics, backends, airPlayDevices);
-                        return (_jsxs(Box, { children: [_jsx(Pointer, { active: active }), _jsx(Text, { color: active ? accent : undefined, bold: active, children: item }), value ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: textMuted, children: " \u00B7 " }), _jsx(Text, { color: accent, children: value })] })) : null] }));
-                    } }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: textMuted, bold: true, children: "Status" }), _jsxs(Text, { color: textMuted, children: ["Output: ", _jsx(Text, { color: accent, children: audioOutputLabel(playback.backend) }), " / ", playback.state, " \u00B7", ' ', "Selected: ", _jsx(Text, { color: accent, children: audioOutputLabel(settings.preferredBackend) }), " \u00B7", ' ', diagnostics.muted ? 'muted' : `vol ${diagnostics.volume}`, " \u00B7 tune timeout ", settings.tuneTimeoutSeconds, "s"] }), _jsxs(Text, { color: textMuted, children: ["Provider health: ", health.length ? health.map(([provider, status]) => `${provider} ${status}`).join(' · ') : 'not checked yet'] }), _jsxs(Text, { color: textMuted, children: ["Active stream: ", truncate(diagnostics.streamUrl ?? 'none', lineWidth - 15)] }), _jsxs(Text, { color: textMuted, children: ["Library: ", truncate(storePath, lineWidth - 9)] })] })] }));
+    const menuWindow = settingsMenuWindow(selected, height);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ScreenHeader, { title: "Settings", subtitle: "Enter changes the highlighted setting \u00B7 shortcuts in the footer", width: width, theme: theme }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(Menu, { items: menuWindow.items, selected: selected - menuWindow.start, keyFor: ({ item }) => item, render: (item, _index, active) => {
+                        const label = settingLabel(item.item, updateCheck);
+                        const value = settingValue(item.item, settings, diagnostics, backends, airPlayDevices, updateCheck);
+                        return (_jsxs(Box, { children: [_jsx(Pointer, { active: active }), _jsx(Text, { color: active ? accent : undefined, bold: active, children: label }), value ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: textMuted, children: " \u00B7 " }), _jsx(Text, { color: accent, children: value })] })) : null] }));
+                    } }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: textMuted, bold: true, children: "Status" }), _jsxs(Text, { color: textMuted, children: ["Output: ", _jsx(Text, { color: accent, children: audioOutputLabel(playback.backend) }), " / ", playback.state, " \u00B7", ' ', "Selected: ", _jsx(Text, { color: accent, children: audioOutputLabel(settings.preferredBackend) }), " \u00B7", ' ', diagnostics.muted ? 'muted' : `vol ${diagnostics.volume}`, " \u00B7 tune timeout ", settings.tuneTimeoutSeconds, "s"] }), _jsxs(Text, { color: textMuted, children: ["Provider health: ", health.length ? health.map(([provider, status]) => `${provider} ${status}`).join(' · ') : 'not checked yet'] }), _jsxs(Text, { color: textMuted, children: ["Version: ", _jsxs(Text, { color: accent, children: ["v", appVersion] }), " \u00B7 Update: ", updateStatusText(updateCheck)] }), _jsxs(Text, { color: textMuted, children: ["Active stream: ", truncate(diagnostics.streamUrl ?? 'none', lineWidth - 15)] }), _jsxs(Text, { color: textMuted, children: ["Library: ", truncate(storePath, lineWidth - 9)] })] })] }));
 }
-function settingValue(item, settings, diagnostics, backends, airPlayDevices) {
+function settingsMenuWindow(selected, height) {
+    if (!height) {
+        return { start: 0, items: settingsItems.map(item => ({ item })) };
+    }
+    const reservedRows = 10;
+    const maxRows = Math.max(5, height - reservedRows);
+    if (settingsItems.length <= maxRows) {
+        return { start: 0, items: settingsItems.map(item => ({ item })) };
+    }
+    const clampedSelected = Math.min(Math.max(selected, 0), settingsItems.length - 1);
+    const start = Math.min(Math.floor(clampedSelected / maxRows) * maxRows, Math.max(0, settingsItems.length - maxRows));
+    return {
+        start,
+        items: settingsItems.slice(start, start + maxRows).map(item => ({ item }))
+    };
+}
+function settingValue(item, settings, diagnostics, backends, airPlayDevices, updateCheck) {
     switch (item) {
         case 'Cycle display color':
             return settings.theme;
@@ -46,9 +65,17 @@ function settingValue(item, settings, diagnostics, backends, airPlayDevices) {
             return settings.asciiMode ? 'on' : 'off';
         case 'Reduce motion':
             return settings.reduceMotion ? 'on' : 'off';
+        case 'Check for updates':
+            return updateStatusText(updateCheck);
         case 'Reset learned media keys':
             return `prev ${settings.mediaKeys.previous.length} · play ${settings.mediaKeys.playPause.length} · next ${settings.mediaKeys.next.length}`;
         default:
             return undefined;
     }
 }
+function settingLabel(item, updateCheck) {
+    if (item === 'Check for updates' && updateCheck?.updateAvailable) {
+        return 'Install update';
+    }
+    return item;
+}

package/dist/ui/screens/screen-render.test.js

@@ -61,13 +61,34 @@ const settings = {
 describe('SettingsScreen rendering', () => {
     it('renders the new display and playback toggles with their values', () => {
         const settingsIndex = Math.max(0, settingsItems.indexOf('Resume last station on launch'));
-        const { lastFrame } = render(_jsx(SettingsScreen, { selected: settingsIndex, settings: settings, storePath: "/tmp/radiocli.json", playback: playback, backends: ['mpv'], airPlayDevices: [], providerHealth: {}, theme: "green", diagnostics: diagnostics, width: 80 }));
+        const { lastFrame } = render(_jsx(SettingsScreen, { selected: settingsIndex, settings: settings, appVersion: "0.1.9", updateCheck: { checkedAt: '2026-07-07T00:00:00.000Z', currentVersion: '0.1.9', latestVersion: '0.1.9', updateAvailable: false }, storePath: "/tmp/radiocli.json", playback: playback, backends: ['mpv'], airPlayDevices: [], providerHealth: {}, theme: "green", diagnostics: diagnostics, width: 80 }));
         const frame = lastFrame() ?? '';
         expect(frame).toContain('Resume last station on launch');
         expect(frame).toContain('ASCII-safe display');
         expect(frame).toContain('Reduce motion');
         expect(frame).toContain('Transparent background');
     });
+    it('changes the update settings row when an update is available', () => {
+        const settingsIndex = Math.max(0, settingsItems.indexOf('Check for updates'));
+        const { lastFrame } = render(_jsx(SettingsScreen, { selected: settingsIndex, settings: settings, appVersion: "0.1.9", updateCheck: { checkedAt: '2026-07-07T00:00:00.000Z', currentVersion: '0.1.9', latestVersion: '0.1.10', updateAvailable: true }, storePath: "/tmp/radiocli.json", playback: playback, backends: ['mpv'], airPlayDevices: [], providerHealth: {}, theme: "green", diagnostics: diagnostics, width: 80 }));
+        const frame = lastFrame() ?? '';
+        expect(frame).toContain('Install update');
+        expect(frame).toContain('v0.1.10 available');
+    });
+    it('keeps the selected update row visible in a constrained Settings pane', () => {
+        const settingsIndex = Math.max(0, settingsItems.indexOf('Check for updates'));
+        const { lastFrame } = render(_jsx(SettingsScreen, { selected: settingsIndex, settings: settings, appVersion: "0.1.9", updateCheck: { checkedAt: '2026-07-07T00:00:00.000Z', currentVersion: '0.1.9', latestVersion: '0.1.9', updateAvailable: false }, storePath: "/tmp/radiocli.json", playback: playback, backends: ['mpv'], airPlayDevices: [], providerHealth: {}, theme: "green", diagnostics: diagnostics, width: 80, height: 18 }));
+        const frame = lastFrame() ?? '';
+        expect(frame).toContain('> Check for updates');
+    });
+    it('keeps Reduce motion visible between ASCII-safe display and update checks', () => {
+        const settingsIndex = Math.max(0, settingsItems.indexOf('Reduce motion'));
+        const { lastFrame } = render(_jsx(SettingsScreen, { selected: settingsIndex, settings: settings, appVersion: "0.1.9", updateCheck: { checkedAt: '2026-07-07T00:00:00.000Z', currentVersion: '0.1.9', latestVersion: '0.1.9', updateAvailable: false }, storePath: "/tmp/radiocli.json", playback: playback, backends: ['mpv'], airPlayDevices: [], providerHealth: {}, theme: "green", diagnostics: diagnostics, width: 80, height: 18 }));
+        const frame = lastFrame() ?? '';
+        expect(frame).toContain('  ASCII-safe display');
+        expect(frame).toContain('> Reduce motion');
+        expect(frame).toContain('  Check for updates');
+    });
 });
 function renderExplore(asciiMode) {
     const mode = resolveDisplayMode({ asciiMode }, {});

package/dist/ui/terminal-mouse.js

@@ -14,6 +14,21 @@ export function parseSgrMouseEvents(input) {
 export function primaryMousePress(events) {
     return events.find(event => event.pressed && (event.button & 3) === 0 && (event.button & 96) === 0) ?? null;
 }
+export function wheelScrollDelta(events) {
+    return events.reduce((delta, event) => {
+        if (!event.pressed) {
+            return delta;
+        }
+        const button = event.button & 127;
+        if (button === 64) {
+            return delta - 1;
+        }
+        if (button === 65) {
+            return delta + 1;
+        }
+        return delta;
+    }, 0);
+}
 export function exploreCursorForMouseCell(x, y, frameWidth, layout) {
     if (layout.compact) {
         return null;

package/dist/ui/use-app-input.js

@@ -2,9 +2,9 @@ import { useEffect } from 'react';
 import { useInput } from 'ink';
 import { homeItems, settingsItems } from './screen-items.js';
 import { applyTextInput, clamp, favoriteTarget, isEditableInput, isPlainPrintableInput, mediaTransportActionForInput, searchEditingArrowAction, shouldHandleKeyboardEvent, shouldToggleNearbyLocationShortcut } from './app-state.js';
-import { parseSgrMouseEvents, primaryMousePress } from './terminal-mouse.js';
+import { parseSgrMouseEvents, primaryMousePress, wheelScrollDelta } from './terminal-mouse.js';
 import { completeCommand } from './help-content.js';
-export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, beginLearningTransportKey, capturingTransportAction, commandMode, commandText, copyStationUrl, openStationHomepage, currentItemCount, cycleDisplayColor, cycleAudioOutput, cycleReceiverStyle, cycleSleepTimer, editingCountryFilter, editingSearch, executeCommand, filteredCountries, go, lastRawTransportAtRef, lastSubmittedSearchRef, loadCountry, openAdjacentTab, openAirPlayCode, openAirPlaySettings, openScreen, playAdjacent, playStation, player, playingStation, recallSearchHistory, moveExploreCursor, moveExploreCursorToCell, refreshAirPlayTargets, refreshProviderHealth, resetLearnedTransportKeys, runSearch, saveLearnedTransportKey, screen, searchQuery, selected, selectedStation, selectAirPlayDeviceAt, setCapturingTransportAction, setAirPlayCode, setCommandMode, setCommandText, setCountryFilter, setEditingCountryFilter, setEditingSearch, setMessage, setSearchQuery, setSelected, setShowDiagnostics, submitAirPlayCode, settingsRef, shutdown, stdin, toggleFavorite, toggleMute, togglePause, toggleSetting, toggleNearbyLocation, toggleRadioGarden, toggleSkipBrokenStreams }) {
+export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, beginLearningTransportKey, capturingTransportAction, commandMode, commandText, copyStationUrl, openStationHomepage, currentItemCount, cycleDisplayColor, cycleAudioOutput, cycleReceiverStyle, cycleSleepTimer, editingCountryFilter, editingSearch, executeCommand, filteredCountries, go, lastRawTransportAtRef, lastSubmittedSearchRef, loadCountry, openAdjacentTab, openAirPlayCode, openAirPlaySettings, openScreen, playAdjacent, playStation, player, playingStation, recallSearchHistory, moveExploreCursor, moveExploreCursorToCell, refreshAirPlayTargets, refreshProviderHealth, resetLearnedTransportKeys, runSearch, saveLearnedTransportKey, screen, searchQuery, selected, selectedStation, selectAirPlayDeviceAt, setCapturingTransportAction, setAirPlayCode, setCommandMode, setCommandText, setCountryFilter, setEditingCountryFilter, setEditingSearch, setMessage, setSearchQuery, setSelected, setShowDiagnostics, submitAirPlayCode, settingsRef, shutdown, stdin, toggleFavorite, toggleMute, togglePause, toggleSetting, toggleNearbyLocation, toggleRadioGarden, toggleSkipBrokenStreams, updateFromSettings }) {
     useEffect(() => {
         const onData = (data) => {
             const rawInput = String(data);
@@ -22,8 +22,13 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, be
             }
             const mouseEvents = parseSgrMouseEvents(rawInput);
             if (mouseEvents.length > 0) {
+                const wheelDelta = wheelScrollDelta(mouseEvents);
                 const click = primaryMousePress(mouseEvents);
                 lastRawTransportAtRef.current = Date.now();
+                if (wheelDelta !== 0 && shouldScrollSelectionWithWheel(screen, commandMode, editingCountryFilter)) {
+                    setSelected(value => clamp(value + wheelDelta * 3, currentItemCount(screen) - 1));
+                    return;
+                }
                 if (!commandMode && screen === 'explore' && click) {
                     moveExploreCursorToCell(click.x, click.y);
                 }
@@ -426,6 +431,9 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, be
                 else if (item === 'Reduce motion') {
                     toggleSetting('reduceMotion');
                 }
+                else if (item === 'Check for updates') {
+                    void updateFromSettings();
+                }
                 else if (item === 'Refresh provider health') {
                     refreshProviderHealth();
                     setMessage('Provider health refreshed.');
@@ -461,6 +469,12 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, be
         }
     });
 }
+function shouldScrollSelectionWithWheel(screen, commandMode, editingCountryFilter) {
+    if (commandMode || editingCountryFilter) {
+        return false;
+    }
+    return ['countries', 'map', 'stations', 'search', 'nearby', 'explore', 'library'].includes(screen);
+}
 function exploreMoveForInput(input) {
     const normalized = input.toLowerCase();
     if (normalized === 'w') {

package/dist/ui/use-command-executor.js

@@ -1,6 +1,6 @@
 import { useCallback } from 'react';
 import { favoriteTarget, normalizeMediaKeyBindings, parseMediaActionName } from './app-state.js';
-export function useCommandExecutor({ beginLearningTransportKey, countries, go, loadCountry, openAirPlaySettings, openLibrary, player, playingStation, providers, resetLearnedTransportKeys, runSearch, screen, selectedStation, setCountries, setFilters, setLibrary, setMessage, setSearchQuery, setSleepUntil, setVolume, settingsRef, store, toggleFavorite, toggleMute, updateSettings }) {
+export function useCommandExecutor({ beginLearningTransportKey, countries, go, loadCountry, openAirPlaySettings, openLibrary, player, playingStation, providers, resetLearnedTransportKeys, runSearch, screen, selectedStation, setCountries, setFilters, setLibrary, setMessage, setSearchQuery, setSleepUntil, setVolume, settingsRef, store, toggleFavorite, toggleMute, updateCommand, updateSettings }) {
     return useCallback(async (rawCommand) => {
         const trimmed = rawCommand.trim();
         if (!trimmed) {
@@ -136,6 +136,10 @@ export function useCommandExecutor({ beginLearningTransportKey, countries, go, l
             go('settings');
             return;
         }
+        if (name === 'update') {
+            await updateCommand();
+            return;
+        }
         if (name === 'stop') {
             setLibrary(store.finishActiveListeningSession());
             await player.stop();
@@ -189,6 +193,7 @@ export function useCommandExecutor({ beginLearningTransportKey, countries, go, l
         store,
         toggleFavorite,
         toggleMute,
+        updateCommand,
         updateSettings
     ]);
 }

package/dist/update-check.js

@@ -0,0 +1,122 @@
+import { realpathSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { appVersion } from './version.js';
+const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const UPDATE_PACKAGE_NAME = '@ciphore/radiocli';
+export async function checkForUpdate({ currentVersion = appVersion(), fetchImpl = fetch, now = new Date(), packageName = UPDATE_PACKAGE_NAME, timeoutMs = 3000 } = {}) {
+    try {
+        const response = await fetchWithTimeout(registryLatestUrl(packageName), fetchImpl, timeoutMs);
+        if (!response.ok) {
+            throw new Error(`npm registry returned ${response.status}`);
+        }
+        const parsed = await response.json();
+        const latestVersion = typeof parsed.version === 'string' ? parsed.version : undefined;
+        if (!latestVersion) {
+            throw new Error('npm registry response did not include a version');
+        }
+        return {
+            checkedAt: now.toISOString(),
+            currentVersion,
+            latestVersion,
+            updateAvailable: compareSemver(latestVersion, currentVersion) > 0
+        };
+    }
+    catch (error) {
+        return {
+            checkedAt: now.toISOString(),
+            currentVersion,
+            updateAvailable: false,
+            error: error instanceof Error ? error.message : 'Update check failed'
+        };
+    }
+}
+export function shouldCheckForUpdate(updateCheck, now = Date.now()) {
+    if (process.env.RADIOCLI_DISABLE_UPDATE_CHECK === '1' || process.env.CI === 'true') {
+        return false;
+    }
+    if (!updateCheck?.checkedAt) {
+        return true;
+    }
+    const checkedAt = Date.parse(updateCheck.checkedAt);
+    return !Number.isFinite(checkedAt) || now - checkedAt >= UPDATE_CHECK_INTERVAL_MS;
+}
+export function updateStatusText(updateCheck) {
+    if (!updateCheck) {
+        return 'not checked yet';
+    }
+    if (updateCheck.updateAvailable && updateCheck.latestVersion) {
+        return `v${updateCheck.latestVersion} available`;
+    }
+    if (updateCheck.error) {
+        return `check failed: ${updateCheck.error}`;
+    }
+    return updateCheck.latestVersion ? `current at v${updateCheck.latestVersion}` : 'not checked yet';
+}
+export function updateCommandForInstall(entryPath = process.argv[1]) {
+    const resolved = resolvePath(entryPath);
+    const haystack = [entryPath, resolved].filter(Boolean).join('\n');
+    if (/\/(?:opt\/homebrew|usr\/local)\/(?:Cellar|Homebrew)\//.test(haystack) || /\/\.linuxbrew\/(?:Cellar|Homebrew)\//.test(haystack)) {
+        return { method: 'homebrew', command: 'brew update && brew upgrade radiocli' };
+    }
+    if (/\/node_modules\/@ciphore\/radiocli\//.test(haystack)) {
+        return { method: 'npm', command: 'npm install -g @ciphore/radiocli@latest' };
+    }
+    return { method: 'unknown', command: 'npm install -g @ciphore/radiocli@latest' };
+}
+export function installUpdate(command = updateCommandForInstall().command) {
+    return new Promise(resolve => {
+        const shell = process.platform === 'win32' ? 'cmd.exe' : 'sh';
+        const args = process.platform === 'win32' ? ['/d', '/s', '/c', command] : ['-lc', command];
+        const child = spawn(shell, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        const chunks = [];
+        child.stdout.on('data', chunk => chunks.push(Buffer.from(chunk)));
+        child.stderr.on('data', chunk => chunks.push(Buffer.from(chunk)));
+        child.on('error', error => {
+            resolve({ ok: false, command, output: error.message });
+        });
+        child.on('close', code => {
+            const output = Buffer.concat(chunks).toString('utf8').trim();
+            resolve({ ok: code === 0, command, output });
+        });
+    });
+}
+export function compareSemver(left, right) {
+    const leftParts = semverParts(left);
+    const rightParts = semverParts(right);
+    for (let index = 0; index < 3; index += 1) {
+        const delta = leftParts[index] - rightParts[index];
+        if (delta !== 0) {
+            return delta;
+        }
+    }
+    return 0;
+}
+function registryLatestUrl(packageName) {
+    return `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
+}
+async function fetchWithTimeout(url, fetchImpl, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetchImpl(url, { signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function semverParts(version) {
+    const normalized = version.trim().replace(/^v/i, '').split(/[+-]/)[0] ?? '';
+    const [major = '0', minor = '0', patch = '0'] = normalized.split('.');
+    return [Number(major) || 0, Number(minor) || 0, Number(patch) || 0];
+}
+function resolvePath(path) {
+    if (!path) {
+        return undefined;
+    }
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return path;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ciphore/radiocli",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "description": "A terminal-first world radio receiver built with Ink, mpv, and resilient public-radio providers.",
   "type": "module",
   "license": "MIT",