@ciphore/radiocli 0.2.1 → 0.2.3

package/dist/ui/AppContent.js

@@ -14,15 +14,32 @@ import { AirPlaySettingsScreen } from './screens/AirPlaySettingsScreen.js';
 import { AirPlayCodeScreen } from './screens/AirPlayCodeScreen.js';
 import { selectedAirPlayDevice } from './airplay-settings.js';
 import { AdaptiveContent } from './AdaptiveContent.js';
-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 }) {
+import { AlarmsScreen, AlarmEditorScreen, AlarmPickerScreen, AlarmRingingScreen } from './screens/AlarmsScreen.js';
+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, searchQuery, screen, settingsPage, selected, showDiagnostics, sleepLabel, stationContext, stationFavorite, stationTime, storePath, theme, updateCheck, alarmTui }) {
     if (layout.compact) {
-        return (_jsx(AdaptiveContent, { mode: layout.mode === 'micro' ? 'micro' : 'compact', screen: screen, selected: selected, height: layout.contentRows, width: frameWidth, theme: theme, playback: playback, playingStation: playingStation, nowPlaying: nowPlaying, stations: displayStations, countries: filteredCountries, airPlayDevices: airPlayDevices, airPlayCode: airPlayCode, searchQuery: searchQuery, editingSearch: editingSearch, countryFilter: countryFilter, editingCountryFilter: editingCountryFilter, loadingCountries: loadingCountries, loadingStations: loadingStations, library: library, diagnostics: diagnostics, backends: backends, updateCheck: updateCheck, favoriteKeys: favoriteKeys, stationTitle: stationContext.title, filterLabel: filterLabel, pulse: pulse, sleepLabel: sleepLabel }));
+        if (screen === 'alarms')
+            return _jsx(AlarmsScreen, { alarms: library.alarms, selected: selected, runtime: alarmTui.runtime, verification: alarmTui.verification, deletingId: alarmTui.deletingId, busyAlarmIds: alarmTui.busyAlarmIds, theme: theme, width: frameWidth, height: layout.contentRows, mode: layout.mode });
+        if (screen === 'alarm-editor' && alarmTui.draft)
+            return _jsx(AlarmEditorScreen, { draft: alarmTui.draft, field: alarmTui.editorField, editing: alarmTui.editingField, control: alarmTui.editorControl, timeSegment: alarmTui.timeSegment, weekdayIndex: alarmTui.weekdayIndex, error: alarmTui.validationError, saving: alarmTui.saving, theme: theme, width: frameWidth, height: layout.contentRows });
+        if (screen === 'alarm-picker')
+            return _jsx(AlarmPickerScreen, { choices: alarmTui.pickerChoices, selected: selected, fallback: alarmTui.pickerFallback, theme: theme, width: frameWidth, height: layout.contentRows });
+        if (screen === 'alarm-ringing')
+            return _jsx(AlarmRingingScreen, { sessions: alarmTui.activeAlarms, alarms: library.alarms, selected: alarmTui.activeSelected, snoozeMinutes: alarmTui.snoozeMinutes, theme: theme, width: frameWidth, height: layout.contentRows });
+        return (_jsx(AdaptiveContent, { mode: layout.mode === 'micro' ? 'micro' : 'compact', screen: screen, settingsPage: settingsPage, selected: selected, height: layout.contentRows, width: frameWidth, theme: theme, playback: playback, playingStation: playingStation, nowPlaying: nowPlaying, stations: displayStations, countries: filteredCountries, airPlayDevices: airPlayDevices, airPlayCode: airPlayCode, searchQuery: searchQuery, editingSearch: editingSearch, countryFilter: countryFilter, editingCountryFilter: editingCountryFilter, loadingCountries: loadingCountries, loadingStations: loadingStations, exploreCursor: exploreCursor, library: library, diagnostics: diagnostics, backends: backends, updateCheck: updateCheck, appVersion: appVersion, favoriteKeys: favoriteKeys, stationTitle: stationContext.title, stationError: stationContext.error, filterLabel: filterLabel, sleepLabel: sleepLabel }));
     }
+    if (screen === 'alarms')
+        return _jsx(AlarmsScreen, { alarms: library.alarms, selected: selected, runtime: alarmTui.runtime, verification: alarmTui.verification, deletingId: alarmTui.deletingId, busyAlarmIds: alarmTui.busyAlarmIds, theme: theme, width: frameWidth, height: layout.contentRows, mode: layout.mode });
+    if (screen === 'alarm-editor' && alarmTui.draft)
+        return _jsx(AlarmEditorScreen, { draft: alarmTui.draft, field: alarmTui.editorField, editing: alarmTui.editingField, control: alarmTui.editorControl, timeSegment: alarmTui.timeSegment, weekdayIndex: alarmTui.weekdayIndex, error: alarmTui.validationError, saving: alarmTui.saving, theme: theme, width: frameWidth, height: layout.contentRows });
+    if (screen === 'alarm-picker')
+        return _jsx(AlarmPickerScreen, { choices: alarmTui.pickerChoices, selected: selected, fallback: alarmTui.pickerFallback, theme: theme, width: frameWidth, height: layout.contentRows });
+    if (screen === 'alarm-ringing')
+        return _jsx(AlarmRingingScreen, { sessions: alarmTui.activeAlarms, alarms: library.alarms, selected: alarmTui.activeSelected, snoozeMinutes: alarmTui.snoozeMinutes, theme: theme, width: frameWidth, height: layout.contentRows });
     if (screen === 'home') {
         return _jsx(HomeScreen, { selected: selected, theme: theme, library: library });
     }
     if (screen === 'countries') {
-        return (_jsx(CountriesScreen, { countries: filteredCountries, selected: selected, loading: loadingCountries, filter: countryFilter, editingFilter: editingCountryFilter, theme: theme, pageSize: layout.countryRows, width: frameWidth }));
+        return (_jsx(CountriesScreen, { countries: filteredCountries, selected: selected, loading: loadingCountries, filter: countryFilter, editingFilter: editingCountryFilter, theme: theme, pageSize: layout.countryRows, width: frameWidth, reduceMotion: Boolean(library.settings.reduceMotion) }));
     }
     if (screen === 'map') {
         return (_jsx(MapScreen, { countries: filteredCountries, selected: selected, loading: loadingCountries, filter: countryFilter, editingFilter: editingCountryFilter, theme: theme, pageSize: layout.mapCountryRows, mode: layout.mapMode, width: frameWidth }));
@@ -31,19 +48,19 @@ export function AppContent({ airPlayDevices, airPlayCode, appVersion, backends,
         return (_jsx(SearchScreen, { query: searchQuery, editing: editingSearch, loading: loadingStations, stations: displayStations, selected: selected, theme: theme, favorites: favoriteKeys, experimentalOn: library.settings.enableRadioGarden, filterLabel: filterLabel, pageSize: Math.max(1, layout.contentRows - 8), width: frameWidth }));
     }
     if (screen === 'explore') {
-        return (_jsx(ExploreScreen, { title: stationContext.title, subtitle: stationContext.subtitle, stations: displayStations, selected: selected, loading: loadingStations, theme: theme, favorites: favoriteKeys, filterLabel: filterLabel, cursor: exploreCursor, pageSize: layout.stationRows, width: frameWidth, height: layout.contentRows }));
+        return (_jsx(ExploreScreen, { title: stationContext.title, subtitle: stationContext.subtitle, stations: displayStations, selected: selected, loading: loadingStations, error: stationContext.error, theme: theme, favorites: favoriteKeys, filterLabel: filterLabel, cursor: exploreCursor, pageSize: layout.stationRows, width: frameWidth, height: layout.contentRows }));
     }
     if (screen === 'nearby' || screen === 'stations' || screen === 'library') {
-        return (_jsx(StationScreen, { title: stationContext.title, subtitle: stationContext.subtitle, stations: displayStations, selected: selected, loading: loadingStations, theme: theme, favorites: favoriteKeys, filterLabel: filterLabel, pageSize: layout.stationRows, width: frameWidth }));
+        return (_jsx(StationScreen, { title: stationContext.title, subtitle: stationContext.subtitle, stations: displayStations, selected: selected, loading: loadingStations, error: stationContext.error, theme: theme, favorites: favoriteKeys, filterLabel: filterLabel, pageSize: layout.stationRows, width: frameWidth }));
     }
     if (screen === 'now-playing') {
-        return (_jsx(NowPlayingScreen, { station: playingStation, playback: playback, metadata: nowPlaying, theme: theme, favorite: stationFavorite, pulse: pulse, diagnostics: diagnostics, showDiagnostics: showDiagnostics, stationTime: stationTime, receiverStyle: library.settings.receiverStyle, trackHistory: library.trackHistory, width: layout.receiverWidth, height: layout.receiverRows }));
+        return (_jsx(NowPlayingScreen, { station: playingStation, playback: playback, metadata: nowPlaying, theme: theme, favorite: stationFavorite, diagnostics: diagnostics, showDiagnostics: showDiagnostics, stationTime: stationTime, receiverStyle: library.settings.receiverStyle, trackHistory: library.trackHistory, width: layout.receiverWidth, height: layout.receiverRows }));
     }
     if (screen === 'stats') {
         return _jsx(StatsScreen, { library: library, theme: theme, width: frameWidth, height: layout.contentRows });
     }
     if (screen === 'settings') {
-        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 }));
+        return (_jsx(SettingsScreen, { page: settingsPage, 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, height: layout.contentRows }));

package/dist/ui/adaptive-explore-layout.js

@@ -0,0 +1,47 @@
+export function adaptiveExploreFrameMetrics(mode, height) {
+    const safeHeight = Math.max(1, height);
+    const headerRows = mode === 'compact' && safeHeight >= 4 ? 2 : 1;
+    const headerGap = mode === 'compact' && safeHeight >= 5 ? 1 : 0;
+    return { headerRows, headerGap, bodyRows: Math.max(0, safeHeight - headerRows - headerGap) };
+}
+export function computeAdaptiveExploreLayout(mode, width, bodyRows) {
+    const safeWidth = Math.max(1, width);
+    const safeRows = Math.max(1, bodyRows);
+    // Compact/mini always keeps the map and list side-by-side. Only true micro
+    // stacks stations below the map.
+    const split = mode === 'compact';
+    if (split) {
+        const gap = 1;
+        const mapAreaWidth = Math.min(Math.max(1, safeWidth - 7), Math.max(24, Math.floor(safeWidth * 0.62)));
+        const listWidth = Math.max(1, safeWidth - mapAreaWidth - gap);
+        const mapRows = safeRows;
+        const mapColumns = Math.max(1, Math.min(mapAreaWidth, mapRows * 4));
+        return {
+            split,
+            mapAreaWidth,
+            mapColumns,
+            mapRows,
+            mapOffsetX: Math.max(0, Math.floor((mapAreaWidth - mapColumns) / 2)),
+            listWidth,
+            listRows: safeRows,
+            gap
+        };
+    }
+    // True micro stacks a detailed map above a height-aware list. Reserve one,
+    // two, or three station rows as space permits while leaving most of the
+    // viewport available to the map.
+    const listRows = Math.min(3, Math.max(1, Math.floor(safeRows / 3)));
+    const gap = 0;
+    const mapRows = Math.max(1, safeRows - listRows - gap);
+    const mapColumns = Math.max(1, Math.min(safeWidth, mapRows * 4));
+    return {
+        split,
+        mapAreaWidth: safeWidth,
+        mapColumns,
+        mapRows,
+        mapOffsetX: Math.max(0, Math.floor((safeWidth - mapColumns) / 2)),
+        listWidth: safeWidth,
+        listRows,
+        gap
+    };
+}

package/dist/ui/alarm-editor.js

@@ -0,0 +1,174 @@
+import { nextAlarmOccurrence } from '../alarms/schedule.js';
+export const alarmEditorFields = [
+    'label', 'enabled', 'station', 'scheduleType', 'date', 'time', 'weekdays', 'timezone',
+    'volume', 'fadeSeconds', 'stopAfterMinutes', 'fallbackStation', 'output',
+    'missedRunGraceMinutes', 'wakeIfSupported', 'keepAwakeUntilAlarm', 'preview', 'save', 'cancel'
+];
+export const alarmTextFields = new Set([
+    'label', 'date', 'timezone'
+]);
+export function adjustTime(value, segment, direction) {
+    const match = /^(\d{2}):(\d{2})$/.exec(value);
+    const hour = match ? Number(match[1]) : 0;
+    const minute = match ? Number(match[2]) : 0;
+    const nextHour = segment === 'hour' ? wrap(hour + direction, 24) : hour;
+    const nextMinute = segment === 'minute' ? wrap(minute + direction, 60) : minute;
+    return `${String(nextHour).padStart(2, '0')}:${String(nextMinute).padStart(2, '0')}`;
+}
+export function toggleWeekday(value, weekday) {
+    const selected = new Set(parseWeekdayValues(value));
+    if (selected.has(weekday)) {
+        if (selected.size > 1)
+            selected.delete(weekday);
+    }
+    else
+        selected.add(weekday);
+    return [...selected].sort((left, right) => left - right).join(',');
+}
+export function defaultAlarmDraft(station, now = new Date()) {
+    const future = new Date(now.getTime() + 5 * 60_000);
+    future.setSeconds(0, 0);
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+    return {
+        label: station ? `Wake to ${station.name}` : 'Morning radio',
+        enabled: true,
+        station,
+        scheduleType: 'recurring',
+        date: localDate(future),
+        time: localTime(future),
+        weekdays: '1,2,3,4,5',
+        timezone,
+        volume: '70',
+        fadeSeconds: '30',
+        stopAfterMinutes: '60',
+        missedRunGraceMinutes: '15',
+        wakeIfSupported: true,
+        keepAwakeUntilAlarm: false
+    };
+}
+export function draftFromAlarm(alarm) {
+    const once = alarm.schedule.type === 'once' ? new Date(alarm.schedule.at) : undefined;
+    return {
+        id: alarm.id,
+        label: alarm.label,
+        enabled: alarm.enabled,
+        station: alarm.station,
+        scheduleType: alarm.schedule.type,
+        date: once ? localDate(once) : localDate(new Date()),
+        time: alarm.schedule.type === 'once' ? localTime(once) : alarm.schedule.time,
+        weekdays: alarm.schedule.type === 'recurring' ? alarm.schedule.weekdays.join(',') : '1,2,3,4,5',
+        timezone: alarm.schedule.type === 'recurring' ? alarm.schedule.timezone : Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC',
+        volume: String(alarm.playback.volume),
+        fadeSeconds: String(alarm.playback.fadeSeconds),
+        stopAfterMinutes: String(alarm.playback.stopAfterMinutes),
+        fallbackStation: alarm.playback.fallbackStation,
+        missedRunGraceMinutes: String(alarm.reliability.missedRunGraceMinutes),
+        wakeIfSupported: alarm.reliability.wakeIfSupported,
+        keepAwakeUntilAlarm: Boolean(alarm.reliability.keepAwakeUntilAlarm)
+    };
+}
+export function validateAlarmDraft(draft, now = new Date()) {
+    try {
+        alarmInputFromDraft(draft, now);
+        return null;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+export function alarmInputFromDraft(draft, now = new Date()) {
+    const label = draft.label.trim();
+    if (!label)
+        throw new Error('Label is required.');
+    if (!draft.station)
+        throw new Error('Choose a primary station.');
+    const volume = integer(draft.volume, 'Volume', 0, 100);
+    const fadeSeconds = integer(draft.fadeSeconds, 'Fade', 0, 3600);
+    const stopAfterMinutes = integer(draft.stopAfterMinutes, 'Stop after', 1, 10080);
+    const missedRunGraceMinutes = integer(draft.missedRunGraceMinutes, 'Missed grace', 0, 10080);
+    const schedule = draft.scheduleType === 'once'
+        ? { type: 'once', at: onceInstant(draft.date, draft.time, canonicalTimezone(draft.timezone)) }
+        : {
+            type: 'recurring',
+            time: canonicalTime(draft.time),
+            weekdays: parseWeekdays(draft.weekdays),
+            timezone: canonicalTimezone(draft.timezone)
+        };
+    if (schedule.type === 'once' && new Date(schedule.at).getTime() <= now.getTime())
+        throw new Error('One-time alarm must be in the future.');
+    return {
+        label,
+        enabled: draft.enabled,
+        station: draft.station,
+        schedule,
+        playback: { volume, fadeSeconds, stopAfterMinutes, ...(draft.fallbackStation ? { fallbackStation: draft.fallbackStation } : {}) },
+        reliability: { missedRunGraceMinutes, wakeIfSupported: draft.wakeIfSupported, keepAwakeUntilAlarm: draft.keepAwakeUntilAlarm }
+    };
+}
+export function draftNextOccurrence(draft, now = new Date()) {
+    try {
+        return nextAlarmOccurrence(alarmInputFromDraft({ ...draft, enabled: true }, new Date(0)).schedule, now);
+    }
+    catch {
+        return null;
+    }
+}
+export function cycleWeekdays(value, direction) {
+    const presets = ['1,2,3,4,5', '6,7', '1,2,3,4,5,6,7'];
+    const index = presets.indexOf(value);
+    return presets[(index < 0 ? 0 : index + direction + presets.length) % presets.length];
+}
+function parseWeekdays(value) {
+    const days = [...new Set(value.split(',').map(part => Number(part.trim())))].sort((a, b) => a - b);
+    if (!days.length || days.some(day => !Number.isInteger(day) || day < 1 || day > 7))
+        throw new Error('Weekdays use 1–7 (Monday–Sunday), separated by commas.');
+    return days;
+}
+function parseWeekdayValues(value) {
+    return value.split(',').map(Number).filter(day => Number.isInteger(day) && day >= 1 && day <= 7);
+}
+function wrap(value, size) { return ((value % size) + size) % size; }
+function canonicalTime(value) { if (!/^([01]\d|2[0-3]):[0-5]\d$/.test(value))
+    throw new Error('Time must use 24-hour HH:mm.'); return value; }
+function canonicalTimezone(value) { try {
+    return new Intl.DateTimeFormat('en-US', { timeZone: value.trim() }).resolvedOptions().timeZone;
+}
+catch {
+    throw new Error('Enter a valid IANA timezone, such as America/Los_Angeles.');
+} }
+function onceInstant(date, time, timezone) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(date);
+    if (!match)
+        throw new Error('Date must use YYYY-MM-DD.');
+    canonicalTime(time);
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const normalized = new Date(Date.UTC(year, month - 1, day));
+    if (normalized.getUTCFullYear() !== year || normalized.getUTCMonth() + 1 !== month || normalized.getUTCDate() !== day)
+        throw new Error('Enter a real calendar date.');
+    const [hour, minute] = time.split(':').map(Number);
+    const estimate = Date.UTC(year, month - 1, day, hour, minute);
+    const formatter = civilFormatter(timezone);
+    const probes = [estimate - 48 * 60 * 60_000, estimate, estimate + 48 * 60 * 60_000];
+    const offsets = new Set(probes.map(timestamp => timezoneOffsetAt(timestamp, formatter)));
+    const candidates = [...offsets].map(offset => new Date(estimate - offset)).filter(candidate => {
+        const parts = civilParts(candidate, formatter);
+        return parts.year === year && parts.month === month && parts.day === day && parts.hour === hour && parts.minute === minute;
+    }).sort((left, right) => left.getTime() - right.getTime());
+    if (candidates.length === 0)
+        throw new Error('That local time does not exist because of a daylight-saving transition. Choose another time.');
+    if (candidates.length > 1)
+        throw new Error('That local time occurs twice because of a daylight-saving transition. Choose an unambiguous time.');
+    return candidates[0].toISOString();
+}
+function civilFormatter(timezone) { return new Intl.DateTimeFormat('en-CA', { timeZone: timezone, year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', hourCycle: 'h23' }); }
+function civilParts(date, formatter) {
+    const values = Object.fromEntries(formatter.formatToParts(date).filter(part => part.type !== 'literal').map(part => [part.type, Number(part.value)]));
+    return { year: values.year ?? 0, month: values.month ?? 0, day: values.day ?? 0, hour: values.hour ?? 0, minute: values.minute ?? 0 };
+}
+function timezoneOffsetAt(timestamp, formatter) { const parts = civilParts(new Date(timestamp), formatter); return Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute) - timestamp; }
+function integer(value, label, min, max) { const number = Number(value); if (!Number.isInteger(number) || number < min || number > max)
+    throw new Error(`${label} must be ${min}–${max}.`); return number; }
+function localDate(date) { return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`; }
+function localTime(date) { return `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`; }

package/dist/ui/alarm-tui-service.js

@@ -0,0 +1,84 @@
+import { connectActiveAlarms } from '../alarms/active-session.js';
+import { createSchedulerService } from '../alarms/scheduler.js';
+import { prepareAlarmTerminalAccess } from '../alarms/terminal-launcher.js';
+import { verifyAlarmSetup } from '../alarms/setup-verification.js';
+export function createAlarmTuiService() {
+    const scheduler = createSchedulerService();
+    return serializeAlarmTuiService({
+        sync: alarm => scheduler.sync(alarm),
+        syncAll: alarms => scheduler.syncAll(alarms),
+        async remove(alarm) {
+            await scheduler.sync({ ...alarm, enabled: false });
+            scheduler.health.remove(alarm.id);
+        },
+        async runtimeStatus(alarms) {
+            const result = await scheduler.runtimeStatus(alarms);
+            const degraded = actionableDegradedAlarmIds(result.alarms);
+            const capabilities = result.capabilities;
+            return {
+                capabilities,
+                degradedAlarmIds: degraded,
+                message: capabilities.supported
+                    ? degraded.size ? `${degraded.size} alarm${degraded.size === 1 ? '' : 's'} need repair.` : 'Native scheduler ready.'
+                    : capabilities.message
+            };
+        },
+        async activeAlarms() {
+            const clients = await connectActiveAlarms();
+            const statuses = await Promise.allSettled(clients.map(async (client) => ({ client, status: await client.status() })));
+            return statuses.flatMap(result => result.status === 'fulfilled' ? [activeView(result.value.client, result.value.status)] : []);
+        },
+        prepareTerminalAccess: () => prepareAlarmTerminalAccess(),
+        verifySetup: (alarm, settings, onUpdate) => verifyAlarmSetup(scheduler, alarm, settings, onUpdate)
+    });
+}
+export function actionableDegradedAlarmIds(items) {
+    const degraded = new Set();
+    for (const item of items) {
+        const latestScheduler = latest(item.health.filter(entry => entry.component === 'scheduler' && !entry.occurrenceAt));
+        const latestGuard = latest(item.health.filter(entry => entry.component === 'power' && !entry.occurrenceAt));
+        if (!item.native.healthy || latestScheduler?.healthy === false || latestGuard?.healthy === false)
+            degraded.add(item.alarmId);
+    }
+    return degraded;
+}
+function latest(entries) { return entries.sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt))[0]; }
+/** Serializes every mutation for one alarm while preserving concurrency across alarms. */
+export function serializeAlarmTuiService(service) {
+    const queues = new Map();
+    const enqueue = (alarmId, work) => {
+        const previous = queues.get(alarmId) ?? Promise.resolve();
+        const current = previous.catch(() => undefined).then(work);
+        queues.set(alarmId, current);
+        void current.finally(() => { if (queues.get(alarmId) === current)
+            queues.delete(alarmId); }).catch(() => undefined);
+        return current;
+    };
+    return {
+        sync: alarm => enqueue(alarm.id, () => service.sync(alarm)),
+        syncAll: alarms => alarms.length === 0 ? service.syncAll([]) : Promise.all(alarms.map(alarm => enqueue(alarm.id, async () => {
+            try {
+                const [result] = await service.syncAll([alarm]);
+                return result ?? { id: alarm.id, occurrence: null, error: 'Alarm sync returned no result.' };
+            }
+            catch (error) {
+                return { id: alarm.id, occurrence: null, error: error instanceof Error ? error.message : String(error) };
+            }
+        }))),
+        remove: alarm => enqueue(alarm.id, () => service.remove(alarm)),
+        runtimeStatus: alarms => service.runtimeStatus(alarms),
+        activeAlarms: () => service.activeAlarms(),
+        prepareTerminalAccess: () => service.prepareTerminalAccess?.() ?? Promise.resolve(),
+        verifySetup: service.verifySetup ? (alarm, settings, onUpdate) => service.verifySetup(alarm, settings, onUpdate) : undefined
+    };
+}
+function activeView(client, status) {
+    return {
+        key: `${status.alarmId}:${status.scheduledAt}`,
+        status,
+        dismiss: () => client.dismiss(),
+        snooze: minutes => client.snooze(minutes),
+        keepPlaying: () => client.keepPlaying(),
+        handoff: () => client.handoff()
+    };
+}

package/dist/ui/app-state.js

@@ -158,6 +158,9 @@ export function activeTabForScreen(screen) {
     if (screen === 'airplay-settings' || screen === 'airplay-code') {
         return 'settings';
     }
+    if (screen === 'alarms' || screen === 'alarm-editor' || screen === 'alarm-picker' || screen === 'alarm-ringing') {
+        return 'home';
+    }
     return screen;
 }
 export function stationContextKeyForScreen(screen) {

package/dist/ui/ascii.js

@@ -97,6 +97,14 @@ function asciiGlyph(code) {
     if (code === 0x2014 || code === 0x2013) {
         return '-';
     }
+    if (code === 0x203a || code === 0x2192)
+        return '>';
+    if (code === 0x2039 || code === 0x2190)
+        return '<';
+    if (code === 0x2191)
+        return '^';
+    if (code === 0x2193)
+        return 'v';
     // Drop zero-width and combining marks entirely so they do not skew widths.
     if (code === 0x200b || code === 0xfeff || (code >= 0x0300 && code <= 0x036f)) {
         return '';

package/dist/ui/components/AdaptiveMarquee.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Text } from 'ink';
+import { displayWidth, sliceDisplay, truncate } from '../format.js';
+const edgePauseMs = 1000;
+const stepMs = 180;
+export function AdaptiveMarquee({ text, width, active, reduceMotion }) {
+    const safeWidth = Math.max(0, width);
+    const maxOffset = Math.max(0, displayWidth(text) - safeWidth);
+    const animated = active && !reduceMotion && maxOffset > 0;
+    const [offset, setOffset] = useState(0);
+    useEffect(() => {
+        setOffset(0);
+    }, [active, reduceMotion, safeWidth, text]);
+    useEffect(() => {
+        if (!animated)
+            return;
+        const delay = offset === 0 || offset >= maxOffset ? edgePauseMs : stepMs;
+        const timer = setTimeout(() => {
+            setOffset(current => current >= maxOffset ? 0 : current + 1);
+        }, delay);
+        return () => clearTimeout(timer);
+    }, [animated, maxOffset, offset]);
+    const visible = animated
+        ? sliceDisplay(text, Math.min(offset, maxOffset), safeWidth)
+        : truncate(text, safeWidth);
+    return _jsx(Text, { children: visible });
+}

package/dist/ui/components/StationList.js

@@ -1,10 +1,13 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-import { displayWidth, stationLocation, stationTags, stationTech, truncate } from '../format.js';
+import { stationLocation, stationTags, stationTech, truncate } from '../format.js';
 import { textMuted, themeAccent } from '../theme.js';
 import { Menu, Pointer } from './Menu.js';
 import { visibleWindow } from '../list-window.js';
+import { useDisplay } from '../display-context.js';
+import { AdaptiveMarquee } from './AdaptiveMarquee.js';
 export function StationList({ stations, selected, theme, favorites, pageSize, width, emptyTitle = 'No stations found.', emptyHint = 'Try another view or clear active filters.', showCount = true }) {
+    const { reduceMotion } = useDisplay();
     if (stations.length === 0) {
         return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: textMuted, children: emptyTitle }), _jsx(Text, { color: textMuted, children: emptyHint })] }));
     }
@@ -14,12 +17,14 @@ export function StationList({ stations, selected, theme, favorites, pageSize, wi
     const metaWidth = Math.max(12, rowWidth - nameWidth - 6);
     return (_jsxs(Box, { flexDirection: "column", children: [showCount ? (_jsxs(Text, { color: textMuted, children: [window.start + 1, "-", window.end, " of ", stations.length] })) : null, _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);
+                    if (width < 42) {
+                        const compactNameWidth = Math.max(1, width - 2 - (favorite ? 2 : 0));
+                        return (_jsxs(Box, { children: [_jsx(Pointer, { active: active }), _jsx(Text, { color: active ? themeAccent(theme) : undefined, bold: active, children: _jsx(AdaptiveMarquee, { text: station.name, width: compactNameWidth, active: active, reduceMotion: reduceMotion }) }), favorite ? _jsx(Text, { color: "yellow", children: " \u2605" }) : null] }));
+                    }
+                    const stationNameWidth = favorite ? Math.max(1, nameWidth - 2) : nameWidth;
                     const titleWidth = nameWidth + 2;
-                    const titleUsed = displayWidth(stationName) + (favorite ? 2 : 0);
-                    const titlePadding = ' '.repeat(Math.max(1, titleWidth - titleUsed));
                     const standardMetadata = `${stationLocation(station)} · ${stationTech(station)}`;
                     const selectedMetadata = station.tags.length > 0 ? stationTags(station) : standardMetadata;
-                    return (_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: active ? themeAccent(theme) : textMuted, children: truncate(active ? selectedMetadata : standardMetadata, metaWidth) })] }));
+                    return (_jsxs(Box, { children: [_jsx(Pointer, { active: active }), _jsxs(Box, { width: titleWidth, children: [_jsx(Box, { width: stationNameWidth, children: _jsx(Text, { color: active ? themeAccent(theme) : undefined, bold: active, children: _jsx(AdaptiveMarquee, { text: station.name, width: stationNameWidth, active: active, reduceMotion: reduceMotion }) }) }), favorite ? _jsx(Text, { color: "yellow", children: " \u2605" }) : null] }), _jsx(Text, { color: active ? themeAccent(theme) : textMuted, children: truncate(active ? selectedMetadata : standardMetadata, metaWidth) })] }));
                 } })] }));
 }

package/dist/ui/components/VersionIndicator.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { updateAvailableForVersion } from '../../update-check.js';
+import { displayWidth } from '../format.js';
+import { appBackground, textDim, themeAccent } from '../theme.js';
+export function availableUpdateLabel(currentVersion, updateCheck) {
+    return updateAvailableForVersion(updateCheck, currentVersion) && updateCheck?.latestVersion
+        ? `v${updateCheck.latestVersion} available`
+        : undefined;
+}
+export function versionIndicatorWidth(currentVersion, updateCheck) {
+    const versionWidth = displayWidth(`v${currentVersion}`);
+    const updateLabel = availableUpdateLabel(currentVersion, updateCheck);
+    return updateLabel ? displayWidth(updateLabel) + 3 + versionWidth : versionWidth;
+}
+export function VersionIndicator({ currentVersion, updateCheck, theme }) {
+    const updateLabel = availableUpdateLabel(currentVersion, updateCheck);
+    return (_jsxs(Box, { flexShrink: 0, children: [updateLabel ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: appBackground, backgroundColor: themeAccent(theme), bold: true, children: ` ${updateLabel} ` }), _jsx(Text, { children: " " })] })) : null, _jsx(Text, { color: textDim, children: `v${currentVersion}` })] }));
+}

package/dist/ui/cosmo-world-map.js

@@ -14,8 +14,11 @@ const brailleBits = [
 ];
 const mapCache = new Map();
 export function buildCosmoWorldMap(width, height, markers = []) {
-    const mapWidth = Math.max(40, Math.floor(width));
-    const mapHeight = Math.max(10, Math.floor(height));
+    // Layout owns minimum sizing. Keeping the renderer faithful to the requested
+    // viewport prevents clipped rows and mismatched mouse coordinates near
+    // responsive breakpoints.
+    const mapWidth = Math.max(1, Math.floor(width));
+    const mapHeight = Math.max(1, Math.floor(height));
     const rows = buildCosmoMapRows(mapWidth, mapHeight);
     const cells = rows.map(row => Array.from(row, char => ({
         char: char === brailleBlank ? ' ' : char,

package/dist/ui/explore-map-layout.js

@@ -4,12 +4,23 @@ export function computeExploreMapLayout(width, height, pageSize = 1) {
     // body margin below supplies the single gutter shared with the panel footer.
     const headerRows = 2;
     const bodyRows = Math.max(7, height - headerRows - 1);
-    const split = contentWidth >= 104 && bodyRows >= 10;
-    const listPanelWidth = split ? Math.max(50, Math.min(74, Math.floor(contentWidth * 0.35))) : contentWidth;
-    const mapPanelWidth = split ? Math.max(48, contentWidth - listPanelWidth - 1) : contentWidth;
-    const mapRows = split ? Math.max(8, bodyRows - 2) : Math.max(7, Math.min(14, Math.floor(bodyRows * 0.52)));
-    const mapColumns = Math.max(40, mapPanelWidth - 2);
-    const listRows = split ? bodyRows - 2 : Math.max(1, bodyRows - mapRows - 4);
+    // Every non-micro Explore layout is side-by-side. Preserve the established
+    // wide/full proportions, while giving narrower full layouts a useful map and
+    // a deliberately compact station column.
+    const split = true;
+    const listPanelWidth = contentWidth >= 104
+        ? Math.max(50, Math.min(74, Math.floor(contentWidth * 0.35)))
+        : Math.max(18, Math.floor(contentWidth * 0.35));
+    const mapPanelWidth = Math.max(1, contentWidth - listPanelWidth - 1);
+    const mapRows = Math.max(8, bodyRows - 2);
+    // A braille cell is two dots wide by four dots tall. With ordinary terminal
+    // cells roughly twice as tall as they are wide, a 2:1 world projection is
+    // represented by about four terminal columns per row. Use the panel as a
+    // viewport and center the map whenever filling it would stretch longitude.
+    const mapInnerWidth = Math.max(1, mapPanelWidth - 2);
+    const mapColumns = Math.max(1, Math.min(mapInnerWidth, mapRows * 4));
+    const mapOffsetX = Math.max(0, Math.floor((mapInnerWidth - mapColumns) / 2));
+    const listRows = bodyRows - 2;
     const listPageSize = Math.max(1, Math.min(pageSize, listRows - 3));
     return {
         contentWidth,
@@ -20,6 +31,7 @@ export function computeExploreMapLayout(width, height, pageSize = 1) {
         mapPanelWidth,
         mapRows,
         mapColumns,
+        mapOffsetX,
         listRows,
         listPageSize
     };

package/dist/ui/format.js

@@ -46,6 +46,27 @@ export function displayWidth(value) {
 export function padDisplayEnd(value, width) {
     return value + ' '.repeat(Math.max(0, width - displayWidth(value)));
 }
+export function sliceDisplay(value, start, length) {
+    const safeStart = Math.max(0, Math.floor(start));
+    const safeLength = Math.max(0, Math.floor(length));
+    if (safeLength === 0)
+        return '';
+    let skippedWidth = 0;
+    let outputWidth = 0;
+    let result = '';
+    for (const grapheme of graphemes(value)) {
+        const graphemeWidth = displayWidth(grapheme);
+        if (skippedWidth + graphemeWidth <= safeStart) {
+            skippedWidth += graphemeWidth;
+            continue;
+        }
+        if (outputWidth + graphemeWidth > safeLength)
+            break;
+        result += grapheme;
+        outputWidth += graphemeWidth;
+    }
+    return result;
+}
 export function removeLastGrapheme(value) {
     const parts = graphemes(value);
     parts.pop();

package/dist/ui/help-content.js

@@ -5,7 +5,7 @@ export const keyHelpSections = [
             { keys: '↑/↓ or n/p', description: 'Move selection' },
             { keys: '←/→ or Tab', description: 'Switch tabs' },
             { keys: '[ / ]', description: 'Page selection by 10' },
-            { keys: '1-8', description: 'Jump to an Overview option' },
+            { keys: '1-9', description: 'Jump to an Overview option' },
             { keys: 'Enter', description: 'Open / tune the selection' },
             { keys: 'b or Esc', description: 'Back to home' },
             { keys: ': ', description: 'Command palette' },
@@ -24,7 +24,19 @@ export const keyHelpSections = [
             { keys: 'O', description: 'Open station homepage' },
             { keys: 'y', description: 'Copy stream URL' },
             { keys: 's', description: 'Sleep timer (Now Playing)' },
-            { keys: 'd', description: 'Diagnostics + recent tracks (Now Playing)' }
+            { keys: 'd', description: 'Diagnostics + recent tracks (Now Playing)' },
+            { keys: 'a', description: 'Schedule the selected / playing station' },
+            { keys: '!', description: 'Open controls for a ringing alarm from any screen' }
+        ]
+    },
+    {
+        title: 'Alarms',
+        entries: [
+            { keys: 'Enter / n / e', description: 'Choose Create alarm, use the new shortcut, or edit the selected alarm' },
+            { keys: 'space', description: 'Enable / disable selected alarm' },
+            { keys: 'x twice', description: 'Confirm alarm deletion' },
+            { keys: 't / r / g', description: 'Test-tune / repair / toggle Alarm Guard' },
+            { keys: 'd / s / k', description: 'Dismiss / snooze / keep playing while ringing' }
         ]
     },
     {

package/dist/ui/layout.js

@@ -13,7 +13,7 @@ export function computeTerminalLayout(columns = 100, rows = 30, footerRows = 2)
     const desiredFooterRows = mode === 'full'
         ? clamp(Math.round(footerRows), 2, 4)
         : mode === 'compact'
-            ? (safeRows >= 14 ? 2 : 1)
+            ? (safeRows >= 14 ? 3 : 2)
             : 1;
     const reservedFooterRows = Math.min(desiredFooterRows, Math.max(0, safeRows - topRows - 1));
     const contentRows = Math.max(1, safeRows - reservedFooterRows - topRows);