Give a month chip back some of its width (#212)

The pinch clamped its lower bound to `ceil(fillPx)`. Rounding a fill height up
by the fraction of a pixel that 24 hours don't divide the viewport into makes
the timeline up to one pixel per hour taller than the viewport those hours are
supposed to fill — roughly 24px of leftover scroll, enough to bounce off
Android's overscroll stretch. `FitDay` resolves to the unrounded height and sits
still, so the two ways of reaching "the whole day on one screen" disagreed.
That inconsistency is what #290 is about.

Clamps to `fillPx` itself. The whole-pixel rounding exists so the hour gutter's
24 stacked boxes share a grid with the lines and blocks drawn at the fractional
height, and it still applies everywhere the pinch is free to move. The floor is
the one height where matching `FitDay` matters more — and because it is the
clamp *result* rather than a bound the gesture is merely held against, the pinch
lands on it exactly, so the next frame reads it back unchanged and the focal
anchor gets no correction to apply.

Week and Day both measure their viewport inside a `BoxWithConstraints` below the
all-day strip, so the strip appearing only changes the height both paths agree
on — that half of the report needed no change.

Tests: the two cases that encoded the old rounding are updated (the dead-space
invariant still holds, now exactly rather than by a pixel), plus one for the
reported symptom and one asserting the pinch floor equals what `FitDay`
resolves to at the same viewport.

Closes #290

Co-authored-by: Jean-Luc Makiola <business@jeanlucmakiola.de>
Reviewed-on: https://codeberg.org/jlmakiola/calendula/pulls/315

CHANGELOG.md

@@ -5,63 +5,6 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
-
-### Added
-- **Pages can open the split agenda.** Swipe up from a full month to reveal the compact grid and month agenda; tap a day to filter it, then swipe down to return. The transition gives haptic feedback ([#111]).
-
-### Changed
-- **Split view opens with the month's agenda.** It starts at today in the current month; tapping a day filters the list, and the filter chip restores the full month. Swiping the list moves by day when filtered and by month otherwise ([#142]).
-
-## [2.21.0] — 2026-09-23
-
-### Added
-- **Setup makes sure you have a calendar to write to.** A fresh install could
-  finish onboarding and land on an empty grid with nothing saying why — either
-  because the device had no calendar at all, or because every calendar it had
-  was switched off. Setup now covers both: it offers to create a calendar on
-  this device or to add an account that syncs one, and it lists the calendars
-  that exist but are switched off so you can turn them back on ([#287]).
-
-### Changed
-- **The month grid gives its days more room.** Week numbers are set smaller and
-  their gutter is measured from the widest number it has to seat instead of
-  holding a fixed 40dp; event chips spend less of their width on padding; and
-  the labels in both are tracked more tightly, which is worth roughly a
-  character per chip ([#189], [#190], [#212], [#213]).
-- **A month day shows as many events as it has height for.** The limit was a
-  flat three at every size, so a tall week row threw away space it could have
-  filled, while a cramped one drew a third chip its band could not hold and put
-  the "more" marker below the clip, where nothing showed the day held more at
-  all. It is measured per week row now, and a tablet or a landscape phone seats
-  more of them.
-- **Split view no longer pads a short month out to six rows.** A five-row month
-  was handing the day pane a blank row and its gap — a sixth of the grid. The
-  grid now draws only the rows its month spans and the pane grows into the rest
-  ([#162]).
-
-### Fixed
-- **Short events show their title in week and day view.** A block needed 20dp
-  of height before it drew any title at all, which at fit-the-whole-day put the
-  cutoff around the half hour. The padding now tapers as the block shrinks, so
-  a short event keeps its name ([#289]).
-- **A fully zoomed-out timeline sits still.** Rounding its height up left it as
-  much as a pixel per hour taller than the viewport those hours are meant to
-  fill — some 24px of leftover scroll, enough to bounce off Android's
-  overscroll stretch ([#290]).
-- **Backup & restore says what is going on instead of coming up blank.** It
-  built its rows straight from the calendar list, so loading, a provider error,
-  and a device with nothing to export all rendered as an empty page with no
-  buttons on it ([#304]).
-- **An event with no title reads in your language.** It was labelled "(Ohne
-  Titel)" on every screen but the event's own, whatever language the phone was
-  set to: the German text was chosen before the translated one could be
-  ([#321]).
-- **A calendar the system gives no name reads in your language.** The same
-  cause, in the calendar lists and pickers — and because the calendar editor
-  starts from that name, saving such a calendar wrote the German text into it
-  for real ([#329]).
-
 ## [2.20.4] — 2026-09-20
 
 ### Fixed
@@ -1771,14 +1714,3 @@ automatically, with zero telemetry and no internet permission.
 [#309]: https://codeberg.org/jlmakiola/calendula/issues/309
 [#305]: https://codeberg.org/jlmakiola/calendula/issues/305
 [#294]: https://codeberg.org/jlmakiola/calendula/issues/294
-[#287]: https://codeberg.org/jlmakiola/calendula/issues/287
-[#189]: https://codeberg.org/jlmakiola/calendula/issues/189
-[#190]: https://codeberg.org/jlmakiola/calendula/issues/190
-[#212]: https://codeberg.org/jlmakiola/calendula/issues/212
-[#213]: https://codeberg.org/jlmakiola/calendula/issues/213
-[#162]: https://codeberg.org/jlmakiola/calendula/issues/162
-[#289]: https://codeberg.org/jlmakiola/calendula/issues/289
-[#290]: https://codeberg.org/jlmakiola/calendula/issues/290
-[#304]: https://codeberg.org/jlmakiola/calendula/issues/304
-[#321]: https://codeberg.org/jlmakiola/calendula/issues/321
-[#329]: https://codeberg.org/jlmakiola/calendula/issues/329

app/build.gradle.kts

@@ -28,8 +28,8 @@ android {
         // which builds this version and then creates the matching vX.Y.Z tag +
         // release itself (versionCode is pinned to MAJOR*10000 + MINOR*100 +
         // PATCH from versionName, e.g. 2.7.2 -> 20702). See docs/RELEASING.md.
-        versionCode = 22100
-        versionName = "2.21.0"
+        versionCode = 22004
+        versionName = "2.20.4"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

app/src/main/java/de/jeanlucmakiola/calendula/MainActivity.kt

@@ -32,7 +32,6 @@ import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.buildInsertEventForm
 import de.jeanlucmakiola.calendula.ui.RootScreen
 import de.jeanlucmakiola.calendula.ui.common.LocalShowHourGrid
-import de.jeanlucmakiola.calendula.ui.common.LocalMultiDayCount
 import de.jeanlucmakiola.calendula.ui.common.LocalTimelineZoom
 import de.jeanlucmakiola.calendula.ui.common.rememberTimelineZoom
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
@@ -170,7 +169,6 @@ class MainActivity : AppCompatActivity() {
             // weeks and switching between the week and day view.
             val timelineZoom = rememberTimelineZoom(
                 stored = settings.timelineScale,
-                hours = settings.timelineHours,
                 onPersist = settingsViewModel::setTimelineScale,
             )
             val fonts by settingsViewModel.fontState.collectAsStateWithLifecycle()
@@ -190,7 +188,6 @@ class MainActivity : AppCompatActivity() {
                         LocalUse24HourFormat provides use24Hour,
                         LocalShowHourGrid provides settings.showHourGrid,
                         LocalTimelineZoom provides timelineZoom,
-                        LocalMultiDayCount provides settings.multiDayCount,
                         LocalSoftenColors provides settings.softenColors,
                     ) {
                         RootScreen(

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarColorPalette.kt

@@ -1,35 +1,22 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
 /**
- * The colours offered when creating or editing a calendar; ARGB ints for a raw
- * `CALENDAR_COLOR` / `EVENT_COLOR`.
- *
- * Hues rather than final fills: every surface that draws a calendar colour runs
- * it through the app's own tone pass first, so these are chosen to stay
- * distinguishable after it. Shared with Agendula, whose list palette these are —
- * the two apps are the same family and a calendar and a task list picked from
- * different-looking sets read as different products.
- *
- * The named entries exist for callers that need one specific hue (the managed
- * special-dates calendars), so they can't drift from the swatches on offer.
+ * Google-Calendar-style palette; ARGB ints for a raw `CALENDAR_COLOR` /
+ * `EVENT_COLOR`. The named entries exist for callers that need one specific
+ * hue (the managed special-dates calendars), so they can't drift from the
+ * swatches offered in the colour picker.
  */
 object CalendarColorPalette {
-    val Mauve = 0xFF7A5C6B.toInt()
-    val Red = 0xFFD7484A.toInt()
-    val Orange = 0xFFE8743B.toInt()
-    val Amber = 0xFFE0A32E.toInt()
-    val Olive = 0xFF7CA83E.toInt()
-    val Green = 0xFF35A06A.toInt()
-    val Teal = 0xFF19938C.toInt()
-    val Cyan = 0xFF2A9BC4.toInt()
-    val Blue = 0xFF3C74C8.toInt()
-    val Indigo = 0xFF6A5CC0.toInt()
-    val Purple = 0xFF9455B8.toInt()
-    val Pink = 0xFFC94F8E.toInt()
+    val Red = 0xFFD50000.toInt()
+    val Orange = 0xFFE67C00.toInt()
+    val Amber = 0xFFF6BF26.toInt()
+    val Green = 0xFF33B679.toInt()
+    val DarkGreen = 0xFF0B8043.toInt()
+    val Blue = 0xFF039BE5.toInt()
+    val Indigo = 0xFF3F51B5.toInt()
+    val Purple = 0xFF8E24AA.toInt()
+    val Graphite = 0xFF616161.toInt()
 
-    /** The full palette, in swatch-grid order. */
-    val all: List<Int> = listOf(
-        Mauve, Red, Orange, Amber, Olive, Green,
-        Teal, Cyan, Blue, Indigo, Purple, Pink,
-    )
+    /** The full palette, in swatch-row order. */
+    val all: List<Int> = listOf(Red, Orange, Amber, Green, DarkGreen, Blue, Indigo, Purple, Graphite)
 }

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarDataSource.kt

@@ -376,7 +376,7 @@ class AndroidCalendarDataSource @Inject constructor(
         .build()
 
     override fun createLocalCalendar(displayName: String, color: Int, description: String?): Long {
-        val name = displayName.trim()
+        val name = displayName.trim().ifEmpty { Fallbacks.UNNAMED_CALENDAR }
         val values = ContentValues().apply {
             put(CalendarContract.Calendars.ACCOUNT_NAME, LOCAL_ACCOUNT_NAME)
             put(CalendarContract.Calendars.ACCOUNT_TYPE, CalendarContract.ACCOUNT_TYPE_LOCAL)
@@ -400,7 +400,7 @@ class AndroidCalendarDataSource @Inject constructor(
     }
 
     override fun updateCalendar(id: Long, displayName: String, color: Int, description: String?) {
-        val name = displayName.trim()
+        val name = displayName.trim().ifEmpty { Fallbacks.UNNAMED_CALENDAR }
         val values = ContentValues().apply {
             put(CalendarContract.Calendars.CALENDAR_DISPLAY_NAME, name)
             put(CalendarContract.Calendars.NAME, name)
@@ -464,7 +464,7 @@ class AndroidCalendarDataSource @Inject constructor(
             PackageManager.PERMISSION_GRANTED
 
     override fun createManagedCalendar(displayName: String, color: Int, type: SpecialDateType): Long {
-        val name = displayName.trim()
+        val name = displayName.trim().ifEmpty { Fallbacks.UNNAMED_CALENDAR }
         val values = ContentValues().apply {
             put(CalendarContract.Calendars.ACCOUNT_NAME, LOCAL_ACCOUNT_NAME)
             put(CalendarContract.Calendars.ACCOUNT_TYPE, CalendarContract.ACCOUNT_TYPE_LOCAL)

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarMapper.kt

@@ -8,9 +8,8 @@ internal fun ColumnReader.toCalendarSource(): CalendarSource {
     val isLocal = accountType == CalendarContract.ACCOUNT_TYPE_LOCAL
     return CalendarSource(
         id = getLong(CalendarProjection.IDX_ID),
-        // Blank when the provider row has no name: the placeholder is a display
-        // string and belongs to the UI, where it can be localised (#329).
-        displayName = getString(CalendarProjection.IDX_DISPLAY_NAME).orEmpty(),
+        displayName = getString(CalendarProjection.IDX_DISPLAY_NAME)
+            ?: Fallbacks.UNNAMED_CALENDAR,
         accountName = getString(CalendarProjection.IDX_ACCOUNT_NAME).orEmpty(),
         accountType = accountType,
         color = getInt(CalendarProjection.IDX_COLOR),

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/InstanceMapper.kt

@@ -21,9 +21,8 @@ internal fun ColumnReader.toEventInstance(): EventInstance? {
         return null
     }
 
-    // Left blank when the event has no title: the placeholder is a display
-    // string, so it belongs to the UI layer where it can be localised (#321).
-    val title = getString(InstanceProjection.IDX_TITLE).orEmpty()
+    val rawTitle = getString(InstanceProjection.IDX_TITLE)
+    val title = if (rawTitle.isNullOrEmpty()) Fallbacks.UNTITLED_EVENT else rawTitle
 
     val color = if (isNull(InstanceProjection.IDX_EVENT_COLOR)) {
         getInt(InstanceProjection.IDX_CALENDAR_COLOR)

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/Projections.kt

@@ -312,3 +312,8 @@ internal object ReminderProjection {
     const val IDX_MINUTES = 0
     const val IDX_METHOD = 1
 }
+
+internal object Fallbacks {
+    const val UNNAMED_CALENDAR = "(Unbenannter Kalender)"
+    const val UNTITLED_EVENT = "(Ohne Titel)"
+}

app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/SearchMapper.kt

@@ -21,7 +21,8 @@ internal fun ColumnReader.toSearchResult(): EventInstance? {
         else -> dtStart + parseRfc2445DurationMillis(getString(SearchProjection.IDX_DURATION))
     }.coerceAtLeast(dtStart)
 
-    val title = getString(SearchProjection.IDX_TITLE).orEmpty()
+    val rawTitle = getString(SearchProjection.IDX_TITLE)
+    val title = if (rawTitle.isNullOrEmpty()) Fallbacks.UNTITLED_EVENT else rawTitle
     val color = if (isNull(SearchProjection.IDX_EVENT_COLOR)) {
         getInt(SearchProjection.IDX_CALENDAR_COLOR)
     } else {

app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefs.kt

@@ -21,7 +21,6 @@ import de.jeanlucmakiola.calendula.ui.agenda.storageValue
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
-import de.jeanlucmakiola.calendula.ui.common.TimelineHours
 import de.jeanlucmakiola.calendula.ui.common.TimelineScale
 import de.jeanlucmakiola.calendula.ui.common.parseTimelineScale
 import de.jeanlucmakiola.calendula.ui.common.storageValue
@@ -288,36 +287,6 @@ class SettingsPrefs @Inject constructor(
         store.edit { it[TIMELINE_SCALE_KEY] = scale.storageValue() }
     }
 
-    /**
-     * The hours the day, week and multi-day timelines fit to the screen when they
-     * open (#322). Off by default; the hours survive switching it off.
-     */
-    val timelineHours: Flow<TimelineHours> = store.data.map { prefs ->
-        TimelineHours.of(
-            enabled = prefs[TIMELINE_HOURS_ENABLED_KEY] ?: false,
-            startHour = prefs[TIMELINE_HOURS_START_KEY] ?: TimelineHours.DEFAULT_START_HOUR,
-            endHour = prefs[TIMELINE_HOURS_END_KEY] ?: TimelineHours.DEFAULT_END_HOUR,
-        )
-    }
-
-    suspend fun setTimelineHours(hours: TimelineHours) {
-        val valid = TimelineHours.of(hours.enabled, hours.startHour, hours.endHour)
-        store.edit {
-            it[TIMELINE_HOURS_ENABLED_KEY] = valid.enabled
-            it[TIMELINE_HOURS_START_KEY] = valid.startHour
-            it[TIMELINE_HOURS_END_KEY] = valid.endHour
-        }
-    }
-
-    /** How many days the multi-day view shows side by side (#193). */
-    val multiDayCount: Flow<Int> = store.data.map { prefs ->
-        (prefs[MULTI_DAY_COUNT_KEY] ?: DEFAULT_MULTI_DAY_COUNT).coerceIn(MULTI_DAY_COUNTS)
-    }
-
-    suspend fun setMultiDayCount(count: Int) {
-        store.edit { it[MULTI_DAY_COUNT_KEY] = count.coerceIn(MULTI_DAY_COUNTS) }
-    }
-
     /**
      * Where the jump-to-today control lives (issue #60). Default OFF — the
      * historical layout, where it's an extended FAB that fades in above the "+"
@@ -617,24 +586,6 @@ class SettingsPrefs @Inject constructor(
         }
     }
 
-    /** Whether the wizard's calendar step has been answered (or skipped). */
-    val onboardingCalendarsDone: Flow<Boolean> = store.data.map { prefs ->
-        prefs[ONBOARDING_CALENDARS_KEY] ?: false
-    }
-
-    suspend fun setOnboardingCalendarsDone(done: Boolean = true) {
-        store.edit { it[ONBOARDING_CALENDARS_KEY] = done }
-    }
-
-    /** Whether the wizard's hidden-calendars step has been answered (or skipped). */
-    val onboardingHiddenCalendarsDone: Flow<Boolean> = store.data.map { prefs ->
-        prefs[ONBOARDING_HIDDEN_KEY] ?: false
-    }
-
-    suspend fun setOnboardingHiddenCalendarsDone(done: Boolean = true) {
-        store.edit { it[ONBOARDING_HIDDEN_KEY] = done }
-    }
-
     /** Whether the wizard's backup step has been answered (or skipped). */
     val onboardingBackupDone: Flow<Boolean> = store.data.map { prefs ->
         prefs[ONBOARDING_BACKUP_KEY] ?: false
@@ -979,20 +930,10 @@ class SettingsPrefs @Inject constructor(
             if (view in config.enabled) view.name else "!${view.name}"
         }
 
-    /** Keep stored order; insert the new multi-day view after Week on upgrades. */
+    /** Keep the given order (de-duplicated), then append any views it omits. */
     private fun completeViewOrder(seen: List<CalendarView>): List<CalendarView> {
-        val ordered = seen.distinct().toMutableList()
-        IMPLEMENTED_VIEWS.forEach { view ->
-            if (view !in ordered) {
-                val index = if (view == CalendarView.MultiDay && CalendarView.Week in ordered) {
-                    ordered.indexOf(CalendarView.Week) + 1
-                } else {
-                    ordered.size
-                }
-                ordered.add(index, view)
-            }
-        }
-        return ordered
+        val ordered = seen.distinct()
+        return ordered + IMPLEMENTED_VIEWS.filterNot { it in ordered }
     }
 
     companion object {
@@ -1036,10 +977,6 @@ class SettingsPrefs @Inject constructor(
         internal val REMINDERS_ENABLED_KEY = booleanPreferencesKey("reminders_enabled")
         internal val REMINDER_ONBOARDING_KEY = booleanPreferencesKey("reminder_onboarding_done")
         internal val ONBOARDING_WIZARD_ARMED_KEY = booleanPreferencesKey("onboarding_wizard_armed")
-        internal val ONBOARDING_CALENDARS_KEY =
-            booleanPreferencesKey("onboarding_calendars_done")
-        internal val ONBOARDING_HIDDEN_KEY =
-            booleanPreferencesKey("onboarding_hidden_calendars_done")
         internal val ONBOARDING_BACKUP_KEY = booleanPreferencesKey("onboarding_backup_done")
         internal val ONBOARDING_VIEW_KEY = booleanPreferencesKey("onboarding_view_done")
         internal val ONBOARDING_MONTH_STYLE_KEY =
@@ -1058,14 +995,8 @@ class SettingsPrefs @Inject constructor(
         internal const val DEFAULT_ALLDAY_REMINDER_TIME = 540
         private const val MINUTES_PER_DAY = 1_440
         internal val SNOOZE_MINUTES_KEY = intPreferencesKey("snooze_minutes")
-        internal val MULTI_DAY_COUNT_KEY = intPreferencesKey("multi_day_count")
-        internal val TIMELINE_HOURS_ENABLED_KEY = booleanPreferencesKey("timeline_hours_enabled")
-        internal val TIMELINE_HOURS_START_KEY = intPreferencesKey("timeline_hours_start")
-        internal val TIMELINE_HOURS_END_KEY = intPreferencesKey("timeline_hours_end")
         /** Default snooze delay for the notification "Snooze" action. */
         const val DEFAULT_SNOOZE_MINUTES = 10
-        const val DEFAULT_MULTI_DAY_COUNT = 3
-        val MULTI_DAY_COUNTS = 3..6
         internal val CALENDAR_REMINDER_OVERRIDE_KEY =
             stringPreferencesKey("per_calendar_reminder_override")
         internal val CALENDAR_ALLDAY_REMINDER_OVERRIDE_KEY =

app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderNotifier.kt

@@ -88,7 +88,6 @@ class ReminderNotifier @Inject constructor(
             is24Hour = is24Hour,
             today = Instant.now().atZone(zone).toLocalDate(),
             firstDayOfWeek = firstDayOfWeek,
-            todayLabel = context.getString(R.string.reminder_day_today),
             tomorrowLabel = context.getString(R.string.reminder_day_tomorrow),
             yesterdayLabel = context.getString(R.string.reminder_day_yesterday),
         )

app/src/main/java/de/jeanlucmakiola/calendula/data/reminders/ReminderTimeText.kt

@@ -27,12 +27,12 @@ import java.util.Locale
  *                                                          alone would be ambiguous)
  * - timed, crossing days: "11 Jun, 23:30 – 12 Jun, 00:30" (medium date + short time,
  *                                                          already unambiguous)
- * - all-day, one day:     "Tomorrow" / "Thu" / "11 Jun 2026" (same relative rules,
- *                                                          plus [todayLabel] — no time range to lean on)
- * - all-day, multi-day:   "Tomorrow – 12 Jun 2026"        (relative start, explicit end)
+ * - all-day, one day:     "11 Jun 2026"
+ * - all-day, multi-day:   "11 Jun 2026 – 12 Jun 2026"
  *
- * All-day instances store UTC midnights with an exclusive end, so they are read
- * in UTC and the end day is the last *covered* day (issue #308).
+ * All-day instances already carry an explicit date, so they never gain a
+ * relative prefix. They store UTC midnights with an exclusive end, so they are
+ * read in UTC and the end day is the last *covered* day.
  */
 fun reminderTimeText(
     beginMillis: Long,
@@ -43,7 +43,6 @@ fun reminderTimeText(
     is24Hour: Boolean,
     today: LocalDate,
     firstDayOfWeek: DayOfWeek,
-    todayLabel: String,
     tomorrowLabel: String,
     yesterdayLabel: String,
 ): String {
@@ -54,16 +53,11 @@ fun reminderTimeText(
         val lastDay = Instant.ofEpochMilli(endMillis).atZone(ZoneOffset.UTC).toLocalDate()
             .minusDays(1)
             .coerceAtLeast(firstDay)
-        val start = relativeDayPrefix(
-            day = firstDay,
-            today = today,
-            firstDayOfWeek = firstDayOfWeek,
-            locale = locale,
-            dateFormat = dateFormat,
-            tomorrowLabel = tomorrowLabel,
-            yesterdayLabel = yesterdayLabel,
-        ) ?: todayLabel
-        return if (lastDay == firstDay) start else start + RANGE + dateFormat.format(lastDay)
+        return if (lastDay == firstDay) {
+            dateFormat.format(firstDay)
+        } else {
+            dateFormat.format(firstDay) + RANGE + dateFormat.format(lastDay)
+        }
     }
 
     val timeFormat = timeOfDayFormatter(is24Hour, locale)

app/src/main/java/de/jeanlucmakiola/calendula/domain/Models.kt

@@ -253,13 +253,6 @@ enum class FailureReason {
     PermissionRevoked,
     NoCalendarsConfigured,
     AllCalendarsHidden,
-
-    /**
-     * Calendars exist and are switched on, but none can receive an event: every
-     * one is read-only, app-managed, or not synced to this device. Distinct from
-     * [AllCalendarsHidden], which a visibility switch fixes.
-     */
-    NoImportTarget,
     ProviderUnavailable,
     EventNotFound,
     Unknown,

app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsParser.kt

@@ -166,19 +166,14 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
             }
             when {
                 component != null -> {
-                    // A component whose END line never arrives ends at the next
-                    // one's BEGIN, not at that one's END: reading to the far END
-                    // would fold two events into one body, where the later
-                    // properties overwrite the earlier and one event is lost.
                     val end = indexOfEnd(lines, i + 1, component)
-                    val body = indexOfNextComponent(lines, i + 1, end)
                     parseComponent(
-                        body = lines.subList(i + 1, body),
+                        body = lines.subList(i + 1, end),
                         fileCalendarName = calendarName,
                         warnings = warnings,
                         isTask = component == "VTODO",
                     )?.let(events::add)
-                    i = if (body < end) body else end + 1
+                    i = end + 1
                 }
                 line.isBegin("VTIMEZONE") -> {
                     // Skipped wholesale; TZIDs resolve against the OS tz database.
@@ -450,23 +445,6 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
         }
 
         /** Index of the matching `END:<component>` at/after [from], or list end. */
-        /**
-         * Where an unterminated component's body has to stop: the next top-level
-         * `VEVENT` / `VTODO` in `[from, end)`, or [end] when there is none. A
-         * nested `VALARM` is part of the body and is not a boundary.
-         */
-        fun indexOfNextComponent(lines: List<String>, from: Int, end: Int): Int {
-            var i = from
-            while (i < end) {
-                val line = parseContentLine(lines[i])
-                if (line != null && (line.isBegin("VEVENT") || line.isBegin("VTODO"))) {
-                    return i
-                }
-                i++
-            }
-            return end
-        }
-
         fun indexOfEnd(lines: List<String>, from: Int, component: String): Int {
             var i = from
             while (i < lines.size) {

app/src/main/java/de/jeanlucmakiola/calendula/ui/CalendarHost.kt

@@ -45,7 +45,6 @@ import de.jeanlucmakiola.calendula.ui.imports.ImportScreen
 import de.jeanlucmakiola.calendula.ui.month.MonthScreen
 import de.jeanlucmakiola.calendula.ui.search.SearchScreen
 import de.jeanlucmakiola.calendula.ui.settings.SettingsScreen
-import de.jeanlucmakiola.calendula.ui.week.MultiDayScreen
 import de.jeanlucmakiola.calendula.ui.week.WeekScreen
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
@@ -198,21 +197,10 @@ fun CalendarHost(
     // is "restore a backup", not "add this one event". An externally opened .ics
     // keeps routing a single event straight into the prefilled create form.
     var importForceMany by remember { mutableStateOf(false) }
-    // Where a restore came from, so closing the import puts it back: the import
-    // overlays are declared under Backup & restore and the manager, so starting
-    // one has to close them — without this, finishing a restore drops you on the
-    // calendar and the next file means walking in through Settings again.
-    var backupAfterImport by rememberSaveable { mutableStateOf(false) }
-    var calendarsAfterImport by rememberSaveable { mutableStateOf(false) }
-    // One import run. The import VM lives in the Activity's store, so this is
-    // what tells it a *re-import of the same file* is new work and not the run
-    // it already finished; a rotation keeps the number and keeps the result.
-    var importSession by rememberSaveable { mutableStateOf(0) }
     LaunchedEffect(requestedImportUri) {
         if (requestedImportUri != null) {
             importUri = requestedImportUri
             importForceMany = false
-            importSession++
             onImportConsumed()
         }
     }
@@ -381,18 +369,6 @@ fun CalendarHost(
                     drawerViewOrder = drawerViewOrder,
                     todayInToolbar = todayInToolbar,
                 )
-                CalendarView.MultiDay -> MultiDayScreen(
-                    selectedView = currentView,
-                    onSelectView = onSelectView,
-                    onOpenDay = onOpenDay,
-                    onEventClick = onEventClick,
-                    onOpenSettings = onOpenSettings,
-                    onOpenSearch = onOpenSearch,
-                    onCreateEvent = onCreateEvent,
-                    quickSwitchViews = quickSwitchViews,
-                    drawerViewOrder = drawerViewOrder,
-                    todayInToolbar = todayInToolbar,
-                )
                 CalendarView.Day -> DayScreen(
                     selectedView = currentView,
                     onSelectView = onSelectView,
@@ -534,28 +510,11 @@ fun CalendarHost(
         importUri?.let { uri ->
             ImportScreen(
                 uri = uri,
-                session = importSession,
                 forceMany = importForceMany,
-                onClose = {
-                    importUri = null
-                    // Back to the surface the restore started from, ready for
-                    // the next file.
-                    showCalendars = calendarsAfterImport
-                    showBackup = backupAfterImport
-                    calendarsAfterImport = false
-                    backupAfterImport = false
-                },
-                onManageCalendars = {
-                    // The manager is where this leads, so it must not be
-                    // reopened underneath on close.
-                    calendarsAfterImport = false
-                    backupAfterImport = false
-                    showCalendars = true
-                },
+                onClose = { importUri = null },
+                onManageCalendars = { showCalendars = true },
                 onOpenSingle = { form ->
                     importUri = null
-                    calendarsAfterImport = false
-                    backupAfterImport = false
                     importFormSource = ImportSource.File
                     importForm = form
                 },
@@ -591,33 +550,18 @@ fun CalendarHost(
             enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
             exit = slideOutHorizontally(slideSpec) { it } + fadeOut(),
         ) {
-            // Settings can open this screen without the manager underneath, so
-            // its failure states' "Manage calendars" way out has to open the
-            // manager rather than just pop — popping alone lands on Settings
-            // (#304). Coming from the manager the flag is already set, so this
-            // is the same pop-back there.
-            CompositionLocalProvider(
-                LocalManageCalendars provides {
-                    showCalendars = true
+            BackupScreen(
+                onBack = { showBackup = false },
+                // Restore runs the normal .ics import, and both this screen and
+                // the manager that can have opened it are declared above the
+                // import overlays — so both have to step aside.
+                onImport = {
+                    importUri = it
+                    importForceMany = true
                     showBackup = false
+                    showCalendars = false
                 },
-            ) {
-                BackupScreen(
-                    onBack = { showBackup = false },
-                    // Restore runs the normal .ics import, and both this screen
-                    // and the manager that can have opened it are declared above
-                    // the import overlays — so both have to step aside.
-                    onImport = {
-                        importUri = it
-                        importForceMany = true
-                        importSession++
-                        backupAfterImport = true
-                        calendarsAfterImport = showCalendars
-                        showBackup = false
-                        showCalendars = false
-                    },
-                )
-            }
+            )
         }
     }
 }

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/BackupScreen.kt

@@ -4,11 +4,9 @@ import android.net.Uri
 import android.text.format.DateUtils
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
@@ -20,7 +18,6 @@ import androidx.compose.material.icons.filled.Schedule
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Button
 import androidx.compose.material3.Checkbox
-import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
@@ -50,10 +47,9 @@ import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.prefs.BackupStatus
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.isEventTarget
 import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
-import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.LeadingAvatar
-import de.jeanlucmakiola.calendula.ui.common.LocalManageCalendars
 import de.jeanlucmakiola.floret.components.CollapsingScaffold
 import de.jeanlucmakiola.floret.components.DialogAmountField
 import de.jeanlucmakiola.floret.components.DialogUnitDropdown
@@ -84,13 +80,18 @@ fun BackupScreen(
     onImport: (Uri) -> Unit,
     viewModel: CalendarsViewModel = hiltViewModel(),
 ) {
-    val state by viewModel.backupState.collectAsStateWithLifecycle()
+    val calendars by viewModel.calendars.collectAsStateWithLifecycle()
     val backupResult by viewModel.backupResult.collectAsStateWithLifecycle()
     val autoBackup by viewModel.autoBackup.collectAsStateWithLifecycle()
 
     val context = LocalContext.current
     val snackbarHostState = remember { SnackbarHostState() }
 
+    // Export covers local calendars only; managed special-dates mirrors are
+    // rebuilt from contacts. Restore can target anything the import picker offers.
+    val exportable = calendars.filter { it.isLocal && it.canModifyContents && !it.isManaged }
+    val canImport = calendars.any { it.isEventTarget }
+
     // Exports everything eligible (null); the per-calendar selector owns its
     // own launcher.
     val createBackup = rememberLauncherForActivityResult(
@@ -131,42 +132,78 @@ fun BackupScreen(
     CollapsingScaffold(
         title = stringResource(R.string.settings_section_backup),
         onBack = onBack,
-        // Loading and failure fill the screen and centre themselves, which they
-        // can only do in an unscrolled column — the scrolling one measures them
-        // against an unbounded height and leaves them hanging under the header.
-        scrollable = state is BackupUiState.Ready,
         snackbarHost = { SnackbarHost(snackbarHostState) },
         predictiveBack = true,
     ) {
-        when (val s = state) {
-            BackupUiState.Loading -> BackupLoading()
-            is BackupUiState.Failure -> CalendarFailure(reason = s.reason, onRetry = onBack)
-            is BackupUiState.Ready -> BackupContent(
-                exportable = s.exportable,
-                canImport = s.canImport,
-                autoBackup = autoBackup,
-                viewModel = viewModel,
-                onRestore = { runCatching { openBackup.launch(RESTORE_MIME_TYPES) } },
-                onPickFolder = { runCatching { pickFolder.launch(null) } },
-                onExportAll = {
-                    runCatching { createBackup.launch(defaultBackupName()) }
+        HintText(stringResource(R.string.calendars_backup_hint))
+
+        if (exportable.isNotEmpty()) {
+            GroupedRow(
+                title = stringResource(R.string.calendars_backup_action),
+                position = Position.Top,
+                leading = { LeadingAvatar(Icons.Default.FileDownload) },
+                onClick = {
+                    // A single exportable calendar skips the selector.
+                    if (exportable.size == 1) {
+                        runCatching { createBackup.launch("calendula-backup-${LocalDate.now()}.ics") }
+                    } else {
+                        showExportPicker = true
+                    }
                 },
-                onExportPick = { showExportPicker = true },
-                onEditInterval = { showInterval = true },
+            )
+            GroupedRow(
+                title = stringResource(R.string.calendars_restore_action),
+                summary = stringResource(R.string.calendars_restore_hint),
+                position = Position.Middle,
+                leading = { LeadingAvatar(Icons.Default.FileUpload) },
+                onClick = { runCatching { openBackup.launch(RESTORE_MIME_TYPES) } },
+            )
+            GroupedRow(
+                title = stringResource(R.string.calendars_auto_backup),
+                summary = stringResource(R.string.calendars_auto_backup_hint),
+                position = if (autoBackup.enabled) Position.Middle else Position.Bottom,
+                leading = { LeadingAvatar(Icons.Default.Schedule) },
+                trailing = {
+                    Switch(checked = autoBackup.enabled, onCheckedChange = viewModel::setAutoBackupEnabled)
+                },
+                onClick = { viewModel.setAutoBackupEnabled(!autoBackup.enabled) },
+            )
+            if (autoBackup.enabled) {
+                GroupedRow(
+                    title = stringResource(R.string.calendars_auto_backup_folder),
+                    summary = rememberFolderName(autoBackup.folderUri)
+                        ?: stringResource(R.string.calendars_auto_backup_folder_unset),
+                    position = Position.Middle,
+                    onClick = { runCatching { pickFolder.launch(null) } },
+                )
+                GroupedRow(
+                    title = stringResource(R.string.calendars_auto_backup_interval),
+                    summary = backupIntervalLabel(autoBackup.intervalMinutes),
+                    position = Position.Bottom,
+                    onClick = { showInterval = true },
+                )
+                HintText(backupStatusText(autoBackup.status))
+            }
+        } else if (canImport) {
+            // Nothing to back up, but restore is still possible — don't hide
+            // it behind export eligibility.
+            SectionHeader(stringResource(R.string.calendars_restore_header))
+            HintText(stringResource(R.string.calendars_restore_hint))
+            GroupedRow(
+                title = stringResource(R.string.calendars_restore_action),
+                position = Position.Alone,
+                leading = { LeadingAvatar(Icons.Default.FileUpload) },
+                onClick = { runCatching { openBackup.launch(RESTORE_MIME_TYPES) } },
             )
         }
     }
 
-    // Gated on Ready rather than resetting the flag when the state leaves it:
-    // flipping it here would be a write during composition.
-    (state as? BackupUiState.Ready)?.let { ready ->
-        if (showExportPicker) {
-            ExportCalendarPicker(
-                calendars = ready.exportable,
-                onExport = viewModel::exportBackup,
-                onDismiss = { showExportPicker = false },
-            )
-        }
+    if (showExportPicker) {
+        ExportCalendarPicker(
+            calendars = exportable,
+            onExport = viewModel::exportBackup,
+            onDismiss = { showExportPicker = false },
+        )
     }
     if (showInterval) {
         BackupIntervalDialog(
@@ -177,103 +214,6 @@ fun BackupScreen(
     }
 }
 
-/** The screen's loading state, centred in the scaffold's content column. */
-@Composable
-private fun BackupLoading() {
-    Box(
-        modifier = Modifier.fillMaxSize(),
-        contentAlignment = Alignment.Center,
-    ) {
-        CircularProgressIndicator()
-    }
-}
-
-/** Default file name for a one-shot export. */
-private fun defaultBackupName(): String = "calendula-backup-${LocalDate.now()}.ics"
-
-/**
- * The working screen: export (when there are local calendars to export), restore,
- * and the automatic-backup block. Restore is always on screen — when nothing can
- * receive the events it says so and routes to the calendar manager rather than
- * disappearing, which is what #304 reported as an invisible button.
- */
-@Composable
-private fun BackupContent(
-    exportable: List<CalendarSource>,
-    canImport: Boolean,
-    autoBackup: AutoBackupUiState,
-    viewModel: CalendarsViewModel,
-    onRestore: () -> Unit,
-    onPickFolder: () -> Unit,
-    onExportAll: () -> Unit,
-    onExportPick: () -> Unit,
-    onEditInterval: () -> Unit,
-) {
-    val manageCalendars = LocalManageCalendars.current
-    // Restore never depends on export eligibility, and never disappears: when no
-    // calendar can receive events it explains that and offers the way to fix it.
-    val restoreSummary = if (canImport) {
-        stringResource(R.string.calendars_restore_hint)
-    } else {
-        stringResource(R.string.calendars_restore_unavailable)
-    }
-    val onRestoreClick = if (canImport) onRestore else (manageCalendars ?: onRestore)
-
-    if (exportable.isEmpty()) {
-        SectionHeader(stringResource(R.string.calendars_restore_header))
-        HintText(restoreSummary)
-        GroupedRow(
-            title = stringResource(R.string.calendars_restore_action),
-            position = Position.Alone,
-            leading = { LeadingAvatar(Icons.Default.FileUpload) },
-            onClick = onRestoreClick,
-        )
-        return
-    }
-
-    HintText(stringResource(R.string.calendars_backup_hint))
-    GroupedRow(
-        title = stringResource(R.string.calendars_backup_action),
-        position = Position.Top,
-        leading = { LeadingAvatar(Icons.Default.FileDownload) },
-        // A single exportable calendar skips the selector.
-        onClick = if (exportable.size == 1) onExportAll else onExportPick,
-    )
-    GroupedRow(
-        title = stringResource(R.string.calendars_restore_action),
-        summary = restoreSummary,
-        position = Position.Middle,
-        leading = { LeadingAvatar(Icons.Default.FileUpload) },
-        onClick = onRestoreClick,
-    )
-    GroupedRow(
-        title = stringResource(R.string.calendars_auto_backup),
-        summary = stringResource(R.string.calendars_auto_backup_hint),
-        position = if (autoBackup.enabled) Position.Middle else Position.Bottom,
-        leading = { LeadingAvatar(Icons.Default.Schedule) },
-        trailing = {
-            Switch(checked = autoBackup.enabled, onCheckedChange = viewModel::setAutoBackupEnabled)
-        },
-        onClick = { viewModel.setAutoBackupEnabled(!autoBackup.enabled) },
-    )
-    if (autoBackup.enabled) {
-        GroupedRow(
-            title = stringResource(R.string.calendars_auto_backup_folder),
-            summary = rememberFolderName(autoBackup.folderUri)
-                ?: stringResource(R.string.calendars_auto_backup_folder_unset),
-            position = Position.Middle,
-            onClick = onPickFolder,
-        )
-        GroupedRow(
-            title = stringResource(R.string.calendars_auto_backup_interval),
-            summary = backupIntervalLabel(autoBackup.intervalMinutes),
-            position = Position.Bottom,
-            onClick = onEditInterval,
-        )
-        HintText(backupStatusText(autoBackup.status))
-    }
-}
-
 /**
  * Choose which local calendars to include in a one-time `.ics` export. Defaults
  * to all selected; the Export action opens the SAF save dialog and hands back
@@ -312,7 +252,7 @@ private fun ExportCalendarPicker(
         calendars.forEachIndexed { index, calendar ->
             val isSelected = calendar.id in selected
             GroupedRow(
-                title = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
+                title = calendar.displayName,
                 summary = calendar.description,
                 position = positionOf(index, calendars.size),
                 leading = { CalendarColorChip(calendar.color) },

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/BackupUiState.kt

@@ -1,53 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.calendars
-
-import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.FailureReason
-import de.jeanlucmakiola.calendula.domain.calendarListFailure
-import de.jeanlucmakiola.calendula.domain.isEventTarget
-
-/**
- * State of the Backup & restore screen (#69). Three states, because the calendar
- * list it is derived from has all three: it arrives empty, it can throw, and
- * "loaded but nothing to offer" is a real outcome the screen used to render as a
- * blank page (#304).
- */
-sealed interface BackupUiState {
-    data object Loading : BackupUiState
-    data class Failure(val reason: FailureReason) : BackupUiState
-
-    /**
-     * At least one half of the screen works. [exportable] may be empty (restore
-     * only) and [canImport] may be false (export only), but never both — that is
-     * a [Failure].
-     */
-    data class Ready(
-        val exportable: List<CalendarSource>,
-        val canImport: Boolean,
-    ) : BackupUiState
-}
-
-/**
- * What the screen can offer for this calendar list.
- *
- * Export covers the app's own local calendars; managed special-dates mirrors are
- * rebuilt from contacts, so they are excluded. Restore can target anything the
- * import picker offers ([isEventTarget]).
- *
- * A failure is raised only when *neither* is possible — deliberately not
- * [calendarListFailure] on its own, which would call an all-hidden device a
- * failure while its local calendars are still perfectly exportable. When both
- * halves are dead the list itself usually says why (no calendars, everything
- * switched off); [FailureReason.NoImportTarget] covers the remaining case, where
- * calendars exist and are visible but every one of them is read-only, managed or
- * not synced to the device.
- */
-fun backupUiState(calendars: List<CalendarSource>): BackupUiState {
-    val exportable = calendars.filter { it.isLocal && it.canModifyContents && !it.isManaged }
-    val canImport = calendars.any { it.isEventTarget }
-    if (exportable.isEmpty() && !canImport) {
-        return BackupUiState.Failure(
-            calendarListFailure(calendars) ?: FailureReason.NoImportTarget,
-        )
-    }
-    return BackupUiState.Ready(exportable = exportable, canImport = canImport)
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsScreen.kt

@@ -90,7 +90,6 @@ import de.jeanlucmakiola.calendula.ui.common.groupByAccount
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.eventAccent
 import de.jeanlucmakiola.calendula.ui.common.eventFill
-import de.jeanlucmakiola.calendula.ui.common.eventInk
 import de.jeanlucmakiola.calendula.ui.common.LeadingAvatar
 import de.jeanlucmakiola.calendula.ui.common.SourceLogo
 import de.jeanlucmakiola.calendula.ui.common.curatedSourcePackage
@@ -98,25 +97,11 @@ import de.jeanlucmakiola.floret.components.CollapsingScaffold
 import de.jeanlucmakiola.floret.identity.collapseExit
 import de.jeanlucmakiola.floret.identity.expandEnter
 import de.jeanlucmakiola.floret.identity.predictiveBack
+import de.jeanlucmakiola.calendula.ui.common.ColorSwatchRow
 import de.jeanlucmakiola.floret.components.GroupedListInset
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.InlineTextField
 import de.jeanlucmakiola.floret.components.Position
-import androidx.compose.foundation.layout.aspectRatio
-import androidx.compose.foundation.layout.heightIn
-import androidx.annotation.StringRes
-import androidx.compose.foundation.border
-import androidx.compose.foundation.selection.selectable
-import androidx.compose.foundation.selection.selectableGroup
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.icons.filled.Check
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.semantics.Role
-import androidx.compose.ui.text.input.ImeAction
-import de.jeanlucmakiola.floret.components.FullScreenPicker
-import de.jeanlucmakiola.floret.components.GroupedSurface
 
 /** Sentinel [editorId] meaning "the editor is composing a new calendar". */
 private const val NEW_CALENDAR_ID = Long.MIN_VALUE
@@ -246,7 +231,7 @@ private fun CalendarsList(
                 local.forEachIndexed { index, calendar ->
                     val disabled = !calendar.isVisibleInSystem
                     GroupedRow(
-                        title = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
+                        title = calendar.displayName,
                         summary = calendarRowSummary(calendar),
                         position = if (index == local.lastIndex) Position.Bottom else Position.Middle,
                         container = MaterialTheme.colorScheme.surfaceContainerHighest,
@@ -254,7 +239,7 @@ private fun CalendarsList(
                         leading = { CalendarColorChip(calendar.color, dimIf(disabled)) },
                         trailing = {
                             EnableSwitch(
-                                calendarName = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
+                                calendarName = calendar.displayName,
                                 enabled = !disabled,
                                 onToggle = { enabled -> onSetVisible(calendar.id, enabled) },
                             )
@@ -331,7 +316,7 @@ private fun CalendarsList(
                     ordered.forEachIndexed { index, calendar ->
                         val disabled = !calendar.isVisibleInSystem || calendar.isNotSynced
                         GroupedRow(
-                            title = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
+                            title = calendar.displayName,
                             summary = calendarRowSummary(calendar),
                             position = if (index == ordered.lastIndex) Position.Bottom else Position.Middle,
                             container = MaterialTheme.colorScheme.surfaceContainerHighest,
@@ -340,7 +325,7 @@ private fun CalendarsList(
                             trailing = if (calendar.hasVisibilitySwitch) {
                                 {
                                     EnableSwitch(
-                                        calendarName = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
+                                        calendarName = calendar.displayName,
                                         enabled = calendar.isVisibleInSystem,
                                         onToggle = { enabled ->
                                             onSetVisible(calendar.id, enabled)
@@ -358,15 +343,9 @@ private fun CalendarsList(
 
 }
 
-private const val SWATCHES_PER_ROW = 6
-
-/**
- * Create or edit a local calendar: a name field over the palette of calendar
- * colours, on the family's full-screen sheet with the commit in its title bar.
- * The same sheet Agendula edits a task list in, so the two read as one product.
- */
+@OptIn(ExperimentalMaterial3Api::class)
 @Composable
-internal fun CalendarEditor(
+private fun CalendarEditor(
     sessionKey: Int,
     isNew: Boolean,
     initialName: String,
@@ -381,50 +360,121 @@ internal fun CalendarEditor(
     var color by rememberSaveable(sessionKey) { mutableStateOf(initialColor) }
     var description by rememberSaveable(sessionKey) { mutableStateOf(initialDescription) }
     var confirmDelete by remember { mutableStateOf(false) }
-    val focusRequester = remember { FocusRequester() }
+    val dark = isSystemInDarkTheme()
+    val soften = LocalSoftenColors.current
 
-    val valid = name.isNotBlank()
-    val commit = { if (valid) onSave(name.trim(), color, description.trim().ifEmpty { null }) }
-
-    FullScreenPicker(
-        title = stringResource(
-            if (isNew) R.string.calendars_new_title else R.string.calendars_edit_title,
-        ),
-        onDismiss = onClose,
-        predictiveBack = true,
-        actions = {
-            Button(
-                onClick = commit,
-                enabled = valid,
-                modifier = Modifier.padding(end = 12.dp),
-            ) { Text(stringResource(R.string.event_edit_save)) }
+    Scaffold(
+        modifier = Modifier
+            .predictiveBack(onBack = onClose)
+            .fillMaxSize()
+            .background(MaterialTheme.colorScheme.surface),
+        topBar = {
+            TopAppBar(
+                title = {
+                    Text(
+                        stringResource(
+                            if (isNew) R.string.calendars_new_title
+                            else R.string.calendars_edit_title,
+                        ),
+                    )
+                },
+                navigationIcon = {
+                    IconButton(onClick = onClose) {
+                        Icon(
+                            Icons.Default.Close,
+                            contentDescription = stringResource(R.string.event_edit_close),
+                        )
+                    }
+                },
+                actions = {
+                    if (!isNew) {
+                        // Disabled rather than hidden while the special-dates
+                        // sync owns this calendar; the card below says why.
+                        IconButton(
+                            onClick = { confirmDelete = true },
+                            enabled = !deleteLocked,
+                        ) {
+                            Icon(
+                                Icons.Default.Delete,
+                                contentDescription = stringResource(R.string.event_detail_delete),
+                                tint = if (deleteLocked) {
+                                    MaterialTheme.colorScheme.onSurface.copy(alpha = 0.38f)
+                                } else {
+                                    MaterialTheme.colorScheme.error
+                                },
+                            )
+                        }
+                    }
+                    // Filled save button, matching the event editor's top bar.
+                    Button(
+                        onClick = {
+                            onSave(name.trim(), color, description.trim().ifEmpty { null })
+                        },
+                        enabled = name.isNotBlank(),
+                        modifier = Modifier.padding(end = 12.dp),
+                    ) {
+                        Text(stringResource(R.string.event_edit_save))
+                    }
+                },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = MaterialTheme.colorScheme.surface,
+                ),
+            )
         },
-    ) {
-        if (deleteLocked) {
-            ManagedNote()
-            Spacer(Modifier.height(20.dp))
-        }
-
-        CalendarNameField(
-            name = name,
-            color = color,
-            focusRequester = focusRequester,
-            onNameChange = { name = it },
-            onImeAction = commit,
-        )
-        // Inside the picker: it is a Dialog, so a request made from the caller's
-        // composition can run before this field's node exists.
-        // A new calendar opens with the keyboard up: naming it is the whole task.
-        LaunchedEffect(isNew) { if (isNew) focusRequester.requestFocus() }
-
-        Spacer(Modifier.height(20.dp))
-        EditorSectionLabel(stringResource(R.string.calendars_color_label))
-        CalendarColorGrid(selected = color, onSelect = { color = it })
-
-        Spacer(Modifier.height(20.dp))
-        EditorSectionLabel(stringResource(R.string.calendars_description_label))
-        GroupedSurface(position = Position.Alone, modifier = Modifier.padding(horizontal = 16.dp)) {
-            Box(Modifier.fillMaxWidth().heightIn(min = 72.dp).padding(16.dp)) {
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .padding(innerPadding)
+                .fillMaxSize()
+                .verticalScroll(rememberScrollState())
+                .padding(horizontal = 16.dp, vertical = 8.dp),
+            verticalArrangement = Arrangement.spacedBy(12.dp),
+        ) {
+            if (deleteLocked) {
+                EditorCard(
+                    icon = Icons.Default.Info,
+                    iconTint = MaterialTheme.colorScheme.onSurfaceVariant,
+                    iconAtTop = true,
+                ) {
+                    Text(
+                        text = stringResource(R.string.calendars_managed_delete_locked),
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                }
+            }
+            EditorCard(icon = Icons.Default.CalendarMonth, iconTint = eventAccent(color, dark, soften)) {
+                InlineTextField(
+                    value = name,
+                    onValueChange = { name = it },
+                    placeholder = stringResource(R.string.calendars_name_label),
+                    textStyle = MaterialTheme.typography.titleLarge,
+                    capitalization = KeyboardCapitalization.Sentences,
+                )
+            }
+            EditorCard(
+                icon = Icons.Default.Palette,
+                iconTint = MaterialTheme.colorScheme.onSurfaceVariant,
+                iconAtTop = true,
+            ) {
+                Text(
+                    text = stringResource(R.string.calendars_color_label),
+                    style = MaterialTheme.typography.labelLarge,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+                Spacer(Modifier.height(12.dp))
+                ColorSwatchRow(
+                    colors = CalendarColorPalette.all,
+                    selected = color,
+                    onSelect = { color = it },
+                    dark = dark,
+                )
+            }
+            EditorCard(
+                icon = Icons.AutoMirrored.Filled.Notes,
+                iconTint = MaterialTheme.colorScheme.onSurfaceVariant,
+                iconAtTop = true,
+            ) {
                 InlineTextField(
                     value = description,
                     onValueChange = { description = it },
@@ -435,21 +485,20 @@ internal fun CalendarEditor(
                 )
             }
         }
-
-        if (!isNew && !deleteLocked) {
-            Spacer(Modifier.height(24.dp))
-            DeleteCalendarRow(onClick = { confirmDelete = true })
-        }
-        Spacer(Modifier.height(24.dp))
     }
 
     if (confirmDelete) {
         AlertDialog(
             onDismissRequest = { confirmDelete = false },
             title = { Text(stringResource(R.string.calendars_delete_confirm_title)) },
-            text = { Text(stringResource(R.string.calendars_delete_confirm_message, initialName)) },
+            text = {
+                Text(stringResource(R.string.calendars_delete_confirm_message, initialName))
+            },
             confirmButton = {
-                TextButton(onClick = { confirmDelete = false; onDelete() }) {
+                TextButton(onClick = {
+                    confirmDelete = false
+                    onDelete()
+                }) {
                     Text(
                         stringResource(R.string.event_detail_delete),
                         color = MaterialTheme.colorScheme.error,
@@ -465,205 +514,6 @@ internal fun CalendarEditor(
     }
 }
 
-/** The name, with the chosen colour beside it so the two read as one thing. */
-@Composable
-private fun CalendarNameField(
-    name: String,
-    color: Int,
-    focusRequester: FocusRequester,
-    onNameChange: (String) -> Unit,
-    onImeAction: () -> Unit,
-) {
-    val dark = isSystemInDarkTheme()
-    val soften = LocalSoftenColors.current
-    GroupedSurface(position = Position.Alone, modifier = Modifier.padding(horizontal = 16.dp)) {
-        Row(
-            modifier = Modifier.fillMaxWidth().heightIn(min = 72.dp).padding(horizontal = 16.dp),
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.spacedBy(16.dp),
-        ) {
-            Box(
-                modifier = Modifier
-                    .size(40.dp)
-                    .clip(CircleShape)
-                    .background(MaterialTheme.colorScheme.surfaceContainerHighest),
-                contentAlignment = Alignment.Center,
-            ) {
-                Icon(
-                    Icons.Default.CalendarMonth,
-                    contentDescription = null,
-                    tint = eventAccent(color, dark, soften),
-                    modifier = Modifier.size(22.dp),
-                )
-            }
-            InlineTextField(
-                value = name,
-                onValueChange = onNameChange,
-                placeholder = stringResource(R.string.calendars_name_label),
-                capitalization = KeyboardCapitalization.Sentences,
-                imeAction = ImeAction.Done,
-                onImeAction = onImeAction,
-                modifier = Modifier.fillMaxWidth().focusRequester(focusRequester),
-            )
-        }
-    }
-}
-
-/**
- * The palette as two rows of round swatches; the chosen one carries a check.
- *
- * Drawn through the app's own tone pass rather than raw, so a swatch is the
- * colour the calendar's events will actually appear in — the user's "soften
- * colours" preference included.
- */
-@Composable
-private fun CalendarColorGrid(selected: Int, onSelect: (Int) -> Unit) {
-    val dark = isSystemInDarkTheme()
-    val soften = LocalSoftenColors.current
-    GroupedSurface(position = Position.Alone, modifier = Modifier.padding(horizontal = 16.dp)) {
-        Column(
-            modifier = Modifier
-                .padding(horizontal = 12.dp, vertical = 16.dp)
-                .selectableGroup(),
-            verticalArrangement = Arrangement.spacedBy(12.dp),
-        ) {
-            CalendarColorPalette.all.chunked(SWATCHES_PER_ROW).forEach { row ->
-                Row(
-                    modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.spacedBy(8.dp),
-                ) {
-                    row.forEach { swatch ->
-                        ColorSwatch(
-                            fill = eventFill(swatch, dark, soften),
-                            label = stringResource(swatchLabel(swatch)),
-                            selected = swatch == selected,
-                            onClick = { onSelect(swatch) },
-                            modifier = Modifier.weight(1f),
-                        )
-                    }
-                    // Keeps a short final row's swatches the size a full row's
-                    // are, rather than stretching them across the width.
-                    repeat(SWATCHES_PER_ROW - row.size) { Spacer(Modifier.weight(1f)) }
-                }
-            }
-        }
-    }
-}
-
-@Composable
-private fun ColorSwatch(
-    fill: Color,
-    label: String,
-    selected: Boolean,
-    onClick: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    Box(
-        modifier = modifier
-            .aspectRatio(1f)
-            .clip(CircleShape)
-            .background(fill)
-            .then(
-                if (selected) {
-                    Modifier.border(2.dp, MaterialTheme.colorScheme.onSurface, CircleShape)
-                } else {
-                    Modifier
-                },
-            )
-            // selectable, not clickable: the swatch carries its chosen state in
-            // semantics too, so the check is not the only cue.
-            .selectable(selected = selected, role = Role.RadioButton, onClick = onClick)
-            .semantics { contentDescription = label },
-        contentAlignment = Alignment.Center,
-    ) {
-        if (selected) {
-            Icon(
-                Icons.Default.Check,
-                contentDescription = null,
-                tint = eventInk(fill, alpha = 0.7f),
-                modifier = Modifier.size(22.dp),
-            )
-        }
-    }
-}
-
-/** Names the swatch for a screen reader — twelve circles are otherwise one label. */
-@StringRes
-private fun swatchLabel(argb: Int): Int = when (argb) {
-    CalendarColorPalette.Mauve -> R.string.color_name_mauve
-    CalendarColorPalette.Red -> R.string.color_name_red
-    CalendarColorPalette.Orange -> R.string.color_name_orange
-    CalendarColorPalette.Amber -> R.string.color_name_amber
-    CalendarColorPalette.Olive -> R.string.color_name_olive
-    CalendarColorPalette.Green -> R.string.color_name_green
-    CalendarColorPalette.Teal -> R.string.color_name_teal
-    CalendarColorPalette.Cyan -> R.string.color_name_cyan
-    CalendarColorPalette.Blue -> R.string.color_name_blue
-    CalendarColorPalette.Indigo -> R.string.color_name_indigo
-    CalendarColorPalette.Purple -> R.string.color_name_purple
-    else -> R.string.color_name_pink
-}
-
-/** Said in the sheet rather than on a disabled button: the sync owns this one. */
-@Composable
-private fun ManagedNote() {
-    GroupedSurface(
-        position = Position.Alone,
-        modifier = Modifier.padding(horizontal = 16.dp),
-        color = MaterialTheme.colorScheme.surfaceVariant,
-    ) {
-        Row(
-            modifier = Modifier.fillMaxWidth().heightIn(min = 64.dp).padding(20.dp),
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.spacedBy(16.dp),
-        ) {
-            Icon(Icons.Default.Info, contentDescription = null)
-            Text(
-                text = stringResource(R.string.calendars_managed_delete_locked),
-                style = MaterialTheme.typography.bodyMedium,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-            )
-        }
-    }
-}
-
-@Composable
-private fun DeleteCalendarRow(onClick: () -> Unit) {
-    GroupedSurface(
-        position = Position.Alone,
-        modifier = Modifier.padding(horizontal = 16.dp),
-        onClick = onClick,
-        color = MaterialTheme.colorScheme.errorContainer,
-    ) {
-        Row(
-            modifier = Modifier.fillMaxWidth().heightIn(min = 64.dp).padding(horizontal = 20.dp),
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.spacedBy(16.dp),
-        ) {
-            Icon(
-                Icons.Default.Delete,
-                contentDescription = null,
-                tint = MaterialTheme.colorScheme.onErrorContainer,
-            )
-            Text(
-                text = stringResource(R.string.event_detail_delete),
-                style = MaterialTheme.typography.bodyLarge,
-                color = MaterialTheme.colorScheme.onErrorContainer,
-            )
-        }
-    }
-}
-
-@Composable
-private fun EditorSectionLabel(text: String) {
-    Text(
-        text = text,
-        style = MaterialTheme.typography.labelMedium,
-        color = MaterialTheme.colorScheme.onSurfaceVariant,
-        modifier = Modifier.padding(start = 28.dp, end = 28.dp, bottom = 8.dp),
-    )
-}
-
 /**
  * The row's supporting line: the states that make this calendar behave unlike a
  * plain writable one (#76), then its own description.
@@ -706,6 +556,36 @@ private fun EnableSwitch(
 private fun dimIf(disabled: Boolean): Modifier =
     if (disabled) Modifier.alpha(0.38f) else Modifier
 
+/** Tonal field card matching the event editor's design (icon + content). */
+@Composable
+private fun EditorCard(
+    icon: ImageVector,
+    iconTint: Color,
+    iconAtTop: Boolean = false,
+    content: @Composable () -> Unit,
+) {
+    Surface(
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
+        shape = RoundedCornerShape(16.dp),
+        modifier = Modifier.fillMaxWidth(),
+    ) {
+        Row(
+            modifier = Modifier.padding(16.dp),
+            verticalAlignment = if (iconAtTop) Alignment.Top else Alignment.CenterVertically,
+        ) {
+            Icon(
+                imageVector = icon,
+                contentDescription = null,
+                tint = iconTint,
+                modifier = Modifier
+                    .padding(top = if (iconAtTop) 2.dp else 0.dp)
+                    .size(24.dp),
+            )
+            Spacer(Modifier.width(16.dp))
+            Column(modifier = Modifier.weight(1f)) { content() }
+        }
+    }
+}
 
 /**
  * One collapsible calendar group rendered as a connected card. The header row is

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsViewModel.kt

@@ -14,7 +14,6 @@ import de.jeanlucmakiola.calendula.data.ics.IcsExporter
 import de.jeanlucmakiola.calendula.data.prefs.BackupStatus
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -25,7 +24,6 @@ import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -58,22 +56,6 @@ class CalendarsViewModel @Inject constructor(
                 initialValue = emptyList(),
             )
 
-    /**
-     * The Backup & restore screen's own view of that list, with the loading and
-     * failure states [calendars] flattens away — it starts empty and catches to
-     * empty, which that screen used to render as a blank page (#304).
-     */
-    val backupState: StateFlow<BackupUiState> =
-        repository.calendars()
-            .map { backupUiState(it) }
-            .catch { emit(BackupUiState.Failure(FailureReason.ProviderUnavailable)) }
-            .flowOn(io)
-            .stateIn(
-                scope = viewModelScope,
-                started = SharingStarted.WhileSubscribed(5_000L),
-                initialValue = BackupUiState.Loading,
-            )
-
     /** Automatic-backup settings + last-run status, for the Backup section UI. */
     val autoBackup: StateFlow<AutoBackupUiState> = combine(
         settingsPrefs.autoBackupEnabled,

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/AccountGroups.kt

@@ -56,14 +56,12 @@ fun List<CalendarSource>.groupByAccount(): List<CalendarAccountGroup> {
  * account comes from when another account shares the name (#77).
  */
 @Composable
-fun accountGroupTitle(group: CalendarAccountGroup): String {
-    val label = group.label.ifBlank { stringResource(R.string.calendar_unnamed) }
-    return if (!group.ambiguous) {
-        label
+fun accountGroupTitle(group: CalendarAccountGroup): String =
+    if (!group.ambiguous) {
+        group.label
     } else {
-        stringResource(R.string.calendars_account_from_source, label, sourceAppName(group.accountType))
+        stringResource(R.string.calendars_account_from_source, group.label, sourceAppName(group.accountType))
     }
-}
 
 /**
  * The human name of the app backing [accountType], falling back to the raw

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/BlockPlacement.kt

@@ -32,68 +32,6 @@ val BLOCK_TEXT_PADDING = 4.dp
 /** The same, above and below — what a block's height has to pay before any text. */
 val BLOCK_TEXT_INSET = 2.dp
 
-/**
- * What a timed block of a given height has to spend on text, and what each line
- * of it costs.
- */
-@Immutable
-data class BlockTextMetrics(
-    /** Padding above and below the text — see [rememberBlockTextMetrics]. */
-    val inset: Dp,
-    /** Height left for text once [inset] is paid at both edges. */
-    val available: Dp,
-    /** What the first line of a title draws in. */
-    val titleLine: Dp,
-    /** What every title line after the first adds. */
-    val titleLeading: Dp,
-    /** What the time label's one line draws in. */
-    val timeLine: Dp,
-) {
-    /** Whether the block can draw a title at all. */
-    val fitsTitle: Boolean get() = available >= titleLine
-
-    /** Height a title of [lines] lines occupies. */
-    fun titleHeight(lines: Int): Dp =
-        if (lines <= 0) 0.dp else titleLine + titleLeading * (lines - 1)
-
-    /** Title lines that fit [within], which may be none. */
-    fun titleBudget(within: Dp): Int =
-        if (within < titleLine) 0 else 1 + ((within - titleLine) / titleLeading).toInt()
-}
-
-/**
- * The vertical padding a block [height] tall can afford around a title line of
- * [titleLine].
- *
- * The inset is what the block gives up first: breathing room is worth having
- * where there is room to breathe, but on a block down to its last few pixels a
- * bare colour chip where a label would have fit reads as a rendering fault. It
- * tapers rather than snapping, so a pinch closes the gap gradually instead of
- * dropping it in one frame (#289).
- */
-internal fun blockTextInset(height: Dp, titleLine: Dp): Dp =
-    minOf(BLOCK_TEXT_INSET, (height - titleLine) / 2).coerceAtLeast(0.dp)
-
-/** Text metrics for a timed block [height] tall. */
-@Composable
-fun rememberBlockTextMetrics(height: Dp): BlockTextMetrics {
-    val titleStyle = MaterialTheme.typography.labelMedium
-    val titleLine = rememberTrimmedLineHeight(titleStyle)
-    // Packed, so a second line costs what the first did rather than a whole
-    // Material line box — the gap between two lines of a wrapped title is the
-    // one place a block pays that leading twice (#190).
-    val titleLeading = titleLine
-    val timeLine = rememberTrimmedLineHeight(MaterialTheme.typography.labelSmall.asEventTime())
-    val inset = blockTextInset(height, titleLine)
-    return BlockTextMetrics(
-        inset = inset,
-        available = height - inset * 2,
-        titleLine = titleLine,
-        titleLeading = titleLeading,
-        timeLine = timeLine,
-    )
-}
-
 /** Most lines a time label may wrap over before it is worth more than a title line. */
 const val MAX_TIME_LINES = 2
 
@@ -132,9 +70,9 @@ fun blockTextLines(text: String, style: TextStyle, textWidth: Dp, max: Int): Int
  */
 @Composable
 fun blockTimeLines(label: String, textWidth: Dp, spare: Dp): Int {
-    val timeLineHeight = rememberTrimmedLineHeight(
-        MaterialTheme.typography.labelSmall.asEventTime(),
-    )
+    val timeLineHeight = with(LocalDensity.current) {
+        MaterialTheme.typography.labelSmall.lineHeight.toDp()
+    }
     return if (spare >= timeLineHeight) {
         blockTextLines(
             text = label,
@@ -170,10 +108,8 @@ fun BlockTitle(
     Text(
         text = title,
         modifier = modifier,
-        style = rememberPackedLines(
-            MaterialTheme.typography.labelMedium
-                .let { if (fontWeight == null) it else it.copy(fontWeight = fontWeight) },
-        ),
+        style = MaterialTheme.typography.labelMedium
+            .let { if (fontWeight == null) it else it.copy(fontWeight = fontWeight) },
         maxLines = maxLines,
         overflow = overflow.overflow,
         softWrap = overflow.softWrap,
@@ -205,8 +141,6 @@ fun BlockTimeLabel(
         MaterialTheme.motionScheme.fastEffectsSpec()
     }
     val overflow = eventTitleOverflow(singleLine = maxLines == 1)
-    // Regular weight against the title's medium above it (#219).
-    val style = rememberPackedLines(MaterialTheme.typography.labelSmall.asEventTime())
     Crossfade(
         targetState = label,
         animationSpec = spec,
@@ -215,7 +149,8 @@ fun BlockTimeLabel(
     ) { text ->
         Text(
             text = text,
-            style = style,
+            // Regular weight against the title's medium above it (#219).
+            style = MaterialTheme.typography.labelSmall.asEventTime(),
             maxLines = maxLines,
             overflow = overflow.overflow,
             softWrap = overflow.softWrap,

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarDrawer.kt

@@ -91,7 +91,7 @@ fun CalendarDrawer(
             DrawerSectionHeader(stringResource(R.string.view_section))
             viewOrder.forEachIndexed { index, view ->
                 GroupedRow(
-                    title = view.label(),
+                    title = stringResource(view.labelRes),
                     position = positionOf(index, viewOrder.size),
                     selected = view == currentView,
                     minHeight = 56.dp,

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarFailure.kt

@@ -4,36 +4,19 @@ import android.content.Context
 import android.content.Intent
 import android.provider.CalendarContract
 import android.provider.Settings
-import androidx.annotation.StringRes
-import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.widthIn
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.CalendarMonth
-import androidx.compose.material.icons.outlined.EditOff
-import androidx.compose.material.icons.outlined.ErrorOutline
-import androidx.compose.material.icons.outlined.EventBusy
-import androidx.compose.material.icons.outlined.Lock
-import androidx.compose.material.icons.outlined.SyncProblem
-import androidx.compose.material.icons.outlined.VisibilityOff
 import androidx.compose.material3.FilledTonalButton
-import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.compositionLocalOf
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
@@ -43,150 +26,52 @@ import de.jeanlucmakiola.calendula.domain.FailureReason
 
 /**
  * Full-screen failure state shared by every calendar screen (spec §7).
- * A tonal icon, one headline, one supporting line and one recovery action —
- * never a toast.
+ * One explanation line + one recovery action, never a toast.
  */
 @Composable
-fun CalendarFailure(
-    reason: FailureReason,
-    onRetry: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
+fun CalendarFailure(reason: FailureReason, onRetry: () -> Unit) {
     val context = LocalContext.current
     val manageCalendars = LocalManageCalendars.current
-    val copy = failureCopy(reason)
+    val titleRes = when (reason) {
+        FailureReason.PermissionRevoked -> R.string.state_failure_permission
+        FailureReason.NoCalendarsConfigured -> R.string.state_failure_no_calendars
+        FailureReason.AllCalendarsHidden -> R.string.state_failure_all_hidden
+        FailureReason.ProviderUnavailable -> R.string.state_failure_provider
+        FailureReason.Unknown,
+        FailureReason.EventNotFound -> R.string.state_failure_unknown
+    }
+    val actionRes = when (reason) {
+        FailureReason.NoCalendarsConfigured -> R.string.state_failure_no_calendars_action
+        FailureReason.AllCalendarsHidden -> R.string.state_failure_all_hidden_action
+        FailureReason.PermissionRevoked -> R.string.state_failure_permission_action
+        else -> R.string.state_retry
+    }
     val onAction: () -> Unit = when (reason) {
         FailureReason.NoCalendarsConfigured -> {
             { context.startCalendarSetup() }
         }
-        FailureReason.AllCalendarsHidden,
-        FailureReason.NoImportTarget,
-        -> manageCalendars ?: onRetry
+        FailureReason.AllCalendarsHidden -> manageCalendars ?: onRetry
         else -> onRetry
     }
     Column(
-        modifier = modifier
+        modifier = Modifier
             .fillMaxSize()
-            .padding(horizontal = 32.dp, vertical = 24.dp),
+            .padding(32.dp),
         verticalArrangement = Arrangement.Center,
         horizontalAlignment = Alignment.CenterHorizontally,
     ) {
-        FailureIcon(icon = copy.icon, isError = copy.isError)
-        Spacer(Modifier.height(24.dp))
         Text(
-            text = stringResource(copy.title),
+            text = stringResource(titleRes),
             style = MaterialTheme.typography.headlineSmall,
             textAlign = TextAlign.Center,
-            modifier = Modifier.widthIn(max = TEXT_MAX_WIDTH),
         )
-        copy.body?.let { body ->
-            Spacer(Modifier.height(12.dp))
-            Text(
-                text = stringResource(body),
-                style = MaterialTheme.typography.bodyMedium,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                textAlign = TextAlign.Center,
-                modifier = Modifier.widthIn(max = TEXT_MAX_WIDTH),
-            )
-        }
-        Spacer(Modifier.height(32.dp))
+        Spacer(Modifier.height(24.dp))
         FilledTonalButton(onClick = onAction) {
-            Text(stringResource(copy.action))
+            Text(stringResource(actionRes))
         }
     }
 }
 
-/** The state's mark: the reason's icon in a tonal circle above the headline. */
-@Composable
-private fun FailureIcon(icon: ImageVector, isError: Boolean) {
-    val container: Color
-    val content: Color
-    if (isError) {
-        container = MaterialTheme.colorScheme.errorContainer
-        content = MaterialTheme.colorScheme.onErrorContainer
-    } else {
-        container = MaterialTheme.colorScheme.secondaryContainer
-        content = MaterialTheme.colorScheme.onSecondaryContainer
-    }
-    Box(
-        modifier = Modifier
-            .size(72.dp)
-            .background(container, CircleShape),
-        contentAlignment = Alignment.Center,
-    ) {
-        Icon(
-            imageVector = icon,
-            contentDescription = null,
-            tint = content,
-            modifier = Modifier.size(36.dp),
-        )
-    }
-}
-
-/**
- * What a reason says and offers. Headline and supporting line are separate so
- * the explanation reads as body text instead of a headline that runs over three
- * lines; [isError] tints the mark for the two reasons that are an actual fault
- * rather than a calendar the user can switch back on.
- */
-private data class FailureCopy(
-    val icon: ImageVector,
-    @StringRes val title: Int,
-    @StringRes val body: Int?,
-    @StringRes val action: Int,
-    val isError: Boolean = false,
-)
-
-private fun failureCopy(reason: FailureReason): FailureCopy = when (reason) {
-    FailureReason.PermissionRevoked -> FailureCopy(
-        icon = Icons.Outlined.Lock,
-        title = R.string.state_failure_permission,
-        body = R.string.state_failure_permission_body,
-        action = R.string.state_failure_permission_action,
-    )
-    FailureReason.NoCalendarsConfigured -> FailureCopy(
-        icon = Icons.Outlined.CalendarMonth,
-        title = R.string.state_failure_no_calendars,
-        body = R.string.state_failure_no_calendars_body,
-        action = R.string.state_failure_no_calendars_action,
-    )
-    FailureReason.AllCalendarsHidden -> FailureCopy(
-        icon = Icons.Outlined.VisibilityOff,
-        title = R.string.state_failure_all_hidden,
-        body = R.string.state_failure_all_hidden_body,
-        action = R.string.state_failure_all_hidden_action,
-    )
-    FailureReason.NoImportTarget -> FailureCopy(
-        icon = Icons.Outlined.EditOff,
-        title = R.string.state_failure_no_import_target,
-        body = R.string.state_failure_no_import_target_body,
-        action = R.string.state_failure_all_hidden_action,
-    )
-    FailureReason.EventNotFound -> FailureCopy(
-        icon = Icons.Outlined.EventBusy,
-        title = R.string.state_failure_event_not_found,
-        body = R.string.state_failure_event_not_found_body,
-        action = R.string.state_retry,
-    )
-    FailureReason.ProviderUnavailable -> FailureCopy(
-        icon = Icons.Outlined.SyncProblem,
-        title = R.string.state_failure_provider,
-        body = R.string.state_failure_provider_body,
-        action = R.string.state_retry,
-        isError = true,
-    )
-    FailureReason.Unknown -> FailureCopy(
-        icon = Icons.Outlined.ErrorOutline,
-        title = R.string.state_failure_unknown,
-        body = null,
-        action = R.string.state_retry,
-        isError = true,
-    )
-}
-
-/** Keeps the headline and its supporting line at a readable measure. */
-private val TEXT_MAX_WIDTH = 320.dp
-
 /**
  * Opens Settings → Calendars, the only screen that can switch a calendar back
  * on. Null outside the calendar host — screens without it never raise the

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarPager.kt

@@ -1,57 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.FiniteAnimationSpec
-import androidx.compose.animation.core.VectorConverter
-import androidx.compose.foundation.pager.PagerState
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberUpdatedState
-import androidx.compose.runtime.snapshotFlow
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.lerp
-import kotlinx.coroutines.flow.collectLatest
-import kotlin.math.floor
-
-/**
- * One height for every page of something that varies from page to page — the
- * timelines' all-day strip, the split grid's rows — blended between the two
- * pages a swipe sits between, so what sits below it moves with the finger rather
- * than jumping on settle. It follows the swipe directly and only springs when a
- * page's own height changes at rest. [fallback] stands in until the pages have
- * reported theirs, so it doesn't open from zero.
- *
- * @param heights each composed page's own height, by page index.
- */
-@Composable
-fun pagedHeight(pagerState: PagerState, heights: Map<Int, Dp>, fallback: Dp): Dp {
-    val currentFallback by rememberUpdatedState(fallback)
-    val target by remember(pagerState, heights) {
-        derivedStateOf {
-            val position = pagerState.currentPage + pagerState.currentPageOffsetFraction
-            val from = floor(position).toInt()
-            val a = heights[from]
-            val b = heights[from + 1]
-            lerp(a ?: b ?: currentFallback, b ?: a ?: currentFallback, position - from)
-        }
-    }
-    val height = remember { Animatable(target, Dp.VectorConverter) }
-    LaunchedEffect(height) {
-        snapshotFlow { target to pagerState.isScrollInProgress }.collectLatest { (h, scrolling) ->
-            if (scrolling) height.snapTo(h) else height.animateTo(h)
-        }
-    }
-    return height.value
-}
-
-/** A deliberate jump (Today, jump-to-date): animated, or snapped under reduced motion. */
-suspend fun PagerState.jumpToPage(
-    page: Int,
-    reduceMotion: Boolean,
-    spec: FiniteAnimationSpec<Float>,
-) {
-    if (reduceMotion) scrollToPage(page) else animateScrollToPage(page, animationSpec = spec)
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarPickerGroups.kt

@@ -116,7 +116,7 @@ private fun CalendarPickerGroup(
     calendars.forEachIndexed { index, calendar ->
         val isSelected = calendar.id == selectedId
         GroupedRow(
-            title = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
+            title = calendar.displayName,
             position = if (index == calendars.lastIndex) Position.Bottom else Position.Middle,
             selected = isSelected,
             leading = { CalendarColorChip(calendar.color) },

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarSwipe.kt

@@ -0,0 +1,79 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.gestures.detectHorizontalDragGestures
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.dp
+
+/**
+ * Drag distance that turns a calendar page, shared by the month, week and day
+ * views so all three answer a swipe at the same point.
+ *
+ * It was 6dp once, which is inside the distance a tap wanders: brushing the grid
+ * changed the month, and a page that turns on an unintended gesture reads as the
+ * animation misfiring rather than as the gesture being over-eager.
+ */
+val CALENDAR_SWIPE_THRESHOLD = 24.dp
+
+/**
+ * The whole-page horizontal swipe: one page per gesture, committed **the moment
+ * the drag clears [CALENDAR_SWIPE_THRESHOLD]** rather than when the finger lifts.
+ *
+ * Waiting for the lift meant the page sat still under a finger that had already
+ * travelled far enough to ask for it, and the answer only arrived once you let
+ * go — which reads as the view being slow rather than as a deliberate commit.
+ * Firing on the threshold is what makes the gesture feel like it is being
+ * followed. The trade is that a drag can no longer be taken back by dragging the
+ * other way; in practice, once you have moved 24dp deliberately you meant it, and
+ * the page you land on is one swipe back.
+ *
+ * Deliberately **horizontal-only**. The week and day timelines scroll vertically
+ * underneath this, and a two-dimensional detector here would claim those drags
+ * before the inner scroll ever saw them. As it is, a horizontal drag crosses this
+ * detector's slop while a vertical one is consumed below, and the two coexist.
+ * (The month view's split style needs a vertical axis as well, so it keeps its
+ * own axis-locking detector rather than using this.)
+ */
+@Composable
+fun rememberCalendarPageSwipe(
+    onSwipeNext: () -> Unit,
+    onSwipePrev: () -> Unit,
+): Modifier {
+    val threshold = with(LocalDensity.current) { CALENDAR_SWIPE_THRESHOLD.toPx() }
+    return Modifier.pointerInput(onSwipeNext, onSwipePrev) {
+        var accum = 0f
+        // One page per gesture: without this a long drag would keep re-firing
+        // every time the accumulator crossed the threshold again.
+        var fired = false
+        detectHorizontalDragGestures(
+            onDragStart = {
+                accum = 0f
+                fired = false
+            },
+            onDragEnd = {
+                accum = 0f
+                fired = false
+            },
+            onDragCancel = {
+                accum = 0f
+                fired = false
+            },
+            onHorizontalDrag = { _, drag ->
+                accum += drag
+                if (!fired) {
+                    val commit = when {
+                        accum < -threshold -> onSwipeNext
+                        accum > threshold -> onSwipePrev
+                        else -> null
+                    }
+                    if (commit != null) {
+                        fired = true
+                        commit()
+                    }
+                }
+            },
+        )
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarText.kt

@@ -1,57 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.rememberTextMeasurer
-import androidx.compose.ui.text.style.LineHeightStyle
-import androidx.compose.ui.unit.Dp
-
-/**
- * The calendar surfaces' line-height treatment. Material wraps an 11sp glyph in
- * a 16sp line box — room a label wants when it stands on its own, and close to
- * a fifth of an event row when it doesn't. The outer edges only, so a wrapped
- * title keeps its interior line spacing (#190).
- *
- * Trimmed rather than set to a smaller line height: the font picker can load a
- * serif, a monospace or a file of the user's own, and a line height under a
- * face's own ascent and descent overlaps its lines. There is nothing to trim
- * below that, so this is safe whatever font is chosen.
- */
-private val TrimmedLines = LineHeightStyle(
-    alignment = LineHeightStyle.Alignment.Center,
-    trim = LineHeightStyle.Trim.Both,
-)
-
-/** Ascenders and descenders both, so a line is measured at its full extent. */
-private const val LINE_SAMPLE = "Ag"
-
-/** [this] with Material's outer leading trimmed — see [TrimmedLines]. */
-fun TextStyle.trimmedLines(): TextStyle = copy(lineHeightStyle = TrimmedLines)
-
-/**
- * [style] with its wrapped lines packed onto the face's own extent instead of
- * Material's line box.
- *
- * [trimmedLines] takes the leading off the outer edges of a run of text; this
- * takes it from between the lines as well, which is the half a wrapped event
- * title pays for twice over. The line height is *measured* from the font rather
- * than picked, so it lands exactly on the face's ascent-plus-descent and can
- * never be short enough to overlap — whatever the font picker has loaded (#190).
- */
-@Composable
-fun rememberPackedLines(style: TextStyle): TextStyle {
-    val line = rememberTrimmedLineHeight(style)
-    return with(LocalDensity.current) { style.trimmedLines().copy(lineHeight = line.toSp()) }
-}
-
-/** What one trimmed line of [style] actually draws in. */
-@Composable
-fun rememberTrimmedLineHeight(style: TextStyle): Dp {
-    val measurer = rememberTextMeasurer()
-    val density = LocalDensity.current
-    return remember(style, density, measurer) {
-        with(density) { measurer.measure(LINE_SAMPLE, style.trimmedLines()).size.height.toDp() }
-    }
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarTransitions.kt

@@ -1,6 +1,13 @@
 package de.jeanlucmakiola.calendula.ui.common
 
+import androidx.compose.animation.ContentTransform
+import androidx.compose.animation.SizeTransform
 import androidx.compose.animation.core.FiniteAnimationSpec
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.slideInHorizontally
+import androidx.compose.animation.slideOutHorizontally
+import androidx.compose.animation.togetherWith
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
@@ -12,12 +19,12 @@ import androidx.compose.ui.unit.IntOffset
  * the reduce-motion check — now live in floret-kit's identity module
  * (`expandEnter`, `collapseExit`, `itemEnter`, `animateItemMotion`,
  * `fadeThrough`, `Modifier.predictiveBack`, `rememberReduceMotion`). What stays
- * here is only what's specific to paging the calendar grid: the specs its
- * pagers settle with, and that the view switch reuses.
+ * here is only what's specific to paging the calendar grid: the directional
+ * month/week/day slide and the specs that feed it.
  */
 
 /**
- * The M3 Expressive spatial spring the calendar's motion is built on: the
+ * The M3 Expressive spatial spring used for the month/week/day slide: the
  * *default* spring-physics spec from the active motion scheme, rather than a
  * fixed easing curve.
  *
@@ -33,12 +40,6 @@ import androidx.compose.ui.unit.IntOffset
 fun rememberCalendarSlideSpec(): FiniteAnimationSpec<IntOffset> =
     MaterialTheme.motionScheme.defaultSpatialSpec()
 
-/** The same spring as [rememberCalendarSlideSpec], for a pager settling onto its page. */
-@OptIn(ExperimentalMaterial3ExpressiveApi::class)
-@Composable
-fun rememberCalendarPageSpec(): FiniteAnimationSpec<Float> =
-    MaterialTheme.motionScheme.defaultSpatialSpec()
-
 /**
  * The effects spec from the active motion scheme, for the opacity half of the
  * transition. Captured in composable scope alongside [rememberCalendarSlideSpec]
@@ -52,3 +53,50 @@ fun rememberCalendarPageSpec(): FiniteAnimationSpec<Float> =
 @Composable
 fun rememberCalendarFadeSpec(): FiniteAnimationSpec<Float> =
     MaterialTheme.motionScheme.defaultEffectsSpec()
+
+/**
+ * Navigating between adjacent months/weeks/days, as M3's shared-axis X: the
+ * outgoing page slides and fades one way while the incoming one arrives from the
+ * other, position on a spring and opacity on an easing curve.
+ *
+ * @param slideDir     +1 = forward (incoming from the right), -1 = back, 0 = jump
+ *                     (e.g. "today"); a jump reuses the forward direction.
+ * @param spec         spatial animation spec, typically [rememberCalendarSlideSpec].
+ * @param fadeSpec     effects spec for the opacity half, and for the whole
+ *                     transition under reduced motion; typically
+ *                     [rememberCalendarFadeSpec].
+ * @param reduceMotion when true, drop the movement and cross-fade alone.
+ */
+fun calendarSlideTransition(
+    slideDir: Int,
+    spec: FiniteAnimationSpec<IntOffset>,
+    fadeSpec: FiniteAnimationSpec<Float>,
+    reduceMotion: Boolean,
+): ContentTransform {
+    if (reduceMotion) {
+        return fadeIn(fadeSpec).togetherWith(fadeOut(fadeSpec))
+    }
+    val dir = if (slideDir == 0) 1 else slideDir
+    return ContentTransform(
+        targetContentEnter =
+            slideInHorizontally(spec) { w -> dir * w / SLIDE_TRAVEL_DIVISOR } + fadeIn(fadeSpec),
+        initialContentExit =
+            slideOutHorizontally(spec) { w -> -dir * w / SLIDE_TRAVEL_DIVISOR } + fadeOut(fadeSpec),
+        // AnimatedContent clips to the animating container by default, which
+        // shears the pages against the viewport edge as they pass. There is no
+        // size change here to contain — both pages are the same grid.
+        sizeTransform = SizeTransform(clip = false),
+    )
+}
+
+/**
+ * How far a page travels, as a fraction of the container width.
+ *
+ * A full width was the obvious reading of "paging", but the two pages are
+ * stacked and both opaque, so a full-width slide showed one grid racing across
+ * another — the movement carried the whole transition and had a long way to go.
+ * Under M3's shared-axis pattern the offset only has to *hint* the direction
+ * while the cross-fade does the swapping, so a fifth of the width is plenty and
+ * leaves nothing skating past.
+ */
+private const val SLIDE_TRAVEL_DIVISOR = 5

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarView.kt

@@ -1,53 +1,37 @@
 package de.jeanlucmakiola.calendula.ui.common
 
+import androidx.annotation.StringRes
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.CalendarViewDay
 import androidx.compose.material.icons.filled.CalendarViewMonth
 import androidx.compose.material.icons.filled.CalendarViewWeek
 import androidx.compose.material.icons.filled.ViewAgenda
-import androidx.compose.material.icons.filled.ViewColumn
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.res.pluralStringResource
-import androidx.compose.ui.res.stringResource
 import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 
 /** The top-level calendar views the user can switch between (spec M1). */
 enum class CalendarView {
     Month,
     Week,
-    MultiDay,
     Day,
     Agenda,
 }
 
-/** How many days the multi-day view shows (#193), provided once at the app root. */
-val LocalMultiDayCount = staticCompositionLocalOf { SettingsPrefs.DEFAULT_MULTI_DAY_COUNT }
-
-/**
- * The view's name, shared by the top-bar pill, the drawer and Settings. The
- * multi-day view is named after its day count ("3 days").
- */
-@Composable
-fun CalendarView.label(): String = when (this) {
-    CalendarView.Month -> stringResource(R.string.view_month)
-    CalendarView.Week -> stringResource(R.string.view_week)
-    CalendarView.MultiDay -> {
-        val count = LocalMultiDayCount.current
-        pluralStringResource(R.plurals.view_multi_day, count, count)
+/** Switcher label, shared by the top-bar pill and the drawer's View section. */
+@get:StringRes
+val CalendarView.labelRes: Int
+    get() = when (this) {
+        CalendarView.Month -> R.string.view_month
+        CalendarView.Week -> R.string.view_week
+        CalendarView.Day -> R.string.view_day
+        CalendarView.Agenda -> R.string.view_agenda
     }
-    CalendarView.Day -> stringResource(R.string.view_day)
-    CalendarView.Agenda -> stringResource(R.string.view_agenda)
-}
 
 /** Leading icon for the view in the drawer's View section. */
 val CalendarView.icon: ImageVector
     get() = when (this) {
         CalendarView.Month -> Icons.Filled.CalendarViewMonth
         CalendarView.Week -> Icons.Filled.CalendarViewWeek
-        CalendarView.MultiDay -> Icons.Filled.ViewColumn
         CalendarView.Day -> Icons.Filled.CalendarViewDay
         CalendarView.Agenda -> Icons.Filled.ViewAgenda
     }
@@ -57,13 +41,7 @@ val CalendarView.icon: ImageVector
  * through these in order.
  */
 val IMPLEMENTED_VIEWS: List<CalendarView> =
-    listOf(
-        CalendarView.Month,
-        CalendarView.Week,
-        CalendarView.MultiDay,
-        CalendarView.Day,
-        CalendarView.Agenda,
-    )
+    listOf(CalendarView.Month, CalendarView.Week, CalendarView.Day, CalendarView.Agenda)
 
 /** Next view in [available], wrapping around. Falls back to Month if absent. */
 fun CalendarView.next(available: List<CalendarView> = IMPLEMENTED_VIEWS): CalendarView {

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/OutOfViewEdges.kt

@@ -1,328 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.animation.core.FiniteAnimationSpec
-import androidx.compose.foundation.ScrollState
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.BoxScope
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.offset
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.Immutable
-import androidx.compose.runtime.Stable
-import androidx.compose.runtime.SideEffect
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableFloatStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.graphicsLayer
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.semantics.Role
-import androidx.compose.ui.semantics.contentDescription
-import androidx.compose.ui.semantics.onClick
-import androidx.compose.ui.semantics.role
-import androidx.compose.ui.semantics.semantics
-import androidx.compose.ui.unit.IntOffset
-import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.calendula.ui.week.TimedBlock
-import de.jeanlucmakiola.floret.identity.rememberReduceMotion
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
-import kotlin.math.roundToInt
-
-/** Thickness of the out-of-view edge bar. */
-private val EDGE_BAR_THICKNESS = 3.dp
-
-/** Band the bar sits in, and the room a revealed event keeps from the edge. */
-private val EDGE_TOUCH_HEIGHT = 24.dp
-
-/** How far from the viewport's edge a tap on empty column still hits the bar. */
-private val EDGE_TAP_REACH = 16.dp
-
-/**
- * How far the bar sits in from the viewport's edges — enough to clear the
- * timeline's rounded 16dp corners on the outer columns.
- */
-private val EDGE_BAR_VERTICAL_INSET = 4.dp
-private val EDGE_BAR_HORIZONTAL_INSET = 6.dp
-
-/** Distance outside the viewport over which a bar fades before its event appears. */
-private val EDGE_FADE_LEAD = 24.dp
-
-/** The nearest timed blocks wholly above and below a column's viewport. */
-@Immutable
-data class OutOfViewEvents(val above: TimedBlock?, val below: TimedBlock?) {
-    companion object {
-        val None = OutOfViewEvents(null, null)
-    }
-}
-
-/** Which edge of the viewport a hidden event sits past. */
-enum class ViewportEdge { Top, Bottom }
-
-/** Where [block]'s rendered bottom lands, in minutes — short blocks keep a floor. */
-internal fun renderedEndMin(block: TimedBlock): Float =
-    maxOf(block.endMin.toFloat(), block.startMin + MIN_EVENT_FRACTION * 60f)
-
-/**
- * The blocks of one column lying out of a viewport spanning [topMin]..[bottomMin]
- * (minutes of the day), nearest first. A block leaves this set as soon as any
- * part of its rendered height enters the viewport.
- */
-fun outOfViewEvents(
-    blocks: List<TimedBlock>,
-    topMin: Float,
-    bottomMin: Float,
-): OutOfViewEvents {
-    val above = blocks
-        .filter { renderedEndMin(it) <= topMin }
-        .maxWithOrNull(compareBy<TimedBlock>({ renderedEndMin(it) }, { it.startMin }))
-    val below = blocks
-        .filter { it.startMin >= bottomMin }
-        .minWithOrNull(compareBy<TimedBlock>({ it.startMin }, { -renderedEndMin(it) }))
-    return OutOfViewEvents(above, below)
-}
-
-/**
- * The scroll offset that brings [block] into a [viewportPx]-tall viewport from
- * past [edge], with [marginPx] of room so it clears the edge bar. An event above
- * lands with its start at the top; one below lands whole at the bottom when it
- * fits, and with its start at the top when it does not.
- */
-fun revealScrollTarget(
-    block: TimedBlock,
-    edge: ViewportEdge,
-    hourPx: Float,
-    viewportPx: Int,
-    marginPx: Float,
-    maxScroll: Int,
-): Int {
-    val startPx = block.startMin / 60f * hourPx
-    val endPx = renderedEndMin(block) / 60f * hourPx
-    val target = when (edge) {
-        ViewportEdge.Top -> startPx - marginPx
-        ViewportEdge.Bottom -> minOf(endPx + marginPx - viewportPx, startPx - marginPx)
-    }
-    return target.roundToInt().coerceIn(0, maxOf(maxScroll, 0))
-}
-
-/**
- * The edge whose bar a tap at [y] (content px) lands on, if that bar is showing
- * and the tap is within [reachPx] of the viewport's edge.
- */
-fun tappedEdge(
-    events: OutOfViewEvents,
-    y: Float,
-    viewportTop: Float,
-    viewportPx: Int,
-    reachPx: Float,
-): ViewportEdge? = when {
-    events.above != null && y - viewportTop <= reachPx -> ViewportEdge.Top
-    events.below != null && viewportTop + viewportPx - y <= reachPx -> ViewportEdge.Bottom
-    else -> null
-}
-
-/** Fade while the event is still outside; never draw its bar at the boundary. */
-internal fun edgeBarAlpha(gapPx: Float, fadeLeadPx: Float): Float = when {
-    gapPx <= 0f -> 0f
-    fadeLeadPx <= 0f -> 1f
-    else -> (gapPx / fadeLeadPx).coerceIn(0f, 1f)
-}
-
-/**
- * The out-of-view state of one day column (#188): which events hide past its
- * edges, and the scroll that reveals them.
- *
- * The bars take no touches themselves, so event blocks under them keep their
- * taps and drags; the column's own tap handler offers taps to [tap] first.
- */
-@Stable
-class OutOfViewEdges internal constructor(
-    private val scrollState: ScrollState,
-    private val scope: CoroutineScope,
-) {
-    internal var blocks by mutableStateOf(emptyList<TimedBlock>())
-    internal var hourPx by mutableFloatStateOf(0f)
-    internal var fadeLeadPx by mutableFloatStateOf(0f)
-    internal var marginPx by mutableFloatStateOf(0f)
-    internal var reachPx by mutableFloatStateOf(0f)
-    internal var reduceMotion = false
-    internal var revealSpec: FiniteAnimationSpec<Float>? = null
-
-    val events: OutOfViewEvents by derivedStateOf {
-        val viewport = scrollState.viewportSize
-        if (viewport <= 0 || hourPx <= 0f) {
-            OutOfViewEvents.None
-        } else {
-            val top = scrollState.value.toFloat()
-            outOfViewEvents(
-                blocks = blocks,
-                topMin = top / hourPx * 60f,
-                bottomMin = (top + viewport) / hourPx * 60f,
-            )
-        }
-    }
-
-    /** Scrolls the event hidden past [edge] into view, if there is one. */
-    fun reveal(edge: ViewportEdge) {
-        val block = if (edge == ViewportEdge.Top) events.above else events.below
-        block ?: return
-        val target = revealScrollTarget(
-            block = block,
-            edge = edge,
-            hourPx = hourPx,
-            viewportPx = scrollState.viewportSize,
-            marginPx = marginPx,
-            maxScroll = scrollState.maxValue,
-        )
-        val spec = revealSpec
-        scope.launch {
-            if (reduceMotion || spec == null) {
-                scrollState.scrollTo(target)
-            } else {
-                scrollState.animateScrollTo(target, spec)
-            }
-        }
-    }
-
-    /** Reveals the hidden event if a tap at [y] (content px) lands on a bar. */
-    fun tap(y: Float): Boolean {
-        val edge = tappedEdge(
-            events = events,
-            y = y,
-            viewportTop = scrollState.value.toFloat(),
-            viewportPx = scrollState.viewportSize,
-            reachPx = reachPx,
-        ) ?: return false
-        reveal(edge)
-        return true
-    }
-}
-
-@Composable
-fun rememberOutOfViewEdges(
-    blocks: List<TimedBlock>,
-    scrollState: ScrollState,
-    hourPx: Float,
-): OutOfViewEdges {
-    val scope = rememberCoroutineScope()
-    val edges = remember(scrollState, scope) { OutOfViewEdges(scrollState, scope) }
-    val density = LocalDensity.current
-    val reduceMotion = rememberReduceMotion()
-    val revealSpec = rememberCalendarPageSpec()
-    SideEffect {
-        edges.blocks = blocks
-        edges.hourPx = hourPx
-        edges.fadeLeadPx = with(density) { EDGE_FADE_LEAD.toPx() }
-        edges.marginPx = with(density) { EDGE_TOUCH_HEIGHT.roundToPx().toFloat() }
-        edges.reachPx = with(density) { EDGE_TAP_REACH.toPx() }
-        edges.reduceMotion = reduceMotion
-        edges.revealSpec = revealSpec
-    }
-    return edges
-}
-
-/**
- * Thin bars at the top and bottom of a day column's visible viewport, tinted in
- * the colour of the nearest timed event hidden past that edge (#188).
- *
- * Lives inside the column's scrolling content and follows the viewport by
- * offsetting against [scrollState] at placement rather than recomposing every
- * frame. Opacity follows the gap to the hidden event and reaches zero before
- * the event enters view. Taps reach it through [OutOfViewEdges.tap]; screen
- * readers get a button.
- */
-@Composable
-fun BoxScope.OutOfViewEdgeBars(
-    edges: OutOfViewEdges,
-    scrollState: ScrollState,
-    dark: Boolean,
-) {
-    val touchPx = with(LocalDensity.current) { EDGE_TOUCH_HEIGHT.roundToPx() }
-    val events = edges.events
-    EdgeBar(
-        block = events.above,
-        edge = ViewportEdge.Top,
-        dark = dark,
-        onReveal = edges::reveal,
-        scrollState = scrollState,
-        hourPx = edges.hourPx,
-        fadeLeadPx = edges.fadeLeadPx,
-        modifier = Modifier
-            .align(Alignment.TopStart)
-            .offset { IntOffset(0, scrollState.value) },
-    )
-    EdgeBar(
-        block = events.below,
-        edge = ViewportEdge.Bottom,
-        dark = dark,
-        onReveal = edges::reveal,
-        scrollState = scrollState,
-        hourPx = edges.hourPx,
-        fadeLeadPx = edges.fadeLeadPx,
-        modifier = Modifier
-            .align(Alignment.TopStart)
-            .offset { IntOffset(0, scrollState.value + scrollState.viewportSize - touchPx) },
-    )
-}
-
-@Composable
-private fun EdgeBar(
-    block: TimedBlock?,
-    edge: ViewportEdge,
-    dark: Boolean,
-    onReveal: (ViewportEdge) -> Unit,
-    scrollState: ScrollState,
-    hourPx: Float,
-    fadeLeadPx: Float,
-    modifier: Modifier = Modifier,
-) {
-    block ?: return
-    val color = eventFill(block.event.color, dark, LocalSoftenColors.current)
-    val label = stringResource(
-        if (edge == ViewportEdge.Top) R.string.timeline_earlier_events else R.string.timeline_later_events,
-    )
-    Box(
-        modifier = modifier
-            .fillMaxWidth()
-            .height(EDGE_TOUCH_HEIGHT)
-            .graphicsLayer {
-                val gapPx = when (edge) {
-                    ViewportEdge.Top -> scrollState.value - renderedEndMin(block) / 60f * hourPx
-                    ViewportEdge.Bottom -> block.startMin / 60f * hourPx -
-                        (scrollState.value + scrollState.viewportSize)
-                }
-                alpha = edgeBarAlpha(gapPx, fadeLeadPx)
-            }
-            .semantics {
-                role = Role.Button
-                contentDescription = label
-                onClick {
-                    onReveal(edge)
-                    true
-                }
-            },
-        contentAlignment = if (edge == ViewportEdge.Top) Alignment.TopCenter else Alignment.BottomCenter,
-    ) {
-        Box(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(
-                    horizontal = EDGE_BAR_HORIZONTAL_INSET,
-                    vertical = EDGE_BAR_VERTICAL_INSET,
-                )
-                .height(EDGE_BAR_THICKNESS)
-                .background(color, CircleShape),
-        )
-    }
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/PageStateCache.kt

@@ -1,53 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.plus
-
-/**
- * One shared state per pager page — a week, a day, a month — so a page and the
- * screen's anchor read the same query, and the pages either side stay loaded
- * across a swipe.
- *
- * Every entry shares on its own job, cancelled when [keep] lets it go: a
- * `stateIn` on the ViewModel's scope would stay running, holding its last state,
- * until the ViewModel itself was cleared. Main thread only.
- *
- * @param keep whether a cached key is still worth holding once [get] asks for another.
- */
-class PageStateCache<K, S>(
-    private val scope: CoroutineScope,
-    private val initial: S,
-    private val keep: (cached: K, requested: K) -> Boolean,
-    private val load: (K) -> Flow<S>,
-) {
-    private class Entry<S>(val state: StateFlow<S>, val job: Job)
-
-    private val entries = HashMap<K, Entry<S>>()
-
-    /** The number of entries held, for tests. */
-    internal val size: Int get() = entries.size
-
-    fun get(key: K): StateFlow<S> {
-        val iterator = entries.iterator()
-        while (iterator.hasNext()) {
-            val (cached, entry) = iterator.next()
-            if (cached != key && !keep(cached, key)) {
-                entry.job.cancel()
-                iterator.remove()
-            }
-        }
-        return entries.getOrPut(key) {
-            val job = SupervisorJob(scope.coroutineContext[Job])
-            Entry(
-                state = load(key).stateIn(scope + job, SharingStarted.WhileSubscribed(5_000L), initial),
-                job = job,
-            )
-        }.state
-    }
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/TimelineDrag.kt

@@ -284,8 +284,8 @@ class TimelineGeometry {
 }
 
 /**
- * Hoisted drag state for one timeline (#68). It lives above the pager, so a
- * page change mid-drag can't strand a ghost, and the
+ * Hoisted drag state for one timeline (#68). It lives above the per-page
+ * `AnimatedContent`, so a page change mid-drag can't strand a ghost, and the
  * block it renders is drawn in an overlay, clear of the day column's clip.
  */
 @Stable
@@ -790,15 +790,20 @@ private fun DragCopy(
     val width = with(density) { sizePx.width.toDp() }
     val height = with(density) { sizePx.height.toDp() }
     val textWidth = width - (BLOCK_OUTER_INSET + BLOCK_TEXT_PADDING) * 2
+    val titleLineHeight = with(density) {
+        MaterialTheme.typography.labelMedium.lineHeight.toDp()
+    }
+    val timeLineHeight = with(density) {
+        MaterialTheme.typography.labelSmall.lineHeight.toDp()
+    }
     // The block's size, spent the block's way — text sits at the top as it does
-    // on the block, so the copy hands back to the grid without shifting (#267),
-    // and it squeezes its inset on the same terms so a short block's title does
-    // not vanish the moment it is lifted (#289).
+    // on the block, so the copy hands back to the grid without shifting (#267).
     // The title is served in full first and the range lives off what is left:
     // the hour gutter down the side still says where the copy sits, so the
     // range is the half that can afford to go.
-    val metrics = rememberBlockTextMetrics(height)
-    val allowed = titleLines.coerceAtMost(metrics.titleBudget(metrics.available))
+    val available = height - BLOCK_TEXT_INSET * 2
+    val titleBudget = (available / titleLineHeight).toInt().coerceAtLeast(0)
+    val allowed = titleLines.coerceAtMost(titleBudget)
     // Re-measured at the copy's own width rather than spent on the source's
     // count: a block sharing its column with another is a lane wide where the
     // copy is a whole column, so the source's second line is one the copy never
@@ -813,10 +818,10 @@ private fun DragCopy(
             max = allowed,
         )
     }
-    val left = metrics.available - metrics.titleHeight(lines)
-    val showTime = label != null && left >= metrics.timeLine
+    val left = available - titleLineHeight * lines
+    val showTime = label != null && left >= timeLineHeight
     val timeMaxLines = if (showTime) {
-        blockTimeLines(label!!, textWidth, left - metrics.timeLine)
+        blockTimeLines(label!!, textWidth, left - timeLineHeight)
     } else {
         1
     }
@@ -852,7 +857,7 @@ private fun DragCopy(
                 clip = false
             }
             .eventSurface(paint, shape, cuts)
-            .padding(horizontal = BLOCK_TEXT_PADDING, vertical = metrics.inset),
+            .padding(horizontal = BLOCK_TEXT_PADDING, vertical = BLOCK_TEXT_INSET),
     ) {
         Column {
             if (lines > 0) {

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/TimelineHours.kt

@@ -1,58 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import kotlin.math.abs
-import kotlin.math.roundToInt
-
-/**
- * The hours the week and day timelines fit to the screen when they open (#322).
- *
- * Nothing outside the range is hidden: [TimelineScale.FitHours] only sizes the
- * hour so that [startHour]..[endHour] fills the viewport, and the timeline opens
- * scrolled to [startHour]. The hours are kept when [enabled] is switched off, so
- * switching it back on restores the chosen range.
- */
-data class TimelineHours(
-    val enabled: Boolean = false,
-    val startHour: Int = DEFAULT_START_HOUR,
-    val endHour: Int = DEFAULT_END_HOUR,
-) {
-    val span: Int get() = endHour - startHour
-
-    companion object {
-        const val DEFAULT_START_HOUR = 7
-        const val DEFAULT_END_HOUR = 22
-
-        /** Shortest range that can be chosen, in hours. */
-        const val MIN_SPAN = 2
-
-        /**
-         * A range with [startHour] and [endHour] held to the day and at least
-         * [MIN_SPAN] apart; the start gives way when the two collide.
-         */
-        fun of(enabled: Boolean, startHour: Int, endHour: Int): TimelineHours {
-            val end = endHour.coerceIn(MIN_SPAN, 24)
-            val start = startHour.coerceIn(0, end - MIN_SPAN)
-            return TimelineHours(enabled, start, end)
-        }
-
-        /** Start hours that still leave [MIN_SPAN] before [endHour]. */
-        fun startOptions(endHour: Int): List<Int> = (0..endHour - MIN_SPAN).toList()
-
-        /** End hours at least [MIN_SPAN] after [startHour]; 24 is midnight. */
-        fun endOptions(startHour: Int): List<Int> = (startHour + MIN_SPAN..24).toList()
-    }
-}
-
-/**
- * The scroll offset that puts [startHour] at the top of a timeline laid out
- * with [maxValue] scroll range over a [viewportPx] viewport, or null while that
- * layout is not yet at [hourPx] per hour — the scale changes a frame before the
- * content grows to match it, and scrolling against the old layout would land on
- * the wrong hour.
- */
-internal fun startHourScroll(maxValue: Int, viewportPx: Int, startHour: Int, hourPx: Float): Int? {
-    if (viewportPx <= 0 || maxValue < 0 || maxValue == Int.MAX_VALUE) return null
-    val laidOutHourPx = (maxValue + viewportPx) / 24f
-    if (abs(laidOutHourPx - hourPx) > 1f) return null
-    return (startHour * laidOutHourPx).roundToInt().coerceIn(0, maxValue)
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/TimelineScale.kt

@@ -38,12 +38,6 @@ sealed interface TimelineScale {
     /** A height the user pinched to. Build it through [custom], which clamps. */
     data class Custom(val hourHeight: Dp) : TimelineScale
 
-    /**
-     * [startHour]..[endHour] fills the viewport (#322). Applied when a timeline
-     * opens with [TimelineHours] on, never picked from the preset list.
-     */
-    data class FitHours(val startHour: Int, val endHour: Int) : TimelineScale
-
     companion object {
         /** The named steps the settings picker offers, coarse to roomy. */
         val presets: List<TimelineScale> = listOf(FitDay, Compact, Regular, Comfortable)
@@ -80,9 +74,6 @@ fun TimelineScale.hourHeight(viewportHeight: Dp): Dp = when (this) {
     is TimelineScale.Custom -> this.hourHeight
         .coerceAtMost(MAX_PINCH_HOUR_HEIGHT)
         .coerceAtLeast(fillHourHeight(viewportHeight))
-    is TimelineScale.FitHours -> (viewportHeight / (endHour - startHour).coerceIn(1, 24).toFloat())
-        .coerceAtMost(MAX_PINCH_HOUR_HEIGHT)
-        .coerceAtLeast(fillHourHeight(viewportHeight))
 }
 
 /**
@@ -143,7 +134,6 @@ val TimelineScale.labelRes: Int
         TimelineScale.Regular -> R.string.timeline_scale_regular
         TimelineScale.Comfortable -> R.string.timeline_scale_comfortable
         is TimelineScale.Custom -> R.string.timeline_scale_custom
-        is TimelineScale.FitHours -> R.string.settings_visible_hours
     }
 
 @get:StringRes
@@ -154,15 +144,11 @@ val TimelineScale.descriptionRes: Int
         TimelineScale.Regular -> R.string.timeline_scale_regular_summary
         TimelineScale.Comfortable -> R.string.timeline_scale_comfortable_summary
         is TimelineScale.Custom -> R.string.timeline_scale_custom_summary
-        is TimelineScale.FitHours -> R.string.settings_visible_hours_summary
     }
 
 /** Marks a stored custom height; the rest of the value is its dp. */
 private const val CUSTOM_PREFIX = "custom:"
 
-/** Marks a stored hour range, as `start-end`. */
-private const val HOURS_PREFIX = "hours:"
-
 /**
  * Stored names for the presets. Spelled out rather than taken from `toString()`
  * so R8 can't rename them out from under an existing install — and they match
@@ -185,7 +171,6 @@ private val PRESET_NAMES: Map<TimelineScale, String> = mapOf(
  */
 fun TimelineScale.storageValue(): String = when (this) {
     is TimelineScale.Custom -> CUSTOM_PREFIX + hourHeight.value
-    is TimelineScale.FitHours -> "$HOURS_PREFIX$startHour-$endHour"
     TimelineScale.FitDay,
     TimelineScale.Compact,
     TimelineScale.Regular,
@@ -203,11 +188,5 @@ fun parseTimelineScale(stored: String?): TimelineScale = when {
     stored.startsWith(CUSTOM_PREFIX) -> stored.removePrefix(CUSTOM_PREFIX).toFloatOrNull()
         ?.let { TimelineScale.custom(it.dp) }
         ?: TimelineScale.Regular
-    stored.startsWith(HOURS_PREFIX) -> stored.removePrefix(HOURS_PREFIX).split('-')
-        .mapNotNull { it.toIntOrNull() }
-        .takeIf { it.size == 2 }
-        ?.let { (start, end) -> TimelineHours.of(enabled = true, start, end) }
-        ?.let { TimelineScale.FitHours(it.startHour, it.endHour) }
-        ?: TimelineScale.Regular
     else -> PRESET_NAMES.entries.firstOrNull { it.value == stored }?.key ?: TimelineScale.Regular
 }

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/TimelineZoom.kt

@@ -13,15 +13,11 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.setValue
-import androidx.compose.runtime.snapshotFlow
 import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.input.pointer.PointerEventPass
 import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.unit.Dp
-import kotlinx.coroutines.flow.filterNotNull
-import kotlinx.coroutines.flow.first
 import kotlin.math.abs
 import kotlin.math.floor
 import kotlin.math.roundToInt
@@ -53,49 +49,13 @@ class TimelineZoom(
     var isPinching: Boolean by mutableStateOf(false)
         private set
 
-    /** The visible-hours preference (#322); a timeline re-fits when it changes. */
-    var hours: TimelineHours by mutableStateOf(TimelineHours())
-        private set
-
-    private var stored: TimelineScale = initial
-
     /**
      * Take a value that came from the preference. Ignored mid-pinch: the stored
      * value is a frame or two behind the fingers there, and letting it land would
-     * snap the timeline back while the user is still pinching. With visible
-     * hours on it is only remembered, so a late-arriving preference can't undo
-     * the fit a timeline just opened with.
+     * snap the timeline back while the user is still pinching.
      */
     fun adopt(stored: TimelineScale) {
-        this.stored = stored
-        if (!isPinching && !hours.enabled) scale = stored
-    }
-
-    /** Take the visible-hours preference; switching it off hands back the stored scale. */
-    fun adoptHours(hours: TimelineHours) {
-        val wasEnabled = this.hours.enabled
-        this.hours = hours
-        if (wasEnabled && !hours.enabled && !isPinching) scale = stored
-    }
-
-    /**
-     * A timeline is opening. With visible hours on, the range replaces whatever
-     * scale is in force — a stored preset and a pinch alike — and its start hour
-     * is returned for the timeline to scroll to; otherwise null.
-     */
-    fun open(): Int? {
-        val hours = hours
-        if (!hours.enabled) return null
-        if (!isPinching) scale = TimelineScale.FitHours(hours.startHour, hours.endHour)
-        return hours.startHour
-    }
-
-    /**
-     * Holds the height [open] fitted, so a viewport that changes afterwards (the
-     * all-day strip following a swipe) doesn't rescale the hours under the scroll.
-     */
-    fun holdFit(hourHeight: Dp) {
-        if (!isPinching && scale is TimelineScale.FitHours) scale = TimelineScale.Custom(hourHeight)
+        if (!isPinching) scale = stored
     }
 
     fun beginPinch() {
@@ -106,10 +66,9 @@ class TimelineZoom(
         scale = TimelineScale.custom(hourHeight)
     }
 
-    /** Settles the pinch. With visible hours on it only lasts until the next [open]. */
     fun endPinch() {
         isPinching = false
-        if (!hours.enabled) persist(scale)
+        persist(scale)
     }
 }
 
@@ -123,18 +82,16 @@ private val DetachedTimelineZoom by lazy { TimelineZoom(TimelineScale.Regular) {
 val LocalTimelineZoom = staticCompositionLocalOf { DetachedTimelineZoom }
 
 /**
- * The app-wide [TimelineZoom], seeded from [stored] and [hours] and writing
- * settled pinches back through [onPersist].
+ * The app-wide [TimelineZoom], seeded from [stored] and writing settled pinches
+ * back through [onPersist].
  */
 @Composable
 fun rememberTimelineZoom(
     stored: TimelineScale,
-    hours: TimelineHours,
     onPersist: (TimelineScale) -> Unit,
 ): TimelineZoom {
     val persist by rememberUpdatedState(onPersist)
     val zoom = remember { TimelineZoom(stored) { persist(it) } }
-    LaunchedEffect(hours) { zoom.adoptHours(hours) }
     // Picking a preset in Settings has to reach the timelines, and so does the
     // stored value arriving after the first frame.
     LaunchedEffect(stored) { zoom.adopt(stored) }
@@ -285,31 +242,3 @@ internal fun anchoredScroll(
  * as a scroll stays one.
  */
 private const val PINCH_SLOP = 0.08f
-
-/**
- * Where a timeline opens (#322): scrolled to the start of the visible hours when
- * they are on, otherwise centred on noon. Re-runs when the visible-hours
- * preference changes, so a range picked in Settings shows on the way back.
- */
-@Composable
-fun OpenTimelineScroll(scrollState: ScrollState, zoom: TimelineZoom) {
-    val density = LocalDensity.current
-    LaunchedEffect(zoom, zoom.hours) {
-        val startHour = zoom.open()
-        if (startHour == null) {
-            snapshotFlow { scrollState.maxValue }.first { it > 0 }
-            // Half the scroll range *is* noon: the content spans a full 24 hours,
-            // so centring the range centres midday at whatever hour height is in force.
-            scrollState.scrollTo(scrollState.maxValue / 2)
-        } else {
-            val (target, hourHeight) = snapshotFlow {
-                val viewport = scrollState.viewportSize
-                val hourHeight = zoom.scale.hourHeight(with(density) { viewport.toDp() })
-                val hourPx = with(density) { hourHeight.toPx() }
-                startHourScroll(scrollState.maxValue, viewport, startHour, hourPx)?.let { it to hourHeight }
-            }.filterNotNull().first()
-            scrollState.scrollTo(target)
-            zoom.holdFit(hourHeight)
-        }
-    }
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/ViewSwitcherPill.kt

@@ -35,6 +35,6 @@ fun ViewSwitcherPill(
         shape = MaterialTheme.shapes.large,
         modifier = modifier.padding(end = trailingInset),
     ) {
-        Text(current.label())
+        Text(stringResource(current.labelRes))
     }
 }

app/src/main/java/de/jeanlucmakiola/calendula/ui/day/DayPaging.kt

@@ -1,22 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.day
-
-import kotlinx.datetime.DateTimeUnit
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.daysUntil
-import kotlinx.datetime.plus
-
-/** Pages the day pager spans — a little under four centuries, centred on [PAGE_EPOCH]. */
-internal const val DAY_PAGE_COUNT: Int = 140_000
-
-private const val EPOCH_PAGE = DAY_PAGE_COUNT / 2
-
-/** The day at [EPOCH_PAGE]; any date works, it only has to stay fixed. */
-private val PAGE_EPOCH = LocalDate(2000, 1, 1)
-
-/** The day shown on pager [page]. */
-internal fun dayForPage(page: Int): LocalDate =
-    PAGE_EPOCH.plus(page - EPOCH_PAGE, DateTimeUnit.DAY)
-
-/** The pager page showing [date]. */
-internal fun dayPageFor(date: LocalDate): Int =
-    (EPOCH_PAGE + PAGE_EPOCH.daysUntil(date)).coerceIn(0, DAY_PAGE_COUNT - 1)

app/src/main/java/de/jeanlucmakiola/calendula/ui/day/DayScreen.kt

@@ -1,22 +1,7 @@
 package de.jeanlucmakiola.calendula.ui.day
 
 import androidx.compose.animation.AnimatedContent
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.animation.togetherWith
-import androidx.compose.foundation.pager.HorizontalPager
-import androidx.compose.foundation.pager.PagerDefaults
-import androidx.compose.foundation.pager.PagerState
-import androidx.compose.foundation.pager.rememberPagerState
-import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.mutableStateMapOf
-import de.jeanlucmakiola.calendula.ui.common.jumpToPage
-import de.jeanlucmakiola.calendula.ui.common.pagedHeight
-import de.jeanlucmakiola.calendula.ui.common.rememberCalendarPageSpec
-import de.jeanlucmakiola.calendula.ui.common.rememberCurrentMinute
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.drop
+import androidx.compose.animation.core.animateDpAsState
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.gestures.detectTapGestures
@@ -58,10 +43,12 @@ import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.snapshotFlow
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
@@ -96,9 +83,9 @@ import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.BLOCK_OUTER_INSET
 import de.jeanlucmakiola.calendula.ui.common.BLOCK_TEXT_PADDING
+import de.jeanlucmakiola.calendula.ui.common.BLOCK_TEXT_INSET
 import de.jeanlucmakiola.calendula.ui.common.BlockTimeLabel
 import de.jeanlucmakiola.calendula.ui.common.BlockTitle
-import de.jeanlucmakiola.calendula.ui.common.rememberBlockTextMetrics
 import de.jeanlucmakiola.calendula.ui.common.blockTimeLines
 import de.jeanlucmakiola.calendula.ui.common.animatedBlockPlacement
 import de.jeanlucmakiola.calendula.ui.common.ghostAlpha
@@ -106,8 +93,6 @@ import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
 import de.jeanlucmakiola.calendula.ui.common.MoveRequest
 import de.jeanlucmakiola.calendula.ui.common.MoveTarget
 import de.jeanlucmakiola.calendula.ui.common.NowLine
-import de.jeanlucmakiola.calendula.ui.common.OutOfViewEdgeBars
-import de.jeanlucmakiola.calendula.ui.common.rememberOutOfViewEdges
 import de.jeanlucmakiola.calendula.ui.common.TimelineDragController
 import de.jeanlucmakiola.calendula.ui.common.TimelineDragOverlay
 import de.jeanlucmakiola.calendula.ui.common.TimelineDrop
@@ -124,16 +109,17 @@ import de.jeanlucmakiola.calendula.ui.common.rememberEventDragSource
 import de.jeanlucmakiola.calendula.ui.common.rememberTimelineDragController
 import de.jeanlucmakiola.calendula.ui.common.startInstant
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
+import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
+import de.jeanlucmakiola.calendula.ui.common.rememberCalendarPageSwipe
 import de.jeanlucmakiola.floret.identity.rememberReduceMotion
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.calendula.ui.common.EventChipShape
-import de.jeanlucmakiola.calendula.ui.common.trimmedLines
+import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.LocalShowHourGrid
 import de.jeanlucmakiola.calendula.ui.common.LocalTimelineZoom
-import de.jeanlucmakiola.calendula.ui.common.OpenTimelineScroll
 import de.jeanlucmakiola.calendula.ui.common.MIN_EVENT_FRACTION
 import de.jeanlucmakiola.calendula.ui.common.hourHeight
 import de.jeanlucmakiola.calendula.ui.common.rememberTimelinePinchZoom
@@ -145,20 +131,18 @@ import de.jeanlucmakiola.calendula.ui.common.hourCellBlockInset
 import de.jeanlucmakiola.calendula.ui.common.hourGridCells
 import de.jeanlucmakiola.calendula.ui.common.tappedMinuteOfDay
 import de.jeanlucmakiola.calendula.ui.week.TimedBlock
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
 import java.util.Locale
 import kotlin.math.roundToInt
 
-/** One lane of the all-day strip, sized to a trimmed bar line (#190). */
-private val ALL_DAY_ROW_HEIGHT = 20.dp
+private val ALL_DAY_ROW_HEIGHT = 24.dp
 private val ALL_DAY_VERTICAL_PADDING = 6.dp
 
-/** Breathing room between the all-day strip and the scrolling timeline below. */
-private val TIMELINE_TOP_GAP = 8.dp
-
 /** Total all-day strip height for the day (0 when there are no all-day events). */
 internal fun DayUiState.Success.allDayStripHeight(): Dp {
     if (allDay.isEmpty()) return 0.dp
@@ -183,7 +167,7 @@ fun DayScreen(
     viewModel: DayViewModel = hiltViewModel(),
 ) {
     val state by viewModel.state.collectAsStateWithLifecycle()
-    val anchorPage by viewModel.anchorPage.collectAsStateWithLifecycle()
+    val date by viewModel.date.collectAsStateWithLifecycle()
 
     // When opened from the month grid, anchor to the tapped date.
     LaunchedEffect(initialDateIso) {
@@ -193,39 +177,36 @@ fun DayScreen(
     val drawerState = rememberDrawerState(DrawerValue.Closed)
     val scope = rememberCoroutineScope()
 
-    // Opens on the tapped date directly, rather than on today and then correcting.
-    val pagerState = rememberPagerState(
-        initialPage = initialDateIso?.let { dayPageFor(LocalDate.parse(it)) } ?: anchorPage,
-    ) { DAY_PAGE_COUNT }
-    val pageSpec = rememberCalendarPageSpec()
-    val reduceMotion = rememberReduceMotion()
-    // The pager leads and the anchor follows once it settles, so the anchor only
-    // moves on its own to correct the pager — e.g. re-entry from the month grid
-    // on another date. Snapped, since that is a correction rather than a move.
-    LaunchedEffect(anchorPage) {
-        if (pagerState.currentPage != anchorPage && !pagerState.isScrollInProgress) {
-            pagerState.scrollToPage(anchorPage)
+    val isOnToday = when (val s = state) {
+        is DayUiState.Success -> s.date == s.today
+        else -> true
+    }
+
+    // Drives whether the title carries the year. Falls back to the clock only
+    // while the first load is in flight, when there is no state to read today from.
+    val currentYear = when (val s = state) {
+        is DayUiState.Success -> s.today.year
+        else -> Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()).date.year
+    }
+
+    // Slide direction for the day transition: +1 = next, -1 = prev, 0 = jump.
+    var slideDir by remember { mutableIntStateOf(0) }
+    val goNext = { slideDir = 1; viewModel.goToNext() }
+    val goPrev = { slideDir = -1; viewModel.goToPrev() }
+    // Slide toward today: viewing the future → today comes in from the left
+    // (back), viewing the past → from the right (forward).
+    val jumpToToday = {
+        slideDir = when (val s = state) {
+            is DayUiState.Success -> if (s.today < s.date) -1 else 1
+            else -> 0
         }
+        viewModel.goToToday()
     }
-    LaunchedEffect(pagerState) {
-        snapshotFlow { pagerState.settledPage }.drop(1).collect(viewModel::onPageSettled)
-    }
-    // The day under the finger, so the title turns over mid-swipe, not after it.
-    val date = dayForPage(pagerState.currentPage)
-
-    // Off the ticking clock rather than the loaded day, so it turns over at
-    // midnight; derived, so the per-minute tick doesn't recompose the screen.
-    val nowState = rememberCurrentMinute()
-    val zone = remember { TimeZone.currentSystemDefault() }
-    val today by remember(zone) { derivedStateOf { nowState.value.toLocalDateTime(zone).date } }
-    val isOnToday = state !is DayUiState.Success || date == today
-
-    // Straight to the pager: a tap mid-fling must still land, and the anchor
-    // hasn't caught up with the fling yet to tell the difference.
+    // Drawer jump-to-date: slide from the side the target lies on.
     val jumpToDate: (LocalDate) -> Unit = { target ->
-        scope.launch { pagerState.jumpToPage(dayPageFor(target), reduceMotion, pageSpec) }
+        slideDir = if (target < date) -1 else 1
+        viewModel.goToDate(target)
     }
-    val jumpToToday = { jumpToDate(today) }
 
     ModalNavigationDrawer(
         drawerState = drawerState,
@@ -257,7 +238,7 @@ fun DayScreen(
             topBar = {
                 DayTopBar(
                     date = date,
-                    currentYear = today.year,
+                    currentYear = currentYear,
                     selectedView = selectedView,
                     onCycleView = { onSelectView(selectedView.next(quickSwitchViews)) },
                     quickSwitchViews = quickSwitchViews,
@@ -279,9 +260,10 @@ fun DayScreen(
         ) { innerPadding ->
             DayContent(
                 state = state,
-                pagerState = pagerState,
-                day = viewModel::day,
-                onRetry = viewModel::goToToday,
+                slideDir = slideDir,
+                onSwipeNext = goNext,
+                onSwipePrev = goPrev,
+                onRetry = jumpToToday,
                 onEventClick = onEventClick,
                 onCreateAt = { d, minutes -> onCreateEvent(d, minutes) },
                 modifier = Modifier
@@ -295,60 +277,82 @@ fun DayScreen(
 @Composable
 private fun DayContent(
     state: DayUiState,
-    pagerState: PagerState,
-    day: (LocalDate) -> StateFlow<DayUiState>,
+    slideDir: Int,
+    onSwipeNext: () -> Unit,
+    onSwipePrev: () -> Unit,
     onRetry: () -> Unit,
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
     modifier: Modifier = Modifier,
 ) {
+    val slideSpec = rememberCalendarSlideSpec()
     val fadeSpec = rememberCalendarFadeSpec()
+    val reduceMotion = rememberReduceMotion()
 
-    // Shared by every page and the gutter, so the vertical scroll position
-    // survives day-to-day swipes. Positioned once on entry into the day view:
-    // at the visible hours' start if set (#322), otherwise noon.
+    // Hoisted above the per-day AnimatedContent so the vertical scroll position
+    // survives day-to-day swipes. We only centre on noon once, on first entry
+    // into the day view (i.e. when arriving from the month/week view).
     val scrollState = rememberScrollState()
-    OpenTimelineScroll(scrollState, LocalTimelineZoom.current)
+    LaunchedEffect(Unit) {
+        snapshotFlow { scrollState.maxValue }.first { it > 0 }
+        // Half the scroll range *is* noon: the content spans a full 24 hours, so
+        // centring the range centres midday at whatever hour height is in force.
+        scrollState.scrollTo(scrollState.maxValue / 2)
+    }
 
-    // Above the pager: a page change mid-drag would strand the floating block
-    // inside the outgoing page.
+    // Single, hoisted all-day strip height — shared by the outgoing and incoming
+    // day during a swipe, so the strip slides along but never jumps in height.
+    val targetAllDayHeight = (state as? DayUiState.Success)?.allDayStripHeight() ?: 0.dp
+    val allDayHeight by animateDpAsState(
+        targetValue = targetAllDayHeight,
+        label = "day-all-day-strip-height",
+    )
+
+    // Whole-page horizontal swipe, one level above the timeline's vertical
+    // scroll: a horizontal drag crosses this detector's slop, while a vertical
+    // drag is consumed by the inner scroll first — the two gestures coexist.
+    val swipeModifier = rememberCalendarPageSwipe(onSwipeNext, onSwipePrev)
+
+    // Above the AnimatedContent: a page change mid-drag would strand the
+    // floating block inside the outgoing page.
     val dragController = rememberTimelineDragController()
     val move = LocalEventMove.current
     val zone = remember { TimeZone.currentSystemDefault() }
-    val onDrop: (TimelineDrop) -> Unit = { drop ->
-        move?.move(
-            MoveRequest(
-                eventId = drop.event.eventId,
-                beginMillis = drop.event.start.toEpochMilliseconds(),
-                endMillis = drop.event.end.toEpochMilliseconds(),
-                target = MoveTarget.Start(drop.startInstant(zone)),
-            ),
-        )
-    }
 
     Box(modifier = modifier) {
-        // Loading and failure concern the provider as a whole, so they stand in
-        // for the pager; a page still loading its own day handles that itself.
         AnimatedContent(
             targetState = state,
-            modifier = Modifier.fillMaxSize(),
-            contentKey = { it::class },
-            transitionSpec = { fadeIn(fadeSpec).togetherWith(fadeOut(fadeSpec)) },
-            label = "day-state",
+            modifier = Modifier.fillMaxSize().then(swipeModifier),
+            contentKey = { s ->
+                when (s) {
+                    is DayUiState.Success -> "success-${s.date}"
+                    is DayUiState.Failure -> "failure-${s.reason}"
+                    DayUiState.Loading -> "loading"
+                }
+            },
+            transitionSpec = { calendarSlideTransition(slideDir, slideSpec, fadeSpec, reduceMotion) },
+            label = "day-transition",
         ) { s ->
             when (s) {
                 DayUiState.Loading -> DayLoading()
                 is DayUiState.Failure -> CalendarFailure(reason = s.reason, onRetry = onRetry)
-                is DayUiState.Success -> DayPager(
-                    pagerState = pagerState,
-                    day = day,
-                    today = s.today,
-                    initialStripHeight = s.allDayStripHeight(),
+                is DayUiState.Success -> DaySuccess(
+                    state = s,
                     scrollState = scrollState,
+                    allDayHeight = allDayHeight,
                     dragController = dragController,
                     onEventClick = onEventClick,
                     onCreateAt = onCreateAt,
-                    onDrop = onDrop,
+                    onDrop = { drop ->
+                        move?.move(
+                            MoveRequest(
+                                eventId = drop.event.eventId,
+                                beginMillis = drop.event.start.toEpochMilliseconds(),
+                                endMillis = drop.event.end.toEpochMilliseconds(),
+                                target = MoveTarget.Start(drop.startInstant(zone)),
+                            ),
+                        )
+                    },
                 )
             }
         }
@@ -356,101 +360,6 @@ private fun DayContent(
     }
 }
 
-/**
- * The days as pages that follow the finger and snap once a swipe passes half a
- * page or is flung (#336), beside a gutter that stays put.
- */
-@Composable
-private fun DayPager(
-    pagerState: PagerState,
-    day: (LocalDate) -> StateFlow<DayUiState>,
-    today: LocalDate,
-    initialStripHeight: Dp,
-    scrollState: ScrollState,
-    dragController: TimelineDragController,
-    onEventClick: (EventInstance) -> Unit,
-    onCreateAt: (LocalDate, Int) -> Unit,
-    onDrop: (TimelineDrop) -> Unit,
-) {
-    val stripHeights = remember { mutableStateMapOf<Int, Dp>() }
-    val allDayHeight = pagedHeight(pagerState, stripHeights, initialStripHeight)
-    DayFrame(allDayHeight = allDayHeight, scrollState = scrollState, dragController = dragController) {
-        HorizontalPager(
-            state = pagerState,
-            modifier = Modifier.fillMaxSize(),
-            // The days either side are composed ahead, so a swipe lands on a
-            // loaded day rather than watching it fill in.
-            beyondViewportPageCount = 1,
-            // A held block moves within its day; the page stays put under it.
-            userScrollEnabled = !dragController.isDragging,
-            flingBehavior = PagerDefaults.flingBehavior(
-                state = pagerState,
-                snapAnimationSpec = rememberCalendarPageSpec(),
-            ),
-        ) { page ->
-            val date = dayForPage(page)
-            val pageState by remember(date) { day(date) }.collectAsStateWithLifecycle()
-            val loaded = pageState as? DayUiState.Success
-            // Until its day arrives a page shows the empty column.
-            val empty = remember(date, today) {
-                DayUiState.Success(date = date, today = today, allDay = emptyList(), timed = emptyList())
-            }
-            val stripHeight = loaded?.allDayStripHeight()
-            DisposableEffect(page, stripHeight) {
-                if (stripHeight != null) stripHeights[page] = stripHeight
-                onDispose { stripHeights.remove(page) }
-            }
-            DayPage(
-                state = loaded ?: empty,
-                allDayHeight = allDayHeight,
-                scrollState = scrollState,
-                dragController = dragController,
-                active = page == pagerState.currentPage,
-                onEventClick = onEventClick,
-                onCreateAt = onCreateAt,
-                onDrop = onDrop,
-            )
-        }
-    }
-}
-
-/** What stays put while the days swipe: the hour gutter, with [pages] filling the rest. */
-@Composable
-private fun DayFrame(
-    allDayHeight: Dp,
-    scrollState: ScrollState,
-    dragController: TimelineDragController,
-    pages: @Composable () -> Unit,
-) {
-    Row(modifier = Modifier.fillMaxSize()) {
-        Column(modifier = Modifier.width(GUTTER_WIDTH).fillMaxHeight()) {
-            Spacer(
-                Modifier
-                    .fillMaxWidth()
-                    .height(allDayHeight)
-                    .background(MaterialTheme.colorScheme.surface),
-            )
-            Spacer(Modifier.height(TIMELINE_TOP_GAP))
-            // Resolves the hour height off the same viewport height the pages'
-            // timelines have, so labels and column agree.
-            BoxWithConstraints(modifier = Modifier.fillMaxSize()) {
-                val zoom = LocalTimelineZoom.current
-                val hourHeight = zoom.scale.hourHeight(maxHeight)
-                // Start inset so the labels centre on the top bar hamburger,
-                // matching the week view.
-                HourGutter(
-                    scrollState = scrollState,
-                    hourHeight = hourHeight,
-                    dragController = dragController,
-                    modifier = rememberTimelinePinchZoom(scrollState, maxHeight, hourHeight, zoom),
-                )
-            }
-        }
-        Box(modifier = Modifier.weight(1f).fillMaxHeight()) { pages() }
-    }
-}
-
-/** A single day in its frame, without the pager — for the Settings preview. */
 @Composable
 internal fun DaySuccess(
     state: DayUiState.Success,
@@ -460,37 +369,6 @@ internal fun DaySuccess(
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
     onDrop: (TimelineDrop) -> Unit,
-) {
-    DayFrame(allDayHeight = allDayHeight, scrollState = scrollState, dragController = dragController) {
-        DayPage(
-            state = state,
-            allDayHeight = allDayHeight,
-            scrollState = scrollState,
-            dragController = dragController,
-            active = true,
-            onEventClick = onEventClick,
-            onCreateAt = onCreateAt,
-            onDrop = onDrop,
-        )
-    }
-}
-
-/**
- * One day's page: all-day strip and column.
- *
- * @param active whether this is the page on screen, the only one that may
- *   publish the drag geometry.
- */
-@Composable
-private fun DayPage(
-    state: DayUiState.Success,
-    allDayHeight: Dp,
-    scrollState: ScrollState,
-    dragController: TimelineDragController,
-    active: Boolean,
-    onEventClick: (EventInstance) -> Unit,
-    onCreateAt: (LocalDate, Int) -> Unit,
-    onDrop: (TimelineDrop) -> Unit,
 ) {
     Column(modifier = Modifier.fillMaxSize()) {
         // All-day strip collapses to nothing when the day has no all-day events,
@@ -509,12 +387,13 @@ private fun DayPage(
                     .background(MaterialTheme.colorScheme.surface),
             )
         }
-        Spacer(Modifier.height(TIMELINE_TOP_GAP))
+        // Breathing room between the top section and the scrolling timeline
+        // below.
+        Spacer(Modifier.height(8.dp))
         Timeline(
             state = state,
             scrollState = scrollState,
             dragController = dragController,
-            active = active,
             onEventClick = onEventClick,
             onCreateAt = onCreateAt,
             onDrop = onDrop,
@@ -602,6 +481,8 @@ private fun AllDayStrip(
                 end = TIMELINE_CONTENT_END_INSET,
             ),
     ) {
+        // Keep the gutter-width offset so the bars line up with the day column.
+        Spacer(Modifier.width(GUTTER_WIDTH))
         // Bars are positioned absolutely by lane (vertical stacking); each spans
         // the full day-column width. clipToBounds keeps bars from spilling out
         // while the height animates.
@@ -648,7 +529,7 @@ private fun AllDayBar(
         val titleOverflow = eventTitleOverflow()
         Text(
             text = title,
-            style = MaterialTheme.typography.labelSmall.trimmedLines(),
+            style = MaterialTheme.typography.labelSmall,
             maxLines = 1,
             overflow = titleOverflow.overflow,
             softWrap = titleOverflow.softWrap,
@@ -664,7 +545,6 @@ private fun Timeline(
     state: DayUiState.Success,
     scrollState: ScrollState,
     dragController: TimelineDragController,
-    active: Boolean,
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
     onDrop: (TimelineDrop) -> Unit,
@@ -686,54 +566,61 @@ private fun Timeline(
     BoxWithConstraints(modifier = Modifier.fillMaxSize()) {
         val hourHeight = zoom.scale.hourHeight(maxHeight)
         val totalHeight = hourHeight * 24
-        // The pinch sits above the scroll viewport: it has to outrank the
-        // vertical scroll, and it does that by watching the initial pass, which
-        // only reaches it if it is the viewport's ancestor.
+        // The pinch sits on the Row, above both scroll viewports: it has to
+        // outrank the vertical scroll, and it does that by watching the initial
+        // pass, which only reaches it if it is their ancestor.
         val pinch = rememberTimelinePinchZoom(scrollState, maxHeight, hourHeight, zoom)
-        // Scrolls on the same state as the gutter and the other pages, so they
-        // all stay aligned. A static, rounded-clipped window — the content
-        // scrolls inside it, so the soft corners are permanent at any scroll
-        // position.
-        Box(
-            modifier = Modifier
-                .fillMaxSize()
-                .then(pinch)
-                .padding(end = TIMELINE_CONTENT_END_INSET)
-                .clip(RoundedCornerShape(16.dp))
-                .verticalScroll(scrollState)
-                .onGloballyPositioned { if (active) dragController.geometry.viewport = it },
-        ) {
-            DayColumnCard(
-                blocks = state.timed,
-                dark = dark,
-                date = state.date,
-                today = state.today,
-                hourHeight = hourHeight,
+        // Gutter and day column are two scroll viewports that SHARE one scroll
+        // state, so they stay perfectly aligned. The day-column viewport is a
+        // static, rounded-clipped window — the content scrolls inside it, so the
+        // soft corners are permanent at any scroll position.
+        Row(modifier = Modifier.fillMaxSize().then(pinch)) {
+            // Hour gutter (scrolls in sync with the day column). Start inset so the
+            // labels centre on the top bar hamburger, matching the week view.
+            HourGutter(
                 scrollState = scrollState,
+                hourHeight = hourHeight,
                 dragController = dragController,
-                onEventClick = onEventClick,
-                onCreateAt = onCreateAt,
-                onDrop = onDrop,
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .height(totalHeight)
-                    // The scrolling content itself, so its root position
-                    // already folds in the scroll offset. Only the page on
-                    // screen publishes it: the ones either side are laid out too.
-                    .onGloballyPositioned { coords ->
-                        if (!active) return@onGloballyPositioned
-                        dragController.geometry.let {
-                            it.grid = coords
-                            it.scroll = scrollState
-                            it.hourPx = with(density) { hourHeight.toPx() }
-                            it.blockInsetPx = blockInsetPx
-                            it.columnGapPx = 0f
-                            it.columnWidthPx = coords.size.width.toFloat()
-                            it.days = listOf(state.date)
-                            it.isRtl = isRtl
-                        }
-                    },
             )
+            // Day column: rounded, clipped scroll viewport (permanent corners).
+            Box(
+                modifier = Modifier
+                    .weight(1f)
+                    .fillMaxHeight()
+                    .padding(end = TIMELINE_CONTENT_END_INSET)
+                    .clip(RoundedCornerShape(16.dp))
+                    .verticalScroll(scrollState)
+                    .onGloballyPositioned { dragController.geometry.viewport = it },
+            ) {
+                DayColumnCard(
+                    blocks = state.timed,
+                    dark = dark,
+                    date = state.date,
+                    today = state.today,
+                    hourHeight = hourHeight,
+                    dragController = dragController,
+                    onEventClick = onEventClick,
+                    onCreateAt = onCreateAt,
+                    onDrop = onDrop,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .height(totalHeight)
+                        // The scrolling content itself, so its root position
+                        // already folds in the scroll offset.
+                        .onGloballyPositioned { coords ->
+                            dragController.geometry.let {
+                                it.grid = coords
+                                it.scroll = scrollState
+                                it.hourPx = with(density) { hourHeight.toPx() }
+                                it.blockInsetPx = blockInsetPx
+                                it.columnGapPx = 0f
+                                it.columnWidthPx = coords.size.width.toFloat()
+                                it.days = listOf(state.date)
+                                it.isRtl = isRtl
+                            }
+                        },
+                )
+            }
         }
     }
 }
@@ -745,7 +632,6 @@ private fun DayColumnCard(
     date: LocalDate,
     today: LocalDate,
     hourHeight: Dp,
-    scrollState: ScrollState,
     dragController: TimelineDragController,
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
@@ -765,8 +651,6 @@ private fun DayColumnCard(
     // them, or taps land on the scale the column had before the zoom (#148).
     val currentHourPx = rememberUpdatedState(hourPx)
     val currentOnCreateAt = rememberUpdatedState(onCreateAt)
-    val edges = rememberOutOfViewEdges(blocks, scrollState, hourPx)
-    val currentEdges = rememberUpdatedState(edges)
     Card(
         // Plain rectangular column — the soft corners come from the outer
         // rounded scroll viewport, so inner rounding would look odd at the edges.
@@ -794,7 +678,6 @@ private fun DayColumnCard(
                 // only fires on the column background. Snaps to the tapped hour.
                 .pointerInput(date) {
                     detectTapGestures { offset ->
-                        if (currentEdges.value.tap(offset.y)) return@detectTapGestures
                         currentOnCreateAt.value(
                             date,
                             tappedMinuteOfDay(offset.y, currentHourPx.value),
@@ -856,11 +739,6 @@ private fun DayColumnCard(
             if (date == today) {
                 NowLine(date = date, hourHeight = hourHeight)
             }
-            OutOfViewEdgeBars(
-                edges = edges,
-                scrollState = scrollState,
-                dark = dark,
-            )
         }
     }
 }
@@ -885,24 +763,30 @@ private fun EventBlock(
     val timeLabel = "${minToHm(block.startMin, use24Hour, locale)}–" +
         minToHm(block.endMin, use24Hour, locale)
     val density = LocalDensity.current
-    val metrics = rememberBlockTextMetrics(height)
+    val titleLineHeight = with(density) {
+        MaterialTheme.typography.labelMedium.lineHeight.toDp()
+    }
+    val timeLineHeight = with(density) {
+        MaterialTheme.typography.labelSmall.lineHeight.toDp()
+    }
     // A block that cannot afford both lines spends its space on the title, and
     // one too short even for that drops the title rather than serving a sliced one.
     // Height alone decides: a duration threshold would keep hiding the time on a
     // half-hour block the user has pinched open to three times the room it needs.
-    val showTime = metrics.available >= metrics.titleLine + metrics.timeLine
-    val showTitle = metrics.fitsTitle
+    val available = height - BLOCK_TEXT_INSET * 2
+    val showTime = available >= titleLineHeight + timeLineHeight
+    val showTitle = available >= titleLineHeight
     val textWidth = width - (BLOCK_OUTER_INSET + BLOCK_TEXT_PADDING) * 2
     // Only lines the block can actually draw: a block too short for the time is
     // too short for a second title line too, and asking for one served a sliced
     // one — as well as handing the drag copy a count it couldn't honour, so the
     // title re-wrapped the moment the block was lifted (#267).
-    val titleBudget = metrics.titleBudget(metrics.available).coerceAtLeast(1)
+    val titleBudget = (available / titleLineHeight).toInt().coerceAtLeast(1)
     val titleMaxLines = if (showTime) 1 else titleBudget.coerceAtMost(2)
     // On a day column — wide enough for "09:30–11:00" several times over — the
     // range never needs the second line, until lanes cut the column down.
-    val spare = metrics.available - metrics.titleHeight(titleMaxLines) -
-        if (showTime) metrics.timeLine else 0.dp
+    val spare = available - titleLineHeight * titleMaxLines -
+        if (showTime) timeLineHeight else 0.dp
     val timeMaxLines = if (showTime) blockTimeLines(timeLabel, textWidth, spare) else 1
     val paint = eventPaint(block.event, dark)
     val zone = remember { TimeZone.currentSystemDefault() }
@@ -943,7 +827,7 @@ private fun EventBlock(
             // After clickable, so it is the inner node and wins the main pass;
             // the tap still works, since a drag consumes the up.
             .then(dragModifier)
-            .padding(horizontal = BLOCK_TEXT_PADDING, vertical = metrics.inset)
+            .padding(horizontal = BLOCK_TEXT_PADDING, vertical = BLOCK_TEXT_INSET)
             .semantics {
                 contentDescription = "$title, $timeLabel"
                 if (moveAction != null) customActions = listOf(moveAction)

app/src/main/java/de/jeanlucmakiola/calendula/ui/day/DayViewModel.kt

@@ -9,7 +9,6 @@ import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.domain.calendarListFailure
-import de.jeanlucmakiola.calendula.ui.common.PageStateCache
 import de.jeanlucmakiola.calendula.ui.week.layoutAllDay
 import de.jeanlucmakiola.calendula.ui.week.layoutDay
 import kotlinx.coroutines.CoroutineDispatcher
@@ -19,25 +18,21 @@ import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.filterNot
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
+import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.atStartOfDayIn
 import kotlinx.datetime.atTime
-import kotlinx.datetime.daysUntil
+import kotlinx.datetime.minus
+import kotlinx.datetime.plus
 import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Clock
 import kotlin.time.Instant
 import javax.inject.Inject
-import kotlin.math.abs
-
-/** How far from the requested day [DayViewModel.day] keeps other days cached. */
-private const val DAY_CACHE_DAYS = 7
 
 @OptIn(ExperimentalCoroutinesApi::class)
 @HiltViewModel
@@ -52,53 +47,32 @@ class DayViewModel @Inject constructor(
         get() = Clock.System.now().toLocalDateTime(zone).date
 
     private val _date = MutableStateFlow(todayDate)
+    val date: StateFlow<LocalDate> = _date
 
-    /** The pager page the anchor day sits on. */
-    val anchorPage: StateFlow<Int> = _date
-        .map { dayPageFor(it) }
-        .stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5_000L),
-            initialValue = dayPageFor(todayDate),
-        )
-
-    /**
-     * The anchor day's state. Once loaded it never falls back to [DayUiState.Loading]:
-     * moving the anchor keeps the last result until the new day arrives, since
-     * the pages draw their own days and this only gates the failure screen.
-     */
     val state: StateFlow<DayUiState> = _date
-        .flatMapLatest { date -> day(date).filterNot { it is DayUiState.Loading } }
+        .flatMapLatest { day ->
+            val range = dayRange(day, zone)
+            combine(
+                repository.calendars(),
+                repository.instances(range),
+            ) { calendars, instances ->
+                buildState(day, calendars, instances)
+            }
+        }
         .catch { emit(DayUiState.Failure(FailureReason.ProviderUnavailable)) }
+        .flowOn(io)
         .stateIn(
             scope = viewModelScope,
             started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = DayUiState.Loading,
         )
 
-    private val days = PageStateCache<LocalDate, DayUiState>(
-        scope = viewModelScope,
-        initial = DayUiState.Loading,
-        // Far enough to cover the pages either side and a swipe back, so paging
-        // through a month doesn't keep a month of queries around.
-        keep = { cached, requested -> abs(cached.daysUntil(requested)) <= DAY_CACHE_DAYS },
-    ) { date ->
-        combine(
-            repository.calendars(),
-            repository.instances(dayRange(date, zone)),
-        ) { calendars, instances ->
-            buildState(date, calendars, instances)
-        }
-            .catch { emit(DayUiState.Failure(FailureReason.ProviderUnavailable)) }
-            .flowOn(io)
+    fun goToPrev() {
+        _date.value = _date.value.minus(1, DateTimeUnit.DAY)
     }
 
-    /** The day [date], shared between its pager page and [state]. Main thread only. */
-    fun day(date: LocalDate): StateFlow<DayUiState> = days.get(date)
-
-    /** The pager came to rest on [page]; follow it unless it is already the anchor's. */
-    fun onPageSettled(page: Int) {
-        if (dayPageFor(_date.value) != page) _date.value = dayForPage(page)
+    fun goToNext() {
+        _date.value = _date.value.plus(1, DateTimeUnit.DAY)
     }
 
     fun goToToday() {

app/src/main/java/de/jeanlucmakiola/calendula/ui/detail/EventDetailScreen.kt

@@ -302,7 +302,6 @@ fun EventDetailScreen(
             is EventDetailUiState.Failure -> CalendarFailure(
                 reason = s.reason,
                 onRetry = viewModel::retry,
-                modifier = contentModifier,
             )
             is EventDetailUiState.Success -> EventDetailContent(s, copyField, contentModifier)
         }
@@ -527,8 +526,7 @@ private fun EventDetailContent(
             iconContentDescription = stringResource(R.string.event_detail_calendar),
         ) {
             Text(
-                text = state.calendarName?.ifBlank { stringResource(R.string.calendar_unnamed) }
-                    ?: stringResource(R.string.event_detail_calendar_unknown),
+                text = state.calendarName ?: stringResource(R.string.event_detail_calendar_unknown),
                 style = MaterialTheme.typography.titleMedium,
             )
         }

app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditScreen.kt

@@ -620,9 +620,7 @@ private fun EventEditContent(
             Text(
                 text = stringResource(
                     R.string.event_edit_managed_hint,
-                    selectedCalendar?.displayName
-                        ?.ifBlank { stringResource(R.string.calendar_unnamed) }
-                        .orEmpty(),
+                    selectedCalendar?.displayName.orEmpty(),
                 ),
                 style = MaterialTheme.typography.bodySmall,
                 color = MaterialTheme.colorScheme.onSurfaceVariant,
@@ -721,7 +719,6 @@ private fun EventEditContent(
         ) {
             Text(
                 text = selectedCalendar?.displayName
-                    ?.ifBlank { stringResource(R.string.calendar_unnamed) }
                     ?: stringResource(R.string.event_edit_error_no_calendar),
                 style = MaterialTheme.typography.titleMedium,
                 color = if (selectedCalendar == null) {

app/src/main/java/de/jeanlucmakiola/calendula/ui/filter/CalendarFilterList.kt

@@ -62,16 +62,15 @@ private fun FilterList(
 ) {
     Column(modifier = modifier.fillMaxWidth()) {
         groups.forEach { group ->
-            val account = group.account.ifBlank { stringResource(R.string.calendar_unnamed) }
             Text(
                 text = if (group.ambiguous) {
                     stringResource(
                         R.string.calendars_account_from_source,
-                        account,
+                        group.account,
                         sourceAppName(group.accountType),
                     )
                 } else {
-                    account
+                    group.account
                 },
                 style = MaterialTheme.typography.labelMedium,
                 color = MaterialTheme.colorScheme.onSurfaceVariant,
@@ -84,7 +83,7 @@ private fun FilterList(
             )
             group.calendars.forEachIndexed { index, cal ->
                 GroupedRow(
-                    title = cal.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
+                    title = cal.displayName,
                     position = positionOf(index, group.calendars.size),
                     minHeight = 56.dp,
                     leading = { CalendarColorChip(cal.color) },

app/src/main/java/de/jeanlucmakiola/calendula/ui/imports/ImportScreen.kt

@@ -73,19 +73,19 @@ import de.jeanlucmakiola.floret.identity.predictiveBack
 @Composable
 fun ImportScreen(
     uri: Uri,
-    session: Int,
     onClose: () -> Unit,
     onOpenSingle: (EventForm) -> Unit,
     forceMany: Boolean = false,
     onManageCalendars: (() -> Unit)? = null,
-    viewModel: ImportViewModel = hiltViewModel(),
+    // Key the VM by the file uri. This screen has no nav backstack, so an
+    // unkeyed hiltViewModel() resolves to the Activity's store and is retained
+    // across imports — its one-shot `load` guard would then show the *previous*
+    // file's parsed state on the next import (a second restore, export→restore,
+    // etc.). Keying per uri hands each distinct file a fresh VM (fresh Loading
+    // state), while the same uri (rotation) reuses it and holds the result.
+    viewModel: ImportViewModel = hiltViewModel(key = uri.toString()),
 ) {
-    // hiltViewModel() resolves to the Activity's store and is retained across
-    // imports, so the reload is driven by [session] rather than by a fresh VM:
-    // keying per uri looked right but handed a *re-import of the same file* the
-    // previous run's finished state, importing nothing (#304). A rotation keeps
-    // the session and so keeps the result.
-    LaunchedEffect(session) { viewModel.load(uri, forceMany, session) }
+    LaunchedEffect(uri) { viewModel.load(uri, forceMany) }
     val state by viewModel.state.collectAsStateWithLifecycle()
 
     // A single event isn't shown here — it opens the create form for review.

app/src/main/java/de/jeanlucmakiola/calendula/ui/imports/ImportViewModel.kt

@@ -16,7 +16,6 @@ import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
 import de.jeanlucmakiola.calendula.domain.ics.toEventForm
 import de.jeanlucmakiola.calendula.domain.isEventTarget
 import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
@@ -70,26 +69,18 @@ class ImportViewModel @Inject constructor(
     private val parser = IcsParser()
     private val _state = MutableStateFlow<ImportUiState>(ImportUiState.Loading)
     val state: StateFlow<ImportUiState> = _state.asStateFlow()
-    private var loadedSession: Int? = null
-    private var loadJob: Job? = null
+    private var started = false
 
     /**
-     * Read + parse [uri] once per [session]; recomposition (and a rotation,
-     * which keeps the session) re-calls this and keeps the result. A new import
-     * of the *same* file is a new session, and has to parse and run again —
-     * keying on the uri alone showed the previous run's summary and imported
-     * nothing (#304).
-     *
+     * Read + parse [uri] once; subsequent calls (recomposition) are ignored.
      * When [forceMany] is set (an in-app restore), a single-event file still goes
      * through the bulk picker + summary rather than the prefilled create form —
      * a restore is "bring back a backup", not "add this one event".
      */
-    fun load(uri: Uri, forceMany: Boolean = false, session: Int = 0) {
-        if (loadedSession == session) return
-        loadedSession = session
-        loadJob?.cancel()
-        _state.value = ImportUiState.Loading
-        loadJob = viewModelScope.launch {
+    fun load(uri: Uri, forceMany: Boolean = false) {
+        if (started) return
+        started = true
+        viewModelScope.launch {
             val parsed = withContext(io) {
                 importer.readText(uri)?.let(parser::parse)
             }

app/src/main/java/de/jeanlucmakiola/calendula/ui/month/MonthViewModel.kt

@@ -11,7 +11,6 @@ import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.domain.calendarListFailure
-import de.jeanlucmakiola.calendula.ui.common.PageStateCache
 import de.jeanlucmakiola.calendula.domain.isDeclined
 import de.jeanlucmakiola.calendula.ui.week.coversDay
 import de.jeanlucmakiola.calendula.ui.week.layoutAllDay
@@ -26,9 +25,6 @@ import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.filterNot
-import kotlinx.coroutines.flow.map
-import kotlin.math.abs
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.datetime.DateTimeUnit
@@ -48,9 +44,6 @@ import kotlin.time.Clock
 import kotlin.time.Instant
 import javax.inject.Inject
 
-/** How many months either side of the requested one [MonthViewModel.month] keeps cached. */
-private const val MONTH_CACHE_SPAN = 2
-
 @OptIn(ExperimentalCoroutinesApi::class)
 @HiltViewModel
 class MonthViewModel @Inject constructor(
@@ -94,21 +87,6 @@ class MonthViewModel @Inject constructor(
     private val _month = MutableStateFlow(YearMonth(todayDate.year, todayDate.month))
     val month: StateFlow<YearMonth> = _month
 
-    /** The pager page the anchor month sits on, for the paged and split styles. */
-    val anchorPage: StateFlow<Int> = _month
-        .map { monthIndexOf(it) }
-        .stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5_000L),
-            initialValue = monthIndexOf(_month.value),
-        )
-
-    /**
-     * The anchor month's state. Once loaded it never falls back to
-     * [MonthUiState.Loading]: moving the anchor keeps the last result until the
-     * new month arrives, since the pages draw their own months and this feeds
-     * the failure screen and the split style's day pane.
-     */
     val state: StateFlow<MonthUiState> =
         combine(_month, weekStart, viewStyle) { ym, ws, style -> Triple(ym, ws, style) }
             .flatMapLatest { (ym, ws, style) ->
@@ -116,48 +94,22 @@ class MonthViewModel @Inject constructor(
                 // Split draw, so under a scrolling style this query is a month
                 // of provider work for a view that isn't on screen.
                 if (style.isScrolling) return@flatMapLatest flowOf(MonthUiState.Loading)
-                month(ym, ws).filterNot { it is MonthUiState.Loading }
+                val range = monthGridRange(ym, ws, zone)
+                combine(
+                    repository.calendars(),
+                    repository.instances(range),
+                ) { calendars, instances ->
+                    buildState(ym, ws, calendars, instances)
+                }
             }
             .catch { emit(MonthUiState.Failure(FailureReason.ProviderUnavailable)) }
+            .flowOn(io)
             .stateIn(
                 scope = viewModelScope,
                 started = SharingStarted.WhileSubscribed(5_000L),
                 initialValue = MonthUiState.Loading,
             )
 
-    private val months = PageStateCache<Pair<YearMonth, DayOfWeek>, MonthUiState>(
-        scope = viewModelScope,
-        initial = MonthUiState.Loading,
-        // Far enough to cover the pages either side and a swipe back, so paging
-        // through a year doesn't keep a year of queries around. A week-start
-        // change lays every month out afresh.
-        keep = { (cached, cachedWs), (requested, ws) ->
-            cachedWs == ws && abs(monthIndexOf(cached) - monthIndexOf(requested)) <= MONTH_CACHE_SPAN
-        },
-    ) { (ym, ws) ->
-        combine(
-            repository.calendars(),
-            repository.instances(monthGridRange(ym, ws, zone)),
-        ) { calendars, instances ->
-            buildState(ym, ws, calendars, instances)
-        }
-            .catch { emit(MonthUiState.Failure(FailureReason.ProviderUnavailable)) }
-            .flowOn(io)
-    }
-
-    /**
-     * Month [ym] laid out with weeks starting on [ws], shared between its pager
-     * page and [state]. Main thread only.
-     */
-    fun month(ym: YearMonth, ws: DayOfWeek): StateFlow<MonthUiState> = months.get(ym to ws)
-
-    /** The pager came to rest on [page]; follow it unless it is already the anchor's. */
-    fun onPageSettled(page: Int) {
-        if (monthIndexOf(_month.value) == page) return
-        _month.value = yearMonthForIndex(page)
-        realignSelection()
-    }
-
     // --- Continuous + Dense styles (#38) ----------------------------------
     //
     // These scroll through every month there is, so they can't load "a month" —
@@ -292,10 +244,12 @@ class MonthViewModel @Inject constructor(
 
     // --- Split style (#53) ------------------------------------------------
     //
-    // Null means the full-month agenda; a date narrows the pane to that day.
+    // The first selected-day concept in the app: the other views drill straight
+    // into a date, while the split style keeps one selected and lists it below
+    // the grid.
 
-    private val _selectedDate = MutableStateFlow<LocalDate?>(null)
-    val selectedDate: StateFlow<LocalDate?> = _selectedDate
+    private val _selectedDate = MutableStateFlow(todayDate)
+    val selectedDate: StateFlow<LocalDate> = _selectedDate
 
     /**
      * Select [date], following it to its month if it sits in the grid's leading
@@ -303,33 +257,33 @@ class MonthViewModel @Inject constructor(
      * silently list a date the grid isn't pointing at.
      */
     fun selectDate(date: LocalDate) {
+        _selectedDate.value = date
         val target = YearMonth(date.year, date.month)
-        _selectedDate.value = if (target == _month.value && _selectedDate.value == date) null else date
         if (target != _month.value) _month.value = target
     }
 
-    fun clearSelection() { _selectedDate.value = null }
-
-    /** A pane swipe walks days when filtered, months when showing the agenda. */
-    fun stepSplitPane(days: Int) {
-        val selected = _selectedDate.value
-        if (selected == null) {
-            _month.value = yearMonthForIndex(monthIndexOf(_month.value) + days)
-        } else {
-            val next = selected.plus(days, DateTimeUnit.DAY)
-            _selectedDate.value = next
-            _month.value = YearMonth(next.year, next.month)
-        }
+    /**
+     * Move the selection with the month: today if the new month holds it, else
+     * its 1st. Leaving the old date selected would list a day the grid no longer
+     * shows.
+     */
+    private fun realignSelection() {
+        _selectedDate.value = selectionForMonth(_month.value, todayDate)
     }
 
-    /** Moving the grid to another month restores its full agenda. */
-    private fun realignSelection() {
-        _selectedDate.value = null
+    fun goToPrev() {
+        _month.value = _month.value.minus(1, DateTimeUnit.MONTH)
+        realignSelection()
+    }
+
+    fun goToNext() {
+        _month.value = _month.value.plus(1, DateTimeUnit.MONTH)
+        realignSelection()
     }
 
     fun goToToday() {
         _month.value = YearMonth(todayDate.year, todayDate.month)
-        _selectedDate.value = null
+        _selectedDate.value = todayDate
     }
 
     /**
@@ -338,12 +292,13 @@ class MonthViewModel @Inject constructor(
      * otherwise sit wherever paged navigation last left it (today's month, on a
      * fresh open) — and a switch to a paged style, or a reseed of the other
      * scrolling style's list, would jump there instead of holding position. The
-     * selection is cleared alongside it so Split opens the visible month's agenda.
+     * selection is realigned alongside it so that landing on the Split style
+     * shows a live day in the month on screen rather than a stale, off-month one.
      */
     fun syncScrollMonth(ym: YearMonth) {
         if (_month.value == ym) return
         _month.value = ym
-        _selectedDate.value = null
+        _selectedDate.value = selectionForMonth(ym, todayDate)
     }
 
     /** Jump to the month containing [date] (drawer jump-to-date). */
@@ -551,10 +506,11 @@ private const val WINDOW_EDGE = 2
 internal fun edgeForPad(pad: Int): Int = minOf(WINDOW_EDGE, pad - 1).coerceAtLeast(0)
 
 /**
- * First day shown in the split agenda: today in the current month, otherwise
- * the first of the visible month.
+ * Which day the split style should select when the grid lands on [month]:
+ * [today] when the month holds it, otherwise the 1st. Pure so the rule can be
+ * tested without standing up a view model and a provider behind it.
  */
-internal fun agendaStartForMonth(month: YearMonth, today: LocalDate): LocalDate =
+internal fun selectionForMonth(month: YearMonth, today: LocalDate): LocalDate =
     if (YearMonth(today.year, today.month) == month) {
         today
     } else {

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/CalendarsStep.kt

@@ -1,224 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.onboarding
-
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.CalendarMonth
-import androidx.compose.material.icons.filled.CheckCircle
-import androidx.compose.material.icons.filled.CloudSync
-import androidx.compose.material.icons.filled.PhoneAndroid
-import androidx.compose.material.icons.filled.Settings
-import androidx.compose.material3.Button
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.OutlinedButton
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.calendula.data.calendar.CalendarColorPalette
-import de.jeanlucmakiola.calendula.ui.calendars.CalendarEditor
-import de.jeanlucmakiola.calendula.ui.settings.openUrl
-import de.jeanlucmakiola.floret.components.BenefitRow
-import de.jeanlucmakiola.floret.components.OnboardingScaffold
-import de.jeanlucmakiola.floret.components.OnboardingSpace
-
-/** Where the sync branch sends someone who needs a CalDAV client (#287). */
-private const val DAVX5_URL = "https://www.davx5.com/"
-
-/**
- * Wizard step shown only when the device has no calendar at all (#287): the app
- * would otherwise finish onboarding onto an empty grid with nothing saying why.
- *
- * Two ways out. Calendula writes to the system calendar provider and syncs
- * nothing itself, so anything beyond a device-only calendar means pointing at
- * whatever does the syncing.
- *
- * [creation] switches the step to the outcome of its own create: confirming
- * the calendar — the one place to say that more of them live in Settings — or
- * reporting that the provider refused it.
- */
-@Composable
-internal fun CalendarsStep(
-    onCreateLocal: (name: String, color: Int, description: String?) -> Unit,
-    onSkip: () -> Unit,
-    creation: CalendarCreation?,
-    onFinished: () -> Unit,
-    onClearCreation: () -> Unit,
-    modifier: Modifier = Modifier,
-    progress: (@Composable () -> Unit)? = null,
-    navigationIcon: (@Composable () -> Unit)? = null,
-) {
-    val context = LocalContext.current
-    // The same editor Settings opens, rather than a calendar conjured out of
-    // nowhere: "create a calendar" should let you name and colour it, and the
-    // step is the first place anyone meets one.
-    var creating by rememberSaveable { mutableStateOf(false) }
-    // The insert is a suspend write: the editor stays up until it lands, so the
-    // step can't flash its "create" button back for a second press.
-    var submitted by rememberSaveable(creating) { mutableStateOf(false) }
-    LaunchedEffect(creation) { if (creation is CalendarCreation.Failed) creating = false }
-
-    if (creation is CalendarCreation.Created) {
-        CalendarCreated(
-            name = creation.name,
-            onContinue = onFinished,
-            modifier = modifier,
-            progress = progress,
-            navigationIcon = navigationIcon,
-        )
-        return
-    }
-
-    if (creating) {
-        CalendarEditor(
-            sessionKey = 0,
-            isNew = true,
-            // Empty, not a suggestion: a name already in the field reads as one
-            // the app has chosen, and the first thing to do is clear it.
-            initialName = "",
-            initialColor = CalendarColorPalette.all.first(),
-            initialDescription = "",
-            onSave = { name, color, description ->
-                if (!submitted) {
-                    submitted = true
-                    onCreateLocal(name, color, description)
-                }
-            },
-            onDelete = {},
-            onClose = { creating = false },
-        )
-        return
-    }
-
-    OnboardingScaffold(
-        modifier = modifier,
-        progress = progress,
-        navigationIcon = navigationIcon,
-        topSpacing = OnboardingSpace.lg,
-        hero = { IconHero(Icons.Filled.CalendarMonth) },
-        actions = {
-            Button(
-                onClick = {
-                    onClearCreation()
-                    creating = true
-                },
-                modifier = Modifier.fillMaxWidth().height(56.dp),
-            ) {
-                Text(
-                    text = stringResource(R.string.onboarding_calendars_local_button),
-                    style = MaterialTheme.typography.titleMedium,
-                )
-            }
-            OutlinedButton(
-                onClick = { openUrl(context, DAVX5_URL) },
-                modifier = Modifier.fillMaxWidth().height(56.dp),
-            ) {
-                Text(stringResource(R.string.onboarding_calendars_caldav_button))
-            }
-            TextButton(
-                onClick = onSkip,
-                modifier = Modifier.fillMaxWidth(),
-            ) {
-                Text(stringResource(R.string.onboarding_calendars_skip_button))
-            }
-        },
-    ) {
-        Text(
-            text = stringResource(R.string.onboarding_calendars_title),
-            style = MaterialTheme.typography.headlineMedium,
-            textAlign = TextAlign.Center,
-        )
-        Spacer(Modifier.height(12.dp))
-        Text(
-            text = stringResource(R.string.onboarding_calendars_body),
-            style = MaterialTheme.typography.bodyLarge,
-            color = MaterialTheme.colorScheme.onSurfaceVariant,
-            textAlign = TextAlign.Center,
-        )
-
-        if (creation is CalendarCreation.Failed) {
-            Spacer(Modifier.height(12.dp))
-            Text(
-                text = stringResource(R.string.onboarding_calendars_create_failed),
-                style = MaterialTheme.typography.bodyMedium,
-                color = MaterialTheme.colorScheme.error,
-                textAlign = TextAlign.Center,
-            )
-        }
-
-        Spacer(Modifier.height(OnboardingSpace.lg))
-
-        BenefitRow(
-            icon = Icons.Filled.PhoneAndroid,
-            title = stringResource(R.string.onboarding_calendars_benefit_local_title),
-            body = stringResource(R.string.onboarding_calendars_benefit_local_body),
-        )
-        Spacer(Modifier.height(OnboardingSpace.sm))
-        BenefitRow(
-            icon = Icons.Filled.CloudSync,
-            title = stringResource(R.string.onboarding_calendars_benefit_sync_title),
-            body = stringResource(R.string.onboarding_calendars_benefit_sync_body),
-        )
-    }
-}
-
-/** What the step shows once the calendar exists: that it does, and where the next one comes from. */
-@Composable
-private fun CalendarCreated(
-    name: String,
-    onContinue: () -> Unit,
-    modifier: Modifier = Modifier,
-    progress: (@Composable () -> Unit)? = null,
-    navigationIcon: (@Composable () -> Unit)? = null,
-) {
-    OnboardingScaffold(
-        modifier = modifier,
-        progress = progress,
-        navigationIcon = navigationIcon,
-        topSpacing = OnboardingSpace.lg,
-        hero = { IconHero(Icons.Filled.CheckCircle) },
-        actions = {
-            Button(
-                onClick = onContinue,
-                modifier = Modifier.fillMaxWidth().height(56.dp),
-            ) {
-                Text(
-                    text = stringResource(R.string.onboarding_calendars_created_continue),
-                    style = MaterialTheme.typography.titleMedium,
-                )
-            }
-        },
-    ) {
-        Text(
-            text = stringResource(R.string.onboarding_calendars_created_title, name),
-            style = MaterialTheme.typography.headlineMedium,
-            textAlign = TextAlign.Center,
-        )
-        Spacer(Modifier.height(12.dp))
-        Text(
-            text = stringResource(R.string.onboarding_calendars_created_body),
-            style = MaterialTheme.typography.bodyLarge,
-            color = MaterialTheme.colorScheme.onSurfaceVariant,
-            textAlign = TextAlign.Center,
-        )
-
-        Spacer(Modifier.height(OnboardingSpace.lg))
-
-        BenefitRow(
-            icon = Icons.Filled.Settings,
-            title = stringResource(R.string.onboarding_calendars_created_more_title),
-            body = stringResource(R.string.onboarding_calendars_created_more_body),
-        )
-    }
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/HiddenCalendarsStep.kt

@@ -1,173 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.onboarding
-
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.VisibilityOff
-import androidx.compose.material3.Button
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Switch
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.semantics.contentDescription
-import androidx.compose.ui.semantics.semantics
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.hasVisibilitySwitch
-import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
-import de.jeanlucmakiola.floret.components.GroupedListInset
-import de.jeanlucmakiola.floret.components.GroupedRow
-import de.jeanlucmakiola.floret.components.OnboardingScaffold
-import de.jeanlucmakiola.floret.components.OnboardingSpace
-import de.jeanlucmakiola.floret.components.Position
-
-/**
- * Wizard step for a device whose every calendar is switched off (#287), which
- * would otherwise open the app on a blank grid with nothing saying why.
- *
- * The calendars are listed rather than summarised: which ones exist and whose
- * account they came from is the whole of what there is to decide, and switching
- * them on shows them in every other calendar app too — not a choice to make on
- * the app's word. Each row carries the same switch Settings does; the button
- * above them does all of it at once.
- *
- * Declining leads into the calendar step behind this one, which offers to make a
- * calendar instead — the same offer a device with none at all gets.
- */
-@Composable
-internal fun HiddenCalendarsStep(
-    calendars: List<CalendarSource>,
-    onSetVisible: (id: Long, visible: Boolean) -> Unit,
-    onSwitchAllOn: () -> Unit,
-    onFinished: () -> Unit,
-    writeFailed: Boolean,
-    modifier: Modifier = Modifier,
-    progress: (@Composable () -> Unit)? = null,
-    navigationIcon: (@Composable () -> Unit)? = null,
-) {
-    val anyVisible = calendars.any { it.isVisibleInSystem }
-    OnboardingScaffold(
-        modifier = modifier,
-        progress = progress,
-        navigationIcon = navigationIcon,
-        topSpacing = OnboardingSpace.sm,
-        contentPadding = 0.dp,
-        // The list is as long as the device's calendars; pinned actions would
-        // eat the room it needs and hide that there is more below.
-        scrollingActions = true,
-        hero = { IconHero(Icons.Filled.VisibilityOff) },
-        actions = {
-            Button(
-                onClick = if (anyVisible) onFinished else onSwitchAllOn,
-                modifier = Modifier
-                    .padding(horizontal = GroupedListInset)
-                    .fillMaxWidth()
-                    .height(56.dp),
-            ) {
-                Text(
-                    text = stringResource(
-                        if (anyVisible) {
-                            R.string.onboarding_view_continue_button
-                        } else {
-                            R.string.onboarding_hidden_switch_all_button
-                        },
-                    ),
-                    style = MaterialTheme.typography.titleMedium,
-                )
-            }
-            // Only while nothing is on: once something is, the step has been
-            // answered and the one button left to press says so.
-            if (!anyVisible) {
-                TextButton(
-                    onClick = onFinished,
-                    modifier = Modifier
-                        .padding(horizontal = GroupedListInset)
-                        .fillMaxWidth(),
-                ) {
-                    Text(stringResource(R.string.onboarding_hidden_skip_button))
-                }
-            }
-        },
-    ) {
-        Column(Modifier.padding(horizontal = GroupedListInset)) {
-            Text(
-                text = stringResource(R.string.onboarding_hidden_title),
-                style = MaterialTheme.typography.headlineMedium,
-                textAlign = TextAlign.Center,
-                modifier = Modifier.fillMaxWidth(),
-            )
-            Spacer(Modifier.height(12.dp))
-            Text(
-                text = stringResource(R.string.onboarding_hidden_body),
-                style = MaterialTheme.typography.bodyLarge,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                textAlign = TextAlign.Center,
-                modifier = Modifier.fillMaxWidth(),
-            )
-            if (writeFailed) {
-                Spacer(Modifier.height(12.dp))
-                Text(
-                    text = stringResource(R.string.onboarding_hidden_failed),
-                    style = MaterialTheme.typography.bodyMedium,
-                    color = MaterialTheme.colorScheme.error,
-                    textAlign = TextAlign.Center,
-                    modifier = Modifier.fillMaxWidth(),
-                )
-            }
-        }
-
-        Spacer(Modifier.height(OnboardingSpace.md))
-
-        calendars.forEachIndexed { index, calendar ->
-            val off = !calendar.isVisibleInSystem
-            GroupedRow(
-                title = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
-                summary = calendar.accountName.takeIf { it.isNotBlank() },
-                position = when {
-                    calendars.size == 1 -> Position.Alone
-                    index == 0 -> Position.Top
-                    index == calendars.lastIndex -> Position.Bottom
-                    else -> Position.Middle
-                },
-                dimmed = off,
-                trailing = if (calendar.hasVisibilitySwitch) {
-                    {
-                        CalendarSwitch(
-                            calendarName = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
-                            enabled = !off,
-                            onToggle = { on -> onSetVisible(calendar.id, on) },
-                        )
-                    }
-                } else {
-                    null
-                },
-                leading = { CalendarColorChip(calendar.color) },
-            )
-        }
-
-        Spacer(Modifier.height(OnboardingSpace.md))
-    }
-}
-
-/** The per-row switch, writing the device's own `Calendars.VISIBLE` as Settings does. */
-@Composable
-private fun CalendarSwitch(
-    calendarName: String,
-    enabled: Boolean,
-    onToggle: (Boolean) -> Unit,
-) {
-    val label = stringResource(R.string.calendars_visibility_a11y, calendarName)
-    Switch(
-        checked = enabled,
-        onCheckedChange = onToggle,
-        modifier = Modifier.semantics { contentDescription = label },
-    )
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/OnboardingPlan.kt

@@ -5,19 +5,6 @@ enum class OnboardingStep {
     /** Required: nothing works without the calendar grant. */
     Permission,
 
-    /**
-     * Only when every calendar on the device is switched off, so the app would
-     * open on a blank grid: lists them and offers to switch them back on (#287).
-     */
-    HiddenCalendars,
-
-    /**
-     * Only when the device has nothing to put an event in — no calendar at all,
-     * or none left showing after the step above. The app can make a local one,
-     * or send you to whatever would do the syncing (#287).
-     */
-    Calendars,
-
     /** Whether Calendula delivers reminder notifications itself. */
     Reminders,
 
@@ -80,18 +67,6 @@ data class OnboardingPlan(
  * otherwise, so the flow can only ever get shorter — never sprout a step the
  * counter had not accounted for.
  *
- * [calendarsApplies] carries the same contract for the calendar step, with one
- * wrinkle: for the backup step an empty list means "could not read", but here
- * an empty list *is* the condition. The two are indistinguishable at this
- * layer and both want the step, so it turns false only once a calendar the app
- * could actually show has arrived.
- *
- * [hiddenApplies] is the step in front of it (#287): the device has calendars
- * but every one of them is switched off. It comes first because switching one
- * back on is the lighter remedy — and where it is declined, the calendar step
- * behind it still offers to make one, the same offer a device with no calendars
- * at all gets.
- *
  * The month-style step is *not* conditional on Month being the chosen view:
  * Month is reachable from the drawer whatever opens first, and a step that came
  * and went as the view is picked would move the counter under the user on the
@@ -100,9 +75,7 @@ data class OnboardingPlan(
  * [visibilityArmed] carries the one-time notice that the device is hiding some
  * calendars (#75) — the only optional step an *existing* install can be given,
  * which is why it is not gated on `fresh`, and on its own it earns no closing
- * screen. It stays a pure announcement: the all-hidden *state* is
- * [hiddenApplies]'s business, up at the front of the flow where something can
- * still be done about it.
+ * screen.
  */
 fun onboardingPlan(
     hasPermission: Boolean,
@@ -112,10 +85,6 @@ fun onboardingPlan(
     viewDone: Boolean,
     monthStyleDone: Boolean,
     backupApplies: Boolean?,
-    hiddenDone: Boolean = false,
-    hiddenApplies: Boolean? = false,
-    calendarsDone: Boolean = false,
-    calendarsApplies: Boolean? = null,
     visibilityArmed: Boolean = false,
     visibilityDone: Boolean = false,
     doneShown: Boolean = false,
@@ -123,8 +92,6 @@ fun onboardingPlan(
     val fresh = wizardArmed || (!hasPermission && !remindersDone)
     val steps = buildList {
         if (!hasPermission || fresh) add(OnboardingStep.Permission)
-        if (fresh && hiddenApplies != false) add(OnboardingStep.HiddenCalendars)
-        if (fresh && calendarsApplies != false) add(OnboardingStep.Calendars)
         if (!remindersDone || fresh) add(OnboardingStep.Reminders)
         if (fresh && backupApplies != false) add(OnboardingStep.Backup)
         if (fresh) {
@@ -137,8 +104,6 @@ fun onboardingPlan(
     val current = steps.firstOrNull { step ->
         when (step) {
             OnboardingStep.Permission -> !hasPermission
-            OnboardingStep.HiddenCalendars -> !hiddenDone
-            OnboardingStep.Calendars -> !calendarsDone
             OnboardingStep.Reminders -> !remindersDone
             OnboardingStep.Backup -> !backupDone
             OnboardingStep.View -> !viewDone

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/OnboardingSteps.kt

@@ -28,9 +28,6 @@ fun OnboardingSteps(
     // Collected for every step, not just the two that draw a preview: starting
     // it when the picker composes would leave that step blank as it slides in.
     val choice by viewModel.viewChoice.collectAsStateWithLifecycle()
-    val creation by viewModel.creation.collectAsStateWithLifecycle()
-    val hiddenCalendars by viewModel.hiddenCalendars.collectAsStateWithLifecycle()
-    val hiddenWriteFailed by viewModel.hiddenWriteFailed.collectAsStateWithLifecycle()
 
     // Coerced because the outgoing half of a transition may be a step the live
     // plan has since dropped — the backup step goes once the calendars say it
@@ -70,26 +67,6 @@ fun OnboardingSteps(
             modifier = modifier,
             progress = progress,
         )
-        OnboardingStep.HiddenCalendars -> HiddenCalendarsStep(
-            calendars = hiddenCalendars,
-            onSetVisible = viewModel::setHiddenCalendarVisible,
-            onSwitchAllOn = viewModel::switchAllCalendarsOn,
-            onFinished = viewModel::finishHiddenCalendars,
-            writeFailed = hiddenWriteFailed,
-            modifier = modifier,
-            progress = progress,
-            navigationIcon = navigationIcon,
-        )
-        OnboardingStep.Calendars -> CalendarsStep(
-            onCreateLocal = viewModel::createLocalCalendar,
-            onSkip = viewModel::skipCalendars,
-            creation = creation,
-            onFinished = viewModel::finishCalendars,
-            onClearCreation = viewModel::clearCalendarCreation,
-            modifier = modifier,
-            progress = progress,
-            navigationIcon = navigationIcon,
-        )
         OnboardingStep.Reminders -> ReminderStep(
             onFinished = viewModel::finishReminders,
             modifier = modifier,

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/OnboardingViewModel.kt

@@ -16,8 +16,6 @@ import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
 import de.jeanlucmakiola.calendula.data.reminders.ReminderScanner
 import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.hasVisibilitySwitch
-import de.jeanlucmakiola.calendula.domain.orderedForManager
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
 import kotlinx.coroutines.CoroutineDispatcher
@@ -26,7 +24,6 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.first
@@ -77,27 +74,6 @@ class OnboardingViewModel @Inject constructor(
             initialValue = null,
         )
 
-    /**
-     * The calendar list every derived step reads, collected once: one per step
-     * would put a provider query each on every visibility tick, and let the
-     * steps judge different snapshots of the same moment. Null is "no list to
-     * judge" — before the grant, and on a read that failed.
-     */
-    private val calendars: StateFlow<List<CalendarSource>?> = hasPermission
-        .flatMapLatest { granted ->
-            if (granted != true) {
-                flowOf(null)
-            } else {
-                val list: Flow<List<CalendarSource>?> = repository.calendars()
-                list.catch { emit(null) }.flowOn(io)
-            }
-        }
-        .stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5_000L),
-            initialValue = null,
-        )
-
     /**
      * Whether the backup step applies: something of yours is worth exporting and
      * nothing you write to is synced anywhere. Null while the calendar list
@@ -105,90 +81,17 @@ class OnboardingViewModel @Inject constructor(
      * an empty list is also how a null cursor arrives, and guessing false there
      * would drop the step for the whole session.
      */
-    private val backupApplies: Flow<Boolean?> = calendars.map { list ->
-        if (list.isNullOrEmpty()) null else list.backupApplies()
+    private val backupApplies: Flow<Boolean?> = hasPermission.flatMapLatest { granted ->
+        if (granted != true) {
+            flowOf(null)
+        } else {
+            repository.calendars()
+                .map { calendars -> if (calendars.isEmpty()) null else calendars.backupApplies() }
+                .catch { emit(null) }
+                .flowOn(io)
+        }
     }
 
-    /** How the step's own create attempt ended, while it is still saying so (#287). */
-    private val _creation = MutableStateFlow<CalendarCreation?>(null)
-    val creation: StateFlow<CalendarCreation?> = _creation.asStateFlow()
-
-    /**
-     * Whether the step made a calendar here. Latched for the session and never
-     * cleared: the new calendar answers [calendarsApplies] with false, which
-     * would drop the step out of the plan the moment it is used — first from
-     * under the message that it worked, and then from the step count, which
-     * would fall by one just as the user pressed Continue.
-     */
-    private val calendarCreatedHere = MutableStateFlow(false)
-
-    /**
-     * Whether the calendar step applies: the device has nothing to show and so
-     * nothing to put events in. Unlike [backupApplies] an empty list is the
-     * condition itself, not a failed read — the two look identical here and both
-     * want the step, so this only resolves once a calendar the app can actually
-     * show has arrived. Calendars that exist but are all switched off leave it
-     * unresolved too: the step in front (#287) offers to switch them on, and
-     * declining that lands here, on the same offer a device with none gets.
-     */
-    private val calendarsApplies: Flow<Boolean?> = combine(
-        calendars.map { list -> if (list?.any { it.isVisibleInSystem } == true) false else null },
-        calendarCreatedHere,
-    ) { applies, latched -> if (latched) null else applies }
-
-    /**
-     * Set when the step starts a write of its own, and never cleared: from that
-     * moment the step holds its place in the plan until it is answered. Set
-     * *before* the write rather than after it, because a successful one answers
-     * [hiddenApplies] with false — the step would drop out between the provider
-     * taking the change and the latch seeing it.
-     */
-    private val hiddenTouched = MutableStateFlow(false)
-
-    /** A visibility write the provider did not take, while the step says so (#287). */
-    private val _hiddenWriteFailed = MutableStateFlow(false)
-    val hiddenWriteFailed: StateFlow<Boolean> = _hiddenWriteFailed.asStateFlow()
-
-    /**
-     * Whether the device is showing nothing at all right now: calendars exist,
-     * none is visible, and at least one of them has a switch the step can flip
-     * (#287). Null only while there is no list to judge — before the grant, and
-     * on a read that failed — which keeps the step in the plan until the answer
-     * arrives, the same shrink-only contract [backupApplies] keeps.
-     *
-     * An empty list answers false rather than null, unlike [calendarsApplies]:
-     * a phone with no calendars at all is the next step's business, and this one
-     * would be listing calendars it cannot see. [hiddenTouched] holds it at null
-     * from the step's first write onwards.
-     */
-    private val hiddenApplies: Flow<Boolean?> = combine(
-        calendars.map { list -> list?.allHidden() },
-        hiddenTouched,
-    ) { hidden, touched -> if (touched) null else hidden }
-
-    /** Both calendar steps' inputs: what each applies to, and whether it is answered. */
-    private val calendarsFlags: Flow<CalendarsFlags> = combine(
-        calendarsApplies,
-        prefs.onboardingCalendarsDone,
-        hiddenApplies,
-        prefs.onboardingHiddenCalendarsDone,
-        ::CalendarsFlags,
-    )
-
-    /**
-     * The calendars the hidden-calendars step lists, so the user can judge which
-     * to switch on rather than take the app's word that there are some. Live: a
-     * row follows its own switch, and the ones without one stay listed anyway —
-     * being told a calendar exists is half the point.
-     */
-    val hiddenCalendars: StateFlow<List<CalendarSource>> = calendars
-        .map { it.orEmpty().orderedForManager() }
-        .stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5_000L),
-            initialValue = emptyList(),
-        )
-
     private val flags: Flow<OnboardingFlags> = combine(
         prefs.reminderOnboardingDone,
         prefs.onboardingWizardArmed,
@@ -207,13 +110,7 @@ class OnboardingViewModel @Inject constructor(
     )
 
     val plan: StateFlow<OnboardingPlan?> =
-        combine(
-            hasPermission,
-            flags,
-            closingFlags,
-            backupApplies,
-            calendarsFlags,
-        ) { granted, stored, closing, backup, calendars ->
+        combine(hasPermission, flags, closingFlags, backupApplies) { granted, stored, closing, backup ->
             granted?.let {
                 onboardingPlan(
                     hasPermission = it,
@@ -223,10 +120,6 @@ class OnboardingViewModel @Inject constructor(
                     viewDone = stored.viewDone,
                     monthStyleDone = stored.monthStyleDone,
                     backupApplies = backup,
-                    hiddenDone = calendars.hiddenDone,
-                    hiddenApplies = calendars.hiddenApplies,
-                    calendarsDone = calendars.done,
-                    calendarsApplies = calendars.applies,
                     visibilityArmed = closing.visibilityArmed,
                     visibilityDone = closing.visibilityDone,
                     doneShown = closing.doneShown,
@@ -293,8 +186,6 @@ class OnboardingViewModel @Inject constructor(
     fun goBack() {
         viewModelScope.launch {
             when (plan.value?.previous) {
-                OnboardingStep.HiddenCalendars -> prefs.setOnboardingHiddenCalendarsDone(false)
-                OnboardingStep.Calendars -> prefs.setOnboardingCalendarsDone(false)
                 OnboardingStep.Reminders -> prefs.setReminderOnboardingDone(false)
                 OnboardingStep.Backup -> prefs.setOnboardingBackupDone(false)
                 OnboardingStep.View -> prefs.setOnboardingViewDone(false)
@@ -311,53 +202,6 @@ class OnboardingViewModel @Inject constructor(
         viewModelScope.launch { prefs.setOnboardingBackupDone() }
     }
 
-    /**
-     * Make the device-only calendar the step's editor just described. The step
-     * stays up on [creation] either way — to confirm the calendar and say where
-     * to make more, or to say the provider refused it. Answering the step for
-     * them would leave them where the step exists to stop them being: past it,
-     * with nowhere to put an event.
-     */
-    fun createLocalCalendar(displayName: String, color: Int, description: String?) {
-        viewModelScope.launch {
-            val name = displayName.trim()
-            _creation.value = runCatching {
-                repository.createLocalCalendar(
-                    displayName = name,
-                    color = color,
-                    description = description,
-                )
-            }.fold(
-                onSuccess = {
-                    calendarCreatedHere.value = true
-                    CalendarCreation.Created(name)
-                },
-                onFailure = { CalendarCreation.Failed },
-            )
-        }
-    }
-
-    /** Close the calendar step once its confirmation has been read. */
-    fun finishCalendars() {
-        viewModelScope.launch {
-            prefs.setOnboardingCalendarsDone()
-            _creation.value = null
-        }
-    }
-
-    /** Drop the failed attempt so the step offers itself again. */
-    fun clearCalendarCreation() {
-        _creation.value = null
-    }
-
-    /**
-     * Close the calendar step without making one. An empty app is a legitimate
-     * choice, and so is going off to set up an account and coming back.
-     */
-    fun skipCalendars() {
-        viewModelScope.launch { prefs.setOnboardingCalendarsDone() }
-    }
-
     /**
      * Turn automatic backup on, writing to the folder the user just picked
      * (taking a durable write grant so background runs can keep writing), and
@@ -402,52 +246,6 @@ class OnboardingViewModel @Inject constructor(
         viewModelScope.launch { prefs.setOnboardingMonthStyleDone() }
     }
 
-    /** Switch one listed calendar on or off, from the hidden-calendars step (#287). */
-    fun setHiddenCalendarVisible(id: Long, visible: Boolean) = visibilityWrite {
-        repository.setCalendarsVisible(listOf(id), visible)
-        calendarList().any { it.id == id && it.isVisibleInSystem == visible }
-    }
-
-    /** Switch every hidden calendar back on — the step's one-tap way out (#287). */
-    fun switchAllCalendarsOn() = visibilityWrite {
-        val hidden = calendarList().filter { it.hasVisibilitySwitch && !it.isVisibleInSystem }
-        // Nothing to write is not a write that landed: a list that came back
-        // empty (a failed read) would otherwise report success and leave the
-        // step sitting there with no rows and no explanation.
-        if (hidden.isEmpty()) return@visibilityWrite false
-        repository.setCalendarsVisible(hidden.map { it.id }, true)
-        calendarList().any { it.isVisibleInSystem }
-    }
-
-    /**
-     * Run one of the step's visibility writes, whose lambda answers whether it
-     * took. Checked rather than assumed: with read-only calendar access the
-     * choice is kept app-side (#75) and nothing the grid shows would change.
-     */
-    private fun visibilityWrite(landed: suspend () -> Boolean) {
-        viewModelScope.launch {
-            hiddenTouched.value = true
-            _hiddenWriteFailed.value = !runCatching { landed() }.getOrDefault(false)
-        }
-    }
-
-    private suspend fun calendarList(): List<CalendarSource> = repository.calendars().first()
-
-    /** Close the hidden-calendars step, switched on or left as they were (#287). */
-    fun finishHiddenCalendars() {
-        viewModelScope.launch {
-            prefs.setOnboardingHiddenCalendarsDone()
-            // The error belongs to the attempt, not to the step: stepping back
-            // into it later must not find a refusal nothing has asked for yet.
-            _hiddenWriteFailed.value = false
-            val list = calendarList()
-            // Switching them all back on answers the one-time notice too (#75) —
-            // it would otherwise announce, at the end of this same flow, that the
-            // device is hiding calendars it no longer hides.
-            if (list.isNotEmpty() && list.all { it.isVisibleInSystem }) retireVisibilityNotice()
-        }
-    }
-
     /** Acknowledge the calendar-visibility notice (#75). */
     fun finishVisibility() {
         viewModelScope.launch {
@@ -497,20 +295,6 @@ private data class OnboardingFlags(
     val monthStyleDone: Boolean,
 )
 
-/** How the calendar step's create attempt ended (#287). */
-sealed interface CalendarCreation {
-    data class Created(val name: String) : CalendarCreation
-    data object Failed : CalendarCreation
-}
-
-/** Both calendar steps' inputs (#287). */
-private data class CalendarsFlags(
-    val applies: Boolean?,
-    val done: Boolean,
-    val hiddenApplies: Boolean?,
-    val hiddenDone: Boolean,
-)
-
 /** The tail of the flow: the visibility notice and the closing screen. */
 private data class ClosingFlags(
     val visibilityArmed: Boolean,
@@ -525,15 +309,6 @@ data class ViewChoice(
     val weekStart: WeekStartPref,
 )
 
-/**
- * True when this device would show nothing and the step could change that: no
- * calendar is visible, and at least one of them has a switch worth flipping —
- * a non-syncing calendar holds no events on the device, so switching it on
- * leaves the grid exactly as empty (#287).
- */
-private fun List<CalendarSource>.allHidden(): Boolean =
-    any { it.hasVisibilitySwitch } && none { it.isVisibleInSystem }
-
 /**
  * True when this device holds events that live nowhere else: at least one local
  * calendar worth exporting, and no writable synced calendar to carry them.

app/src/main/java/de/jeanlucmakiola/calendula/ui/onboarding/ViewStep.kt

@@ -18,11 +18,10 @@ import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import de.jeanlucmakiola.calendula.ui.agenda.AgendaViewPreview
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
-import de.jeanlucmakiola.calendula.ui.common.LocalMultiDayCount
 import de.jeanlucmakiola.calendula.ui.common.PickerDescription
 import de.jeanlucmakiola.calendula.ui.common.ViewPreviewFrame
 import de.jeanlucmakiola.calendula.ui.common.icon
-import de.jeanlucmakiola.calendula.ui.common.label
+import de.jeanlucmakiola.calendula.ui.common.labelRes
 import de.jeanlucmakiola.calendula.ui.day.DayViewPreview
 import de.jeanlucmakiola.calendula.ui.month.MonthStylePreview
 import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
@@ -68,11 +67,6 @@ internal fun ViewStep(
                     height = PREVIEW_HEIGHT,
                 )
                 CalendarView.Week -> WeekViewPreview(weekStart = weekStart, height = PREVIEW_HEIGHT)
-                CalendarView.MultiDay -> WeekViewPreview(
-                    weekStart = weekStart,
-                    height = PREVIEW_HEIGHT,
-                    dayCount = LocalMultiDayCount.current,
-                )
                 CalendarView.Day -> DayViewPreview(height = PREVIEW_HEIGHT)
                 CalendarView.Agenda -> AgendaViewPreview(height = PREVIEW_HEIGHT)
             }
@@ -80,7 +74,7 @@ internal fun ViewStep(
         IMPLEMENTED_VIEWS.forEachIndexed { index, view ->
             val isSelected = view == choice.defaultView
             GroupedRow(
-                title = view.label(),
+                title = stringResource(view.labelRes),
                 position = positionOf(index, IMPLEMENTED_VIEWS.size),
                 selected = isSelected,
                 leading = {

app/src/main/java/de/jeanlucmakiola/calendula/ui/search/SearchScreen.kt

@@ -509,9 +509,6 @@ private fun SearchResultRow(
     onLongClick: (() -> Unit)? = null,
 ) {
     val event = hit.event
-    // Spans are empty for a blank title — the query never matches the
-    // placeholder — so marking the substitute is safe.
-    val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
     val dark = isSystemInDarkTheme()
     val soften = LocalSoftenColors.current
     // On a picked row the headline is already recoloured for the secondary
@@ -524,7 +521,7 @@ private fun SearchResultRow(
         // Faded like a past event anywhere else in the app — search reaches back
         // through the whole history.
         modifier = if (hit.isPast) modifier.alpha(EventDimAlpha) else modifier,
-        title = declinedTitle(marked(title, hit.titleSpans, highlight), event.isDeclined),
+        title = declinedTitle(marked(event.title, hit.titleSpans, highlight), event.isDeclined),
         summary = searchSummary(hit, highlight),
         position = position,
         minHeight = 64.dp,

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/EventFormSettings.kt

@@ -143,7 +143,7 @@ internal fun EventFormScreen(
                     durationCalendars.forEachIndexed { index, calendar ->
                         val override = state.perCalendarEventDuration[calendar.id]
                         GroupedRow(
-                            title = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
+                            title = calendar.displayName,
                             summary = override?.let { durationLabel(it) }
                                 ?: stringResource(
                                     R.string.settings_calendar_duration_inherits,

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/NotificationSettings.kt

@@ -181,7 +181,7 @@ internal fun NotificationsScreen(
                         // own section — link there instead.
                         if (calendar.id in state.managedCalendarIds) {
                             GroupedRow(
-                                title = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
+                                title = calendar.displayName,
                                 summary = stringResource(R.string.settings_calendar_reminders_managed_hint),
                                 position = Position.Alone,
                                 leading = { CalendarColorChip(calendar.color) },
@@ -198,7 +198,7 @@ internal fun NotificationsScreen(
                         }
                         val expanded = calendar.id in expandedCalendars
                         GroupedRow(
-                            title = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
+                            title = calendar.displayName,
                             position = if (expanded) Position.Top else Position.Alone,
                             leading = { CalendarColorChip(calendar.color) },
                             trailing = {

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsUiState.kt

@@ -13,7 +13,6 @@ import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
-import de.jeanlucmakiola.calendula.ui.common.TimelineHours
 import de.jeanlucmakiola.calendula.ui.common.TimelineScale
 import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
 import de.jeanlucmakiola.calendula.widget.WidgetSize
@@ -35,8 +34,6 @@ data class SettingsUiState(
     val timeFormat: TimeFormatPref = TimeFormatPref.AUTO,
     /** Whether the week/day timeline seats each hour in its own cell (v2.11). */
     val showHourGrid: Boolean = false,
-    /** Days the multi-day view shows side by side (#193). */
-    val multiDayCount: Int = SettingsPrefs.DEFAULT_MULTI_DAY_COUNT,
     /** How the Agenda screen treats events that already ended today. */
     val pastEventDisplay: PastEventDisplay = PastEventDisplay.SHOW,
     /** Whether the month/week grids fade events that have already finished. */
@@ -65,7 +62,6 @@ data class SettingsUiState(
     val monthViewStyle: MonthViewStyle = MonthViewStyle.Paged,
     /** How tall an hour is drawn in the week and day timelines (#56). */
     val timelineScale: TimelineScale = TimelineScale.Regular,
-    val timelineHours: TimelineHours = TimelineHours(),
     /** Order of the views in the navigation drawer (#24); every view is always listed. */
     val drawerViewOrder: List<CalendarView> = IMPLEMENTED_VIEWS,
     /** Optional event-form fields shown by default (rest behind "more fields"). */

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsViewModel.kt

@@ -36,7 +36,6 @@ import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.agenda.storageValue
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
-import de.jeanlucmakiola.calendula.ui.common.TimelineHours
 import de.jeanlucmakiola.calendula.ui.common.TimelineScale
 import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
 import de.jeanlucmakiola.calendula.ui.theme.AppFontSettings
@@ -149,12 +148,11 @@ class SettingsViewModel @Inject constructor(
                     combine(
                         prefs.todayButtonInToolbar,
                         prefs.dragToReschedule,
-                        prefs.multiDayCount,
-                        ::Triple,
+                        ::Pair,
                     ),
-                ) { hourLines, weekNumbers, showToday, soften, (todayInToolbar, dragToMove, multiDay) ->
+                ) { hourLines, weekNumbers, showToday, soften, (todayInToolbar, dragToMove) ->
                     DisplayToggles(
-                        hourLines, weekNumbers, showToday, soften, todayInToolbar, dragToMove, multiDay,
+                        hourLines, weekNumbers, showToday, soften, todayInToolbar, dragToMove,
                     )
                 },
             ) { view, screenRange, widgetRange, timeFormat, toggles ->
@@ -166,7 +164,6 @@ class SettingsViewModel @Inject constructor(
                     softenColors = toggles.softenColors,
                     todayButtonInToolbar = toggles.todayButtonInToolbar,
                     dragToReschedule = toggles.dragToReschedule,
-                    multiDayCount = toggles.multiDayCount,
                 )
             },
             combine(
@@ -181,11 +178,9 @@ class SettingsViewModel @Inject constructor(
                     prefs.drawerViewOrder,
                     prefs.monthViewStyle,
                     prefs.widgetSize,
-                    combine(prefs.timelineScale, prefs.timelineHours, ::Pair),
-                ) { quickSwitch, drawer, monthStyle, widgetSize, (timelineScale, timelineHours) ->
-                    ViewCustomization(
-                        quickSwitch, drawer, monthStyle, widgetSize, timelineScale, timelineHours,
-                    )
+                    prefs.timelineScale,
+                ) { quickSwitch, drawer, monthStyle, widgetSize, timelineScale ->
+                    ViewCustomization(quickSwitch, drawer, monthStyle, widgetSize, timelineScale)
                 },
             ) { showRangeBar, autofocus, pastEvents, dimCompleted, viewCustomization ->
                 MiscSettings(showRangeBar, autofocus, pastEvents, dimCompleted, viewCustomization)
@@ -202,7 +197,6 @@ class SettingsViewModel @Inject constructor(
                 softenColors = views.softenColors,
                 todayButtonInToolbar = views.todayButtonInToolbar,
                 dragToReschedule = views.dragToReschedule,
-                multiDayCount = views.multiDayCount,
                 agendaShowRangeBar = misc.showRangeBar,
                 autofocusEventTitle = misc.autofocusEventTitle,
                 pastEventDisplay = misc.pastEventDisplay,
@@ -212,7 +206,6 @@ class SettingsViewModel @Inject constructor(
                 monthViewStyle = misc.viewCustomization.monthViewStyle,
                 widgetSize = misc.viewCustomization.widgetSize,
                 timelineScale = misc.viewCustomization.timelineScale,
-                timelineHours = misc.viewCustomization.timelineHours,
                 allowColorOnUnsupportedCalendars = defaults.allowColor,
                 defaultReminderMinutes = defaults.defaultReminder,
                 defaultAllDayReminderMinutes = defaults.allDayReminder,
@@ -305,7 +298,6 @@ class SettingsViewModel @Inject constructor(
         val softenColors: Boolean,
         val todayButtonInToolbar: Boolean,
         val dragToReschedule: Boolean,
-        val multiDayCount: Int,
     )
 
     private data class DisplayToggles(
@@ -315,7 +307,6 @@ class SettingsViewModel @Inject constructor(
         val softenColors: Boolean,
         val todayButtonInToolbar: Boolean,
         val dragToReschedule: Boolean,
-        val multiDayCount: Int,
     )
 
     private data class MiscSettings(
@@ -332,7 +323,6 @@ class SettingsViewModel @Inject constructor(
         val monthViewStyle: MonthViewStyle,
         val widgetSize: WidgetSize,
         val timelineScale: TimelineScale,
-        val timelineHours: TimelineHours,
     )
 
     /** Contact special-dates sub-page (issue #15); its own flow — the main state is full. */
@@ -542,10 +532,6 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch { prefs.setTimeFormat(pref) }
     }
 
-    fun setMultiDayCount(count: Int) {
-        viewModelScope.launch { prefs.setMultiDayCount(count) }
-    }
-
     fun setShowHourGrid(enabled: Boolean) {
         viewModelScope.launch { prefs.setShowHourGrid(enabled) }
     }
@@ -631,10 +617,6 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch { prefs.setTimelineScale(scale) }
     }
 
-    fun setTimelineHours(hours: TimelineHours) {
-        viewModelScope.launch { prefs.setTimelineHours(hours) }
-    }
-
     fun setDrawerViewOrder(order: List<CalendarView>) {
         viewModelScope.launch { prefs.setDrawerViewOrder(order) }
     }

app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/ViewsSettings.kt

@@ -21,12 +21,10 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
-import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.TimeFormatPref
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
 import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
@@ -34,15 +32,11 @@ import de.jeanlucmakiola.calendula.ui.common.AgendaRangePicker
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.PickerDescription
-import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
-import de.jeanlucmakiola.calendula.ui.common.TimelineHours
 import de.jeanlucmakiola.calendula.ui.common.TimelineScale
 import de.jeanlucmakiola.calendula.ui.common.agendaRangeLabel
 import de.jeanlucmakiola.calendula.ui.common.descriptionRes
-import de.jeanlucmakiola.calendula.ui.common.formatMinuteOfDay
 import de.jeanlucmakiola.calendula.ui.common.formatTimeOfDay
 import de.jeanlucmakiola.calendula.ui.common.icon
-import de.jeanlucmakiola.calendula.ui.common.label
 import de.jeanlucmakiola.calendula.ui.common.labelRes
 import de.jeanlucmakiola.calendula.ui.month.labelRes
 import de.jeanlucmakiola.floret.components.CollapsingScaffold
@@ -76,10 +70,6 @@ internal fun ViewsScreen(
     var showPastEvents by remember { mutableStateOf(false) }
     var showAgendaScreenRange by remember { mutableStateOf(false) }
     var showTimelineScale by remember { mutableStateOf(false) }
-    var showMultiDayCount by remember { mutableStateOf(false) }
-    var showHoursStart by remember { mutableStateOf(false) }
-    var showHoursEnd by remember { mutableStateOf(false) }
-    val hours = state.timelineHours
 
     CollapsingScaffold(
         title = stringResource(R.string.settings_section_views),
@@ -92,7 +82,7 @@ internal fun ViewsScreen(
         SectionHeader(stringResource(R.string.settings_views_all_header))
         GroupedRow(
             title = stringResource(R.string.settings_default_view),
-            summary = state.defaultView.label(),
+            summary = stringResource(state.defaultView.labelRes),
             position = Position.Top,
             onClick = { showDefaultView = true },
         )
@@ -168,57 +158,12 @@ internal fun ViewsScreen(
 
         Spacer(Modifier.height(8.dp))
         SectionHeader(stringResource(R.string.settings_week_day_header))
-        GroupedRow(
-            title = stringResource(R.string.settings_multi_day_count),
-            summary = multiDayLabel(state.multiDayCount),
-            position = Position.Top,
-            onClick = { showMultiDayCount = true },
-        )
         GroupedRow(
             title = stringResource(R.string.settings_timeline_scale),
-            summary = if (hours.enabled) {
-                stringResource(R.string.settings_timeline_scale_by_visible_hours)
-            } else {
-                stringResource(state.timelineScale.labelRes)
-            },
-            position = Position.Middle,
-            dimmed = hours.enabled,
-            onClick = if (hours.enabled) null else ({ showTimelineScale = true }),
+            summary = stringResource(state.timelineScale.labelRes),
+            position = Position.Top,
+            onClick = { showTimelineScale = true },
         )
-        GroupedRow(
-            title = stringResource(R.string.settings_visible_hours),
-            summary = if (hours.enabled) {
-                stringResource(
-                    R.string.settings_visible_hours_on_summary,
-                    hourLabel(hours.startHour),
-                    hourLabel(hours.endHour),
-                )
-            } else {
-                stringResource(R.string.settings_visible_hours_summary)
-            },
-            position = Position.Middle,
-            trailing = {
-                Switch(
-                    checked = hours.enabled,
-                    onCheckedChange = { viewModel.setTimelineHours(hours.copy(enabled = it)) },
-                )
-            },
-            onClick = { viewModel.setTimelineHours(hours.copy(enabled = !hours.enabled)) },
-        )
-        if (hours.enabled) {
-            GroupedRow(
-                title = stringResource(R.string.settings_visible_hours_start),
-                summary = hourLabel(hours.startHour),
-                position = Position.Middle,
-                onClick = { showHoursStart = true },
-            )
-            GroupedRow(
-                title = stringResource(R.string.settings_visible_hours_end),
-                summary = hourLabel(hours.endHour),
-                position = Position.Middle,
-                onClick = { showHoursEnd = true },
-            )
-        }
         GroupedRow(
             title = stringResource(R.string.settings_hour_lines),
             summary = stringResource(R.string.settings_hour_lines_summary),
@@ -330,7 +275,7 @@ internal fun ViewsScreen(
             predictiveBack = true,
             options = IMPLEMENTED_VIEWS,
             selected = state.defaultView,
-            label = { it.label() },
+            label = { stringResource(it.labelRes) },
             leading = {
                 Icon(
                     imageVector = it.icon,
@@ -392,18 +337,6 @@ internal fun ViewsScreen(
             onDismiss = { showPastEvents = false },
         )
     }
-    if (showMultiDayCount) {
-        OptionPicker(
-            title = stringResource(R.string.settings_multi_day_count),
-            header = { PickerDescription(stringResource(R.string.settings_multi_day_count_hint)) },
-            predictiveBack = true,
-            options = SettingsPrefs.MULTI_DAY_COUNTS.toList(),
-            selected = state.multiDayCount,
-            label = { multiDayLabel(it) },
-            onSelect = viewModel::setMultiDayCount,
-            onDismiss = { showMultiDayCount = false },
-        )
-    }
     if (showTimelineScale) {
         OptionPicker(
             title = stringResource(R.string.settings_timeline_scale),
@@ -423,30 +356,6 @@ internal fun ViewsScreen(
             onDismiss = { showTimelineScale = false },
         )
     }
-    if (showHoursStart) {
-        OptionPicker(
-            title = stringResource(R.string.settings_visible_hours_start),
-            header = { PickerDescription(stringResource(R.string.settings_visible_hours_start_hint)) },
-            predictiveBack = true,
-            options = TimelineHours.startOptions(hours.endHour),
-            selected = hours.startHour,
-            label = { hourLabel(it) },
-            onSelect = { viewModel.setTimelineHours(hours.copy(startHour = it)) },
-            onDismiss = { showHoursStart = false },
-        )
-    }
-    if (showHoursEnd) {
-        OptionPicker(
-            title = stringResource(R.string.settings_visible_hours_end),
-            header = { PickerDescription(stringResource(R.string.settings_visible_hours_end_hint)) },
-            predictiveBack = true,
-            options = TimelineHours.endOptions(hours.startHour),
-            selected = hours.endHour,
-            label = { hourLabel(it) },
-            onSelect = { viewModel.setTimelineHours(hours.copy(endHour = it)) },
-            onDismiss = { showHoursEnd = false },
-        )
-    }
     if (showAgendaScreenRange) {
         AgendaRangePicker(
             title = stringResource(R.string.settings_agenda_range),
@@ -475,7 +384,7 @@ private fun ViewRow(
     trailing: @Composable (() -> Unit)? = null,
 ) {
     GroupedRow(
-        title = view.label(),
+        title = stringResource(view.labelRes),
         position = position,
         dimmed = dimmed,
         minHeight = ReorderableRowHeight,
@@ -540,12 +449,3 @@ internal fun pastEventDisplayLabelRes(mode: PastEventDisplay): Int = when (mode)
     PastEventDisplay.DIM -> R.string.settings_past_events_dim
     PastEventDisplay.HIDE -> R.string.settings_past_events_hide
 }
-
-@Composable
-private fun multiDayLabel(count: Int): String =
-    pluralStringResource(R.plurals.view_multi_day, count, count)
-
-/** A whole hour in the app's clock convention; 24 reads as the end of the day. */
-@Composable
-private fun hourLabel(hour: Int): String =
-    formatMinuteOfDay(hour * 60, LocalUse24HourFormat.current, currentLocale())

app/src/main/java/de/jeanlucmakiola/calendula/ui/theme/Type.kt

@@ -1,24 +1,10 @@
 package de.jeanlucmakiola.calendula.ui.theme
 
 import androidx.compose.material3.Typography
-import androidx.compose.ui.unit.sp
 
 /**
- * Tracking the two label roles the calendar grids are set in. Material gives
- * both 0.5sp, tuned for isolated UI labels with room around them; a month chip
- * is a text box some 37dp wide, where 0.5sp on an 11sp glyph spends most of a
- * character on spacing alone. 0.1sp is what Material itself sets labelLarge to,
- * so the label family stays coherent (#190).
+ * Default Material 3 Expressive typography. Custom font + tuned scale will
+ * land in a later UI-design iteration; the defaults are intentional for V1
+ * scaffolding to keep the foundation lean.
  */
-private val LabelTracking = 0.1.sp
-
-/**
- * Material 3 Expressive typography with the label roles' tracking tightened.
- * Everything else is the default scale.
- */
-val CalendulaTypography: Typography = Typography().let { base ->
-    base.copy(
-        labelMedium = base.labelMedium.copy(letterSpacing = LabelTracking),
-        labelSmall = base.labelSmall.copy(letterSpacing = LabelTracking),
-    )
-}
+val CalendulaTypography = Typography()

app/src/main/java/de/jeanlucmakiola/calendula/ui/week/WeekPaging.kt

@@ -1,75 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.week
-
-import kotlinx.datetime.DateTimeUnit
-import kotlinx.datetime.DayOfWeek
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.daysUntil
-import kotlinx.datetime.plus
-
-/** Pages the week pager spans — a little under four centuries, centred on [PAGE_EPOCH]. */
-internal const val WEEK_PAGE_COUNT: Int = 20_000
-
-private const val EPOCH_PAGE = WEEK_PAGE_COUNT / 2
-
-/** The week at [EPOCH_PAGE]; any date works, it only has to stay fixed. */
-private val PAGE_EPOCH = LocalDate(2000, 1, 3)
-
-/** First day of the week shown on pager [page], with weeks starting on [firstDay]. */
-internal fun weekStartForPage(page: Int, firstDay: DayOfWeek): LocalDate =
-    PAGE_EPOCH.startOfWeek(firstDay).plus((page - EPOCH_PAGE) * 7, DateTimeUnit.DAY)
-
-/** The pager page whose week contains [date], with weeks starting on [firstDay]. */
-internal fun weekPageFor(date: LocalDate, firstDay: DayOfWeek): Int {
-    val days = PAGE_EPOCH.startOfWeek(firstDay).daysUntil(date.startOfWeek(firstDay))
-    return (EPOCH_PAGE + days / 7).coerceIn(0, WEEK_PAGE_COUNT - 1)
-}
-
-/** How a timeline pager cuts the calendar into pages of [dayCount] days. */
-sealed interface PageGrid {
-    val dayCount: Int
-    val pageCount: Int
-
-    /** First day shown on pager [page]. */
-    fun startForPage(page: Int): LocalDate
-
-    /** The pager page showing [date]. */
-    fun pageFor(date: LocalDate): Int
-}
-
-/** Whole weeks, starting on [firstDay]. */
-data class WeekGrid(val firstDay: DayOfWeek) : PageGrid {
-    override val dayCount: Int get() = 7
-    override val pageCount: Int get() = WEEK_PAGE_COUNT
-    override fun startForPage(page: Int): LocalDate = weekStartForPage(page, firstDay)
-    override fun pageFor(date: LocalDate): Int = weekPageFor(date, firstDay)
-}
-
-/** Pages the multi-day pager spans — over three centuries at the widest page. */
-internal const val DAYS_PAGE_COUNT: Int = 40_000
-
-private const val DAYS_EPOCH_PAGE = DAYS_PAGE_COUNT / 2
-
-/** A fixed day the multi-day pages are counted from. */
-private val DAYS_EPOCH = LocalDate(2000, 1, 1)
-
-/**
- * Runs of [dayCount] days (#193), offset [phase] days from a fixed epoch so any
- * date can start a page. The phase stays put while paging and only changes when
- * a jump moves another date to the first column.
- */
-data class DaysGrid(override val dayCount: Int, val phase: Int) : PageGrid {
-    override val pageCount: Int get() = DAYS_PAGE_COUNT
-
-    override fun startForPage(page: Int): LocalDate =
-        DAYS_EPOCH.plus(phase + (page - DAYS_EPOCH_PAGE) * dayCount, DateTimeUnit.DAY)
-
-    override fun pageFor(date: LocalDate): Int =
-        (DAYS_EPOCH_PAGE + Math.floorDiv(DAYS_EPOCH.daysUntil(date) - phase, dayCount))
-            .coerceIn(0, DAYS_PAGE_COUNT - 1)
-
-    companion object {
-        /** The grid of [dayCount]-day pages on which [date] is a page's first day. */
-        fun startingAt(date: LocalDate, dayCount: Int): DaysGrid =
-            DaysGrid(dayCount, Math.floorMod(DAYS_EPOCH.daysUntil(date), dayCount))
-    }
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/week/WeekViewModel.kt

@@ -12,17 +12,14 @@ import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.domain.calendarListFailure
 import de.jeanlucmakiola.calendula.domain.isDeclined
-import de.jeanlucmakiola.calendula.ui.common.PageStateCache
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.filterNot
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
@@ -33,7 +30,6 @@ import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.atStartOfDayIn
 import kotlinx.datetime.atTime
-import kotlinx.datetime.daysUntil
 import kotlinx.datetime.minus
 import kotlinx.datetime.plus
 import kotlinx.datetime.toInstant
@@ -42,38 +38,19 @@ import java.util.Locale
 import kotlin.time.Clock
 import kotlin.time.Instant
 import javax.inject.Inject
-import kotlin.math.abs
 
 const val MINUTES_PER_DAY: Int = 24 * 60
 
-/** How far from the requested page [PagedTimelineViewModel.span] keeps other pages cached. */
-private const val SPAN_CACHE_DAYS = 28
-
-/** A run of [count] days from [start]: what one timeline page shows. */
-data class DaySpan(val start: LocalDate, val count: Int)
-
-/** How the pager cuts the calendar, and the page the anchor sits on. */
-data class PagerPosition(val grid: PageGrid, val page: Int)
-
-/**
- * A timeline paged in runs of days: the week view, and the multi-day view (#193).
- * The pager leads; the anchor follows it once it settles, and the grid it is
- * cut by is derived from the anchor through [gridRule], so a subclass decides
- * whether a jump re-frames the pages or only moves between them.
- *
- * @param gridRule the grid to use for a given anchor, as the settings behind it change.
- * @param initialRule the rule used until [gridRule] first emits.
- */
 @OptIn(ExperimentalCoroutinesApi::class)
-abstract class PagedTimelineViewModel(
+@HiltViewModel
+class WeekViewModel @Inject constructor(
     private val repository: CalendarRepository,
     settingsPrefs: SettingsPrefs,
-    private val io: CoroutineDispatcher,
-    gridRule: Flow<(LocalDate) -> PageGrid>,
-    initialRule: (LocalDate) -> PageGrid,
+    @IoDispatcher private val io: CoroutineDispatcher,
 ) : ViewModel() {
 
     private val zone = TimeZone.currentSystemDefault()
+    private val locale: Locale = Locale.getDefault()
 
     /** Whether to fade events that have already finished (display concern only). */
     val dimCompletedEvents: StateFlow<Boolean> = settingsPrefs.dimCompletedEvents
@@ -86,82 +63,76 @@ abstract class PagedTimelineViewModel(
     private val todayDate: LocalDate
         get() = Clock.System.now().toLocalDateTime(zone).date
 
-    // A day on the visible page; the page itself comes from the grid, so a
-    // settings change re-frames the same days instead of jumping.
+    /** First day of the week, from the Settings preference (AUTO → locale). */
+    private val weekStart: StateFlow<DayOfWeek> = settingsPrefs.weekStart
+        .map { it.resolveFirstDay(locale) }
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = DayOfWeek.MONDAY,
+        )
+
+    // Anchor is a representative day inside the visible week; the actual week
+    // start is derived against [weekStart], so changing the first-day preference
+    // re-frames the same week instead of jumping.
     private val _anchor = MutableStateFlow(todayDate)
 
-    val position: StateFlow<PagerPosition> =
-        combine(_anchor, gridRule) { anchor, rule -> rule(anchor).let { PagerPosition(it, it.pageFor(anchor)) } }
-            .distinctUntilChanged()
+    val weekStartDate: StateFlow<LocalDate> =
+        combine(_anchor, weekStart) { anchor, ws -> anchor.startOfWeek(ws) }
             .stateIn(
                 scope = viewModelScope,
                 started = SharingStarted.WhileSubscribed(5_000L),
-                initialValue = initialRule(todayDate).let { PagerPosition(it, it.pageFor(todayDate)) },
+                initialValue = todayDate.startOfWeek(DayOfWeek.MONDAY),
             )
 
-    /**
-     * The anchor page's state. Once loaded it never falls back to [WeekUiState.Loading]:
-     * moving the anchor keeps the last result until the new page arrives, since
-     * the pages draw their own days and this only gates the failure screen.
-     */
     val state: StateFlow<WeekUiState> =
-        position.map { DaySpan(it.grid.startForPage(it.page), it.grid.dayCount) }
+        combine(_anchor, weekStart) { anchor, ws -> anchor.startOfWeek(ws) }
             .distinctUntilChanged()
-            .flatMapLatest { span -> span(span).filterNot { it is WeekUiState.Loading } }
+            .flatMapLatest { start ->
+                val range = weekRange(start, zone)
+                combine(
+                    repository.calendars(),
+                    repository.instances(range),
+                ) { calendars, instances ->
+                    buildState(start, calendars, instances)
+                }
+            }
             .catch { emit(WeekUiState.Failure(FailureReason.ProviderUnavailable)) }
+            .flowOn(io)
             .stateIn(
                 scope = viewModelScope,
                 started = SharingStarted.WhileSubscribed(5_000L),
                 initialValue = WeekUiState.Loading,
             )
 
-    private val spans = PageStateCache<DaySpan, WeekUiState>(
-        scope = viewModelScope,
-        initial = WeekUiState.Loading,
-        // Far enough to cover the pages either side and a swipe back, so paging
-        // through a year doesn't keep a year of queries around.
-        keep = { cached, requested ->
-            cached.count == requested.count &&
-                abs(cached.start.daysUntil(requested.start)) <= SPAN_CACHE_DAYS
-        },
-    ) { span ->
-        combine(
-            repository.calendars(),
-            repository.instances(spanRange(span.start, span.count, zone)),
-        ) { calendars, instances ->
-            buildState(span, calendars, instances)
-        }
-            .catch { emit(WeekUiState.Failure(FailureReason.ProviderUnavailable)) }
-            .flowOn(io)
+    fun goToPrev() {
+        _anchor.value = _anchor.value.minus(7, DateTimeUnit.DAY)
     }
 
-    /** The days of one page, shared between that page and [state]. Main thread only. */
-    fun span(span: DaySpan): StateFlow<WeekUiState> = spans.get(span)
-
-    /** The pager came to rest on [page]; follow it unless it is already the anchor's. */
-    fun onPageSettled(page: Int) {
-        val grid = position.value.grid
-        if (grid.pageFor(_anchor.value) != page) _anchor.value = grid.startForPage(page)
+    fun goToNext() {
+        _anchor.value = _anchor.value.plus(7, DateTimeUnit.DAY)
     }
 
-    /** Move the anchor to [date], re-framing the pages if the grid depends on it. */
-    fun jumpTo(date: LocalDate) {
+    fun goToToday() {
+        _anchor.value = todayDate
+    }
+
+    /** Jump to the week containing [date] (drawer jump-to-date). */
+    fun goToDate(date: LocalDate) {
         _anchor.value = date
     }
 
-    fun goToToday() = jumpTo(todayDate)
-
     private fun buildState(
-        span: DaySpan,
+        start: LocalDate,
         calendars: List<CalendarSource>,
         instances: List<EventInstance>,
     ): WeekUiState {
         calendarListFailure(calendars)?.let { return WeekUiState.Failure(it) }
-        val days = (0 until span.count).map { span.start.plus(it, DateTimeUnit.DAY) }
+        val days = (0 until 7).map { start.plus(it, DateTimeUnit.DAY) }
         val allDay = instances.filter { it.isAllDay }
         val timed = instances.filterNot { it.isAllDay }
         return WeekUiState.Success(
-            weekStart = span.start,
+            weekStart = start,
             today = todayDate,
             days = days,
             allDaySpans = layoutAllDay(allDay, days, zone),
@@ -170,44 +141,6 @@ abstract class PagedTimelineViewModel(
     }
 }
 
-/** Whole weeks, starting on the first day from Settings (AUTO → locale). */
-@HiltViewModel
-class WeekViewModel @Inject constructor(
-    repository: CalendarRepository,
-    settingsPrefs: SettingsPrefs,
-    @IoDispatcher io: CoroutineDispatcher,
-) : PagedTimelineViewModel(
-    repository = repository,
-    settingsPrefs = settingsPrefs,
-    io = io,
-    gridRule = settingsPrefs.weekStart.map { pref ->
-        val grid = WeekGrid(pref.resolveFirstDay(Locale.getDefault()))
-        val rule: (LocalDate) -> PageGrid = { grid }
-        rule
-    },
-    initialRule = { WeekGrid(DayOfWeek.MONDAY) },
-)
-
-/**
- * The multi-day view (#193): runs of the day count from Settings, with the
- * anchor always a page's first day, so today — or a date jumped to — opens in
- * the first column.
- */
-@HiltViewModel
-class MultiDayViewModel @Inject constructor(
-    repository: CalendarRepository,
-    settingsPrefs: SettingsPrefs,
-    @IoDispatcher io: CoroutineDispatcher,
-) : PagedTimelineViewModel(
-    repository = repository,
-    settingsPrefs = settingsPrefs,
-    io = io,
-    gridRule = settingsPrefs.multiDayCount.map { count ->
-        { anchor: LocalDate -> DaysGrid.startingAt(anchor, count) }
-    },
-    initialRule = { DaysGrid.startingAt(it, SettingsPrefs.DEFAULT_MULTI_DAY_COUNT) },
-)
-
 /**
  * Lay out all-day events as connected horizontal spans across the visible week.
  * Each event becomes one [AllDaySpan] from its first to its last covered column;
@@ -234,7 +167,7 @@ internal fun layoutAllDay(
     // in non-decreasing start order, which the declined-last rule above breaks:
     // a Monday bar seated after a Wednesday one would be refused a lane it is
     // nowhere near, and each wasted lane costs the all-day strip a whole row and
-    // pushes a bar closer to the month grid's lane cap. Seven columns
+    // pushes a bar closer to the month grid's MAX_EVENT_ROWS cap. Seven columns
     // and a handful of bars, so the scan is cheaper than the sort above it.
     val laneCols = ArrayList<MutableList<IntRange>>()
     return raw.map { r ->
@@ -261,10 +194,10 @@ internal fun LocalDate.startOfWeek(weekStart: DayOfWeek): LocalDate {
     return minus(offset, DateTimeUnit.DAY)
 }
 
-/** Instant range covering the [count] days starting at [start]. */
-internal fun spanRange(start: LocalDate, count: Int, zone: TimeZone): ClosedRange<Instant> {
+/** Half-open instant range covering the seven days starting at [start]. */
+internal fun weekRange(start: LocalDate, zone: TimeZone): ClosedRange<Instant> {
     val from = start.atStartOfDayIn(zone)
-    val to = start.plus(count - 1, DateTimeUnit.DAY).atTime(23, 59, 59).toInstant(zone)
+    val to = start.plus(6, DateTimeUnit.DAY).atTime(23, 59, 59).toInstant(zone)
     return from..to
 }
 

app/src/main/java/de/jeanlucmakiola/calendula/ui/week/WeekViewPreview.kt

@@ -32,13 +32,10 @@ internal fun WeekViewPreview(
     weekStart: DayOfWeek,
     height: Dp,
     modifier: Modifier = Modifier,
-    dayCount: Int = 7,
 ) {
     val zone = remember { TimeZone.currentSystemDefault() }
     val today = remember(zone) { Clock.System.now().toLocalDateTime(zone).date }
-    val state = remember(today, weekStart, dayCount, zone) {
-        sampleWeekState(today, weekStart, dayCount, zone)
-    }
+    val state = remember(today, weekStart, zone) { sampleWeekState(today, weekStart, zone) }
     val scrollState = rememberScrollState()
     LaunchedEffect(Unit) {
         snapshotFlow { scrollState.maxValue }.first { it > 0 }
@@ -49,7 +46,6 @@ internal fun WeekViewPreview(
     ScaledViewPreview(height = height, modifier = modifier) {
         WeekSuccess(
             state = state,
-            showWeekNumber = dayCount == 7,
             scrollState = scrollState,
             allDayHeight = state.allDayStripHeight(),
             dragController = rememberTimelineDragController(),
@@ -65,11 +61,10 @@ internal fun WeekViewPreview(
 private fun sampleWeekState(
     today: LocalDate,
     weekStart: DayOfWeek,
-    dayCount: Int,
     zone: TimeZone,
 ): WeekUiState.Success {
-    val start = if (dayCount == 7) today.startOfWeek(weekStart) else today
-    val days = (0 until dayCount).map { start.plus(it, DateTimeUnit.DAY) }
+    val start = today.startOfWeek(weekStart)
+    val days = (0 until 7).map { start.plus(it, DateTimeUnit.DAY) }
     val events = sampleTimelineEvents(days, today, zone)
     return WeekUiState.Success(
         weekStart = start,

app/src/main/res/values/strings.xml

@@ -1,30 +1,22 @@
 <resources>
     <string name="app_name">Calendula</string>
     <string name="app_tagline">A modern calendar.</string>
-    <!-- Alternative launcher label offered by the "App name" setting (issue #44),
-         shown under the app icon. Translate it as the plain, generic word your
-         language uses for a calendar app (e.g. "Kalender"), nothing else (#251). -->
-    <string name="app_name_calendar_alias">Calendar</string>
+    <!-- Alternative launcher label offered by the "App name" setting (issue #44).
+         translatable="false": this string becomes a launcher component's label, so
+         it must never be changed by an unreviewed community translation. -->
+    <string name="app_name_calendar_alias" translatable="false">Calendar</string>
 
     <!-- Loading / Failure / Success generic strings (used across screens) -->
     <string name="state_loading">Loading…</string>
     <string name="state_retry">Retry</string>
     <string name="state_failure_unknown">Something went wrong.</string>
     <string name="state_failure_permission">Calendar access is required.</string>
-    <string name="state_failure_permission_body">Calendula reads your events straight from the system calendar, so it needs calendar access to show anything.</string>
     <string name="state_failure_permission_action">Grant access</string>
     <string name="state_failure_no_calendars">No calendars configured.</string>
-    <string name="state_failure_no_calendars_body">Add a calendar account to this device and its calendars show up here.</string>
     <string name="state_failure_no_calendars_action">Open system calendar settings</string>
     <string name="state_failure_all_hidden">All your calendars are switched off.</string>
-    <string name="state_failure_all_hidden_body">Switch at least one calendar back on to see its events.</string>
     <string name="state_failure_all_hidden_action">Manage calendars</string>
-    <string name="state_failure_no_import_target">No calendar can take new events.</string>
-    <string name="state_failure_no_import_target_body">The calendars that are switched on are read-only, managed by another app, or not synced to this device. Switch on a calendar that can take events, or add a local one.</string>
-    <string name="state_failure_event_not_found">This event is no longer there.</string>
-    <string name="state_failure_event_not_found_body">It may have been deleted, or moved to a calendar that is switched off.</string>
     <string name="state_failure_provider">Could not read the calendar.</string>
-    <string name="state_failure_provider_body">The system calendar did not answer. Try again in a moment.</string>
 
     <!-- Long-press a field to copy it (#195) -->
     <string name="field_copy_action">Copy</string>
@@ -55,7 +47,6 @@
     <string name="month_prev">Previous month</string>
     <string name="month_next">Next month</string>
     <string name="month_today_action">Today</string>
-    <string name="month_split_clear_filter">Show full month agenda</string>
     <string name="month_more_actions">More actions</string>
     <string name="month_open_menu">Open menu</string>
     <string name="month_action_settings">Settings</string>
@@ -68,10 +59,6 @@
     <!-- Day view (S3) -->
     <string name="day_today_action">Today</string>
 
-    <!-- Week and day timelines — edge bar for events scrolled out of view (#188) -->
-    <string name="timeline_earlier_events">Earlier events</string>
-    <string name="timeline_later_events">Later events</string>
-
     <!-- Event detail screen (S4) -->
     <string name="event_detail_back">Back</string>
     <string name="event_detail_edit">Edit</string>
@@ -295,9 +282,6 @@
     <!-- Shared event strings -->
     <string name="event_untitled">(No title)</string>
 
-    <!-- Stands in for a calendar the provider gave no name (#329) -->
-    <string name="calendar_unnamed">(No name)</string>
-
     <!-- First-launch wizard (#163) -->
     <string name="onboarding_step_counter">Step %1$d of %2$d</string>
     <string name="onboarding_backup_title">Your events live only here</string>
@@ -306,26 +290,6 @@
     <string name="onboarding_backup_benefit_folder_body">Backups are plain .ics files — put them somewhere that syncs, or on an SD card.</string>
     <string name="onboarding_backup_benefit_daily_title">Once a day, by itself</string>
     <string name="onboarding_backup_benefit_daily_body">Calendula exports your local calendars in the background. Change how often in Settings.</string>
-    <string name="onboarding_calendars_title">Somewhere to put your events</string>
-    <string name="onboarding_calendars_body">This device has no calendar yet. Calendula writes to the calendars already on your phone — it needs at least one.</string>
-    <string name="onboarding_calendars_local_button">Create a calendar on this device</string>
-    <string name="onboarding_calendars_caldav_button">Sync with a CalDAV server</string>
-    <string name="onboarding_calendars_skip_button">Not now</string>
-    <string name="onboarding_calendars_benefit_local_title">Stays on this phone</string>
-    <string name="onboarding_calendars_benefit_local_body">A device calendar syncs nowhere, so back it up if the events matter.</string>
-    <string name="onboarding_calendars_benefit_sync_title">Or sync from an account</string>
-    <string name="onboarding_calendars_benefit_sync_body">Calendula shows what your accounts already sync. CalDAV servers need DAVx\u2075 to do the syncing.</string>
-    <string name="onboarding_calendars_created_title">“%1$s” is ready</string>
-    <string name="onboarding_calendars_created_body">It lives on this device and new events go into it unless you pick another calendar.</string>
-    <string name="onboarding_calendars_created_more_title">Room for more</string>
-    <string name="onboarding_calendars_created_more_body">Settings → Calendars makes as many as you need, and renames or recolours the ones you have.</string>
-    <string name="onboarding_calendars_created_continue">Continue</string>
-    <string name="onboarding_hidden_title">Your calendars are switched off</string>
-    <string name="onboarding_hidden_body">Calendula shows the calendars this phone has switched on, and right now that is none of them. Switch on the ones you want to see — your other calendar apps show them again too.</string>
-    <string name="onboarding_hidden_switch_all_button">Switch them all on</string>
-    <string name="onboarding_hidden_skip_button">Not now</string>
-    <string name="onboarding_hidden_failed">Couldn\'t switch that on. Settings → Calendars has the same switches.</string>
-    <string name="onboarding_calendars_create_failed">Couldn\'t create the calendar. Your phone\'s calendar storage refused it.</string>
     <string name="onboarding_backup_enable_button">Choose folder and back up</string>
     <string name="onboarding_backup_skip_button">Not now</string>
     <string name="onboarding_view_title">What should open first?</string>
@@ -354,18 +318,12 @@
     <string name="reminder_action_snooze">Snooze</string>
     <string name="reminder_action_dismiss">Dismiss</string>
     <!-- Day context prefix in a reminder for an event on another day (v2.15.0) -->
-    <string name="reminder_day_today">Today</string>
     <string name="reminder_day_tomorrow">Tomorrow</string>
     <string name="reminder_day_yesterday">Yesterday</string>
 
     <!-- View switcher (M1) -->
     <string name="view_month">Month</string>
     <string name="view_week">Week</string>
-    <!-- The multi-day view, named after how many days it shows (#193) -->
-    <plurals name="view_multi_day">
-        <item quantity="one">%d day</item>
-        <item quantity="other">%d days</item>
-    </plurals>
     <string name="view_day">Day</string>
     <string name="view_agenda">Agenda</string>
     <string name="view_section">View</string>
@@ -481,10 +439,7 @@
          each hour") describes a feature that no longer exists and needs redoing. -->
     <string name="settings_hour_lines">Hour grid</string>
     <string name="settings_hour_lines_summary">Seat each hour in its own cell in week and day view</string>
-    <string name="settings_multi_day_count">Multi-day view</string>
-    <string name="settings_multi_day_count_hint">How many days the multi-day view shows side by side. Today opens in the first column.</string>
     <string name="settings_timeline_scale">Hour height</string>
-    <string name="settings_timeline_scale_by_visible_hours">Set by Visible hours</string>
     <string name="settings_timeline_scale_hint">How much vertical space one hour takes in week and day view. Both views share this setting. You can also pinch the timeline with two fingers to set any height in between.</string>
     <string name="timeline_scale_fit_day">Fit whole day</string>
     <string name="timeline_scale_fit_day_summary">All 24 hours on one screen, no scrolling</string>
@@ -496,13 +451,6 @@
     <string name="timeline_scale_comfortable_summary">Roomier blocks, more scrolling</string>
     <string name="timeline_scale_custom">Custom</string>
     <string name="timeline_scale_custom_summary">The height you pinched the timeline to</string>
-    <string name="settings_visible_hours">Visible hours</string>
-    <string name="settings_visible_hours_summary">Fit a range of hours to the screen when week, multi-day or day view opens</string>
-    <string name="settings_visible_hours_on_summary">%1$s – %2$s fills the screen when a view opens</string>
-    <string name="settings_visible_hours_start">From</string>
-    <string name="settings_visible_hours_end">Until</string>
-    <string name="settings_visible_hours_start_hint">The hour at the top of the screen when week, multi-day or day view opens. Earlier hours are still a scroll away.</string>
-    <string name="settings_visible_hours_end_hint">The hour at the bottom of the screen when a view opens. Later hours are still a scroll away, and pinching zooms until the view is opened again.</string>
     <string name="settings_dim_completed">Dim completed events</string>
     <string name="settings_dim_completed_summary">Fade events that have already ended in month and week view</string>
     <string name="settings_drag_to_reschedule">Drag to reschedule</string>
@@ -551,7 +499,7 @@
     <string name="settings_month_header">Month view</string>
     <string name="settings_month_view_style">Month view style</string>
     <string name="month_style_paged">Pages</string>
-    <string name="month_style_paged_summary">One month fills the screen. Swipe left or right to change month, or swipe up to show the month agenda.</string>
+    <string name="month_style_paged_summary">One month fills the screen. Swipe left or right to change month.</string>
     <string name="month_style_continuous">Scrolling months</string>
     <string name="month_style_continuous_summary">Each month sits under its own heading, with a little space setting it apart from the next.</string>
     <string name="month_style_dense">Seamless weeks</string>
@@ -717,20 +665,7 @@
     <string name="calendars_edit_title">Edit calendar</string>
     <string name="calendars_name_label">Name</string>
     <string name="calendars_color_label">Color</string>
-    <string name="calendars_description_label">Description</string>
     <string name="calendars_description_hint">Add a description</string>
-    <string name="color_name_mauve">Mauve</string>
-    <string name="color_name_red">Red</string>
-    <string name="color_name_orange">Orange</string>
-    <string name="color_name_amber">Amber</string>
-    <string name="color_name_olive">Olive</string>
-    <string name="color_name_green">Green</string>
-    <string name="color_name_teal">Teal</string>
-    <string name="color_name_cyan">Cyan</string>
-    <string name="color_name_blue">Blue</string>
-    <string name="color_name_indigo">Indigo</string>
-    <string name="color_name_purple">Purple</string>
-    <string name="color_name_pink">Pink</string>
     <string name="calendars_delete_confirm_title">Delete calendar?</string>
     <string name="calendars_delete_confirm_message">\"%1$s\" and all of its events will be permanently removed from this device.</string>
     <string name="calendars_write_error">Couldn\'t save the change.</string>
@@ -744,7 +679,6 @@
     <string name="calendars_restore_header">Restore</string>
     <string name="calendars_restore_action">Restore from .ics file</string>
     <string name="calendars_restore_hint">Import events from a backup or another calendar app.</string>
-    <string name="calendars_restore_unavailable">No calendar can take the imported events yet.</string>
     <string name="calendars_auto_backup">Automatic backup</string>
     <string name="calendars_auto_backup_hint">Periodically export your local calendars to a folder as an .ics file.</string>
     <string name="calendars_auto_backup_folder">Backup folder</string>

app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/CalendarMapperTest.kt

@@ -64,9 +64,9 @@ class CalendarMapperTest {
     }
 
     @Test
-    fun `null displayName is left blank for the UI to fill in`() {
+    fun `null displayName falls back to placeholder`() {
         val src = reader(displayName = null).toCalendarSource()
-        assertThat(src.displayName).isEmpty()
+        assertThat(src.displayName).isEqualTo(Fallbacks.UNNAMED_CALENDAR)
     }
 
     @Test

app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/InstanceMapperTest.kt

@@ -61,15 +61,15 @@ class InstanceMapperTest {
     }
 
     @Test
-    fun `null title is left blank for the UI to fill in`() {
+    fun `null title falls back to placeholder`() {
         val inst = reader(title = null).toEventInstance()
-        assertThat(inst!!.title).isEmpty()
+        assertThat(inst!!.title).isEqualTo(Fallbacks.UNTITLED_EVENT)
     }
 
     @Test
-    fun `empty title is left blank for the UI to fill in`() {
+    fun `empty title falls back to placeholder`() {
         val inst = reader(title = "").toEventInstance()
-        assertThat(inst!!.title).isEmpty()
+        assertThat(inst!!.title).isEqualTo(Fallbacks.UNTITLED_EVENT)
     }
 
     @Test

app/src/test/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefsTest.kt

@@ -14,7 +14,6 @@ import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
-import de.jeanlucmakiola.calendula.ui.common.TimelineHours
 import de.jeanlucmakiola.calendula.ui.common.TimelineScale
 import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
 import kotlinx.coroutines.flow.first
@@ -126,24 +125,6 @@ class SettingsPrefsTest {
         assertThat(prefs.timelineScale.first()).isEqualTo(TimelineScale.Comfortable)
     }
 
-    @Test
-    fun `visible hours default off and round-trip`(@TempDir tempDir: Path) = runTest {
-        val prefs = SettingsPrefs(newDataStore(tempDir))
-        assertThat(prefs.timelineHours.first()).isEqualTo(TimelineHours(enabled = false, 7, 22))
-        prefs.setTimelineHours(TimelineHours(enabled = true, 6, 20))
-        assertThat(prefs.timelineHours.first()).isEqualTo(TimelineHours(enabled = true, 6, 20))
-        // Switching off keeps the chosen hours for next time.
-        prefs.setTimelineHours(TimelineHours(enabled = false, 6, 20))
-        assertThat(prefs.timelineHours.first()).isEqualTo(TimelineHours(enabled = false, 6, 20))
-    }
-
-    @Test
-    fun `visible hours are stored valid`(@TempDir tempDir: Path) = runTest {
-        val prefs = SettingsPrefs(newDataStore(tempDir))
-        prefs.setTimelineHours(TimelineHours(enabled = true, 23, 22))
-        assertThat(prefs.timelineHours.first()).isEqualTo(TimelineHours(enabled = true, 20, 22))
-    }
-
     @Test
     fun `week numbers default off and round-trips`(@TempDir tempDir: Path) = runTest {
         val prefs = SettingsPrefs(newDataStore(tempDir))
@@ -254,8 +235,7 @@ class SettingsPrefsTest {
         prefs.setQuickSwitchConfig(config)
         val loaded = prefs.quickSwitchConfig.first()
         assertThat(loaded.order).containsExactly(
-            CalendarView.Agenda, CalendarView.Month, CalendarView.Week,
-            CalendarView.MultiDay, CalendarView.Day,
+            CalendarView.Agenda, CalendarView.Month, CalendarView.Week, CalendarView.Day,
         ).inOrder()
         assertThat(loaded.enabled).containsExactly(CalendarView.Agenda, CalendarView.Month)
         assertThat(loaded.cycle).containsExactly(CalendarView.Agenda, CalendarView.Month).inOrder()
@@ -272,14 +252,13 @@ class SettingsPrefsTest {
             m
         }
         val config = prefs.quickSwitchConfig.first()
-        // Stored order first, with the new view after Week.
+        // Stored order first (Day, Week), then the omitted views in default order.
         assertThat(config.order).containsExactly(
-            CalendarView.Day, CalendarView.Week, CalendarView.MultiDay,
-            CalendarView.Month, CalendarView.Agenda,
+            CalendarView.Day, CalendarView.Week, CalendarView.Month, CalendarView.Agenda,
         ).inOrder()
-        // Day was explicitly disabled; the missing views default enabled.
+        // Day was explicitly disabled; the appended Month & Agenda default enabled.
         assertThat(config.enabled).containsExactly(
-            CalendarView.Week, CalendarView.MultiDay, CalendarView.Month, CalendarView.Agenda,
+            CalendarView.Week, CalendarView.Month, CalendarView.Agenda,
         )
     }
 
@@ -293,12 +272,9 @@ class SettingsPrefsTest {
         val newOrder = listOf(CalendarView.Agenda, CalendarView.Month, CalendarView.Week, CalendarView.Day)
         prefs.updateQuickSwitch { it.copy(order = newOrder) }
         val config = prefs.quickSwitchConfig.first()
-        assertThat(config.order).containsExactly(
-            CalendarView.Agenda, CalendarView.Month, CalendarView.Week,
-            CalendarView.MultiDay, CalendarView.Day,
-        ).inOrder()
+        assertThat(config.order).containsExactlyElementsIn(newOrder).inOrder()
         assertThat(config.enabled).containsExactly(
-            CalendarView.Agenda, CalendarView.Month, CalendarView.Week, CalendarView.MultiDay,
+            CalendarView.Agenda, CalendarView.Month, CalendarView.Week,
         )
     }
 
@@ -310,8 +286,7 @@ class SettingsPrefsTest {
             listOf(CalendarView.Agenda, CalendarView.Day, CalendarView.Week, CalendarView.Month),
         )
         assertThat(prefs.drawerViewOrder.first()).containsExactly(
-            CalendarView.Agenda, CalendarView.Day, CalendarView.Week,
-            CalendarView.MultiDay, CalendarView.Month,
+            CalendarView.Agenda, CalendarView.Day, CalendarView.Week, CalendarView.Month,
         ).inOrder()
     }
 
@@ -325,8 +300,7 @@ class SettingsPrefsTest {
             m
         }
         assertThat(prefs.drawerViewOrder.first()).containsExactly(
-            CalendarView.Agenda, CalendarView.Week, CalendarView.MultiDay,
-            CalendarView.Month, CalendarView.Day,
+            CalendarView.Agenda, CalendarView.Week, CalendarView.Month, CalendarView.Day,
         ).inOrder()
     }
 

app/src/test/java/de/jeanlucmakiola/calendula/data/reminders/ReminderTimeTextTest.kt

@@ -38,7 +38,6 @@ class ReminderTimeTextTest {
         is24Hour = is24Hour,
         today = today ?: java.time.Instant.ofEpochMilli(beginMillis).atZone(zone).toLocalDate(),
         firstDayOfWeek = firstDayOfWeek,
-        todayLabel = "Today",
         tomorrowLabel = "Tomorrow",
         yesterdayLabel = "Yesterday",
     )
@@ -131,74 +130,38 @@ class ReminderTimeTextTest {
     }
 
     @Test
-    fun `all-day single day today reads as today, read in UTC`() {
+    fun `all-day single day shows one date, read in UTC`() {
         val text = text(
             beginMillis = utcMidnight(LocalDate.of(2026, 6, 11)),
             endMillis = utcMidnight(LocalDate.of(2026, 6, 12)),
             isAllDay = true,
             // Zone must not matter for all-day events: UTC midnight is
-            // the previous evening in Los Angeles — naive local reading would shift the day.
-            zone = ZoneId.of("America/Los_Angeles"),
+            // 02:00 in Berlin — naive local reading would shift the day.
             today = LocalDate.of(2026, 6, 11),
         )
-        assertThat(text).isEqualTo("Today")
+        assertThat(text).isEqualTo("11.06.2026")
     }
 
     @Test
-    fun `all-day event tomorrow reads as tomorrow`() {
+    fun `all-day event tomorrow still shows the exact date, no relative prefix`() {
         val text = text(
             beginMillis = utcMidnight(LocalDate.of(2026, 6, 12)),
             endMillis = utcMidnight(LocalDate.of(2026, 6, 13)),
             isAllDay = true,
             today = LocalDate.of(2026, 6, 11),
         )
-        assertThat(text).isEqualTo("Tomorrow")
+        assertThat(text).isEqualTo("12.06.2026")
     }
 
     @Test
-    fun `all-day event later this week reads as the short weekday`() {
-        // 2026-06-11 is a Thursday; Saturday the 13th shares its week.
+    fun `all-day multi-day shows the last covered day, not the exclusive end`() {
         val text = text(
-            beginMillis = utcMidnight(LocalDate.of(2026, 6, 13)),
-            endMillis = utcMidnight(LocalDate.of(2026, 6, 14)),
-            isAllDay = true,
-            locale = Locale.US,
-            today = LocalDate.of(2026, 6, 11),
-        )
-        assertThat(text).isEqualTo("Sat")
-    }
-
-    @Test
-    fun `all-day event next week falls back to the exact date`() {
-        val text = text(
-            beginMillis = utcMidnight(LocalDate.of(2026, 6, 16)),
-            endMillis = utcMidnight(LocalDate.of(2026, 6, 17)),
+            beginMillis = utcMidnight(LocalDate.of(2026, 6, 11)),
+            endMillis = utcMidnight(LocalDate.of(2026, 6, 13)),
             isAllDay = true,
             today = LocalDate.of(2026, 6, 11),
         )
-        assertThat(text).isEqualTo("16.06.2026")
-    }
-
-    @Test
-    fun `all-day multi-day reads relative start and the last covered day`() {
-        val text = text(
-            beginMillis = utcMidnight(LocalDate.of(2026, 6, 12)),
-            endMillis = utcMidnight(LocalDate.of(2026, 6, 14)),
-            isAllDay = true,
-            today = LocalDate.of(2026, 6, 11),
-        )
-        assertThat(text).isEqualTo("Tomorrow – 13.06.2026")
-    }
-
-    @Test
-    fun `all-day multi-day further out keeps both dates`() {
-        val text = text(
-            beginMillis = utcMidnight(LocalDate.of(2026, 7, 1)),
-            endMillis = utcMidnight(LocalDate.of(2026, 7, 3)),
-            isAllDay = true,
-            today = LocalDate.of(2026, 6, 11),
-        )
-        assertThat(text).isEqualTo("01.07.2026 – 02.07.2026")
+        assertThat(text).isEqualTo("11.06.2026 – 12.06.2026")
     }
 
     @Test
@@ -210,6 +173,6 @@ class ReminderTimeTextTest {
             isAllDay = true,
             today = LocalDate.of(2026, 6, 11),
         )
-        assertThat(text).isEqualTo("Today")
+        assertThat(text).isEqualTo("11.06.2026")
     }
 }

app/src/test/java/de/jeanlucmakiola/calendula/domain/EventSearchTest.kt

@@ -242,8 +242,8 @@ class EventSearchTest {
     }
 
     @Test
-    fun `an untitled event's blank title is not something the query can match`() {
-        val untitled = candidate("", description = "Titel folgt noch").copy(title = null)
+    fun `an untitled event's placeholder is not something the query can match`() {
+        val untitled = candidate("(Ohne Titel)", description = "Titel folgt noch").copy(title = null)
 
         val results = search(untitled, query = "titel")
 

app/src/test/java/de/jeanlucmakiola/calendula/domain/ModelsTest.kt

@@ -36,13 +36,12 @@ class ModelsTest {
     }
 
     @Test
-    fun `FailureReason enum has all seven variants`() {
+    fun `FailureReason enum has all six variants`() {
         assertThat(FailureReason.values().toSet()).isEqualTo(
             setOf(
                 FailureReason.PermissionRevoked,
                 FailureReason.NoCalendarsConfigured,
                 FailureReason.AllCalendarsHidden,
-                FailureReason.NoImportTarget,
                 FailureReason.ProviderUnavailable,
                 FailureReason.EventNotFound,
                 FailureReason.Unknown,

app/src/test/java/de/jeanlucmakiola/calendula/domain/color/EventToneTest.kt

@@ -156,5 +156,4 @@ class EventToneTest {
         assertThat(eventTone(0xFFFFF6C0.toInt(), dark = false, harmonise = false).onContainer)
             .isEqualTo(0xFF000000.toInt())
     }
-
 }

app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsGoogleImportTest.kt

@@ -1,116 +0,0 @@
-package de.jeanlucmakiola.calendula.domain.ics
-
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.domain.Availability
-import kotlinx.datetime.TimeZone
-import org.junit.jupiter.api.Test
-
-/**
- * Reading a Google Calendar export (Codeberg #304), whose dialect the parser had
- * never been held to: `VTIMEZONE` blocks with `X-LIC-LOCATION`, `TZID`-qualified
- * `DTSTART`/`EXDATE`, folded `DESCRIPTION` and `ATTENDEE` lines, `RECURRENCE-ID`
- * overrides written as separate `VEVENT`s, and `@google.com` UIDs.
- *
- * The fixture is a trimmed copy of what "Settings → Import & export → Export"
- * produces, CRLF and all. Note that Google hands that export out as a **zip**
- * containing one `.ics` per calendar — the file here is one member of it.
- */
-class IcsGoogleImportTest {
-
-    private val parser = IcsParser(TimeZone.of("Europe/Berlin"))
-
-    private val result: IcsParseResult = parser.parse(
-        checkNotNull(
-            javaClass.classLoader?.getResourceAsStream("ics/google-calendar-export.ics"),
-        ).use { it.readBytes().toString(Charsets.UTF_8) },
-    )
-
-    private fun event(summary: String) = result.events.single { it.summary == summary }
-
-    @Test
-    fun `every master event imports and the VTIMEZONE block is not mistaken for one`() {
-        assertThat(result.events.map { it.summary })
-            .containsExactly("Team standup", "Day off", "Christmas break")
-    }
-
-    @Test
-    fun `X-WR-CALNAME names the calendar for all of them`() {
-        assertThat(result.events.map { it.calendarName }.distinct())
-            .containsExactly("jane@example.com")
-    }
-
-    @Test
-    fun `a TZID-qualified start resolves against the device tz database`() {
-        val standup = event("Team standup")
-        assertThat(standup.isAllDay).isFalse()
-        assertThat(standup.zoneId).isEqualTo("Europe/Berlin")
-        // 10:00 CEST is 08:00 UTC.
-        assertThat(standup.start.toString()).isEqualTo("2026-09-15T08:00:00Z")
-        assertThat((standup.end - standup.start).inWholeMinutes).isEqualTo(90)
-    }
-
-    @Test
-    fun `the recurrence rule and its TZID-qualified EXDATE survive`() {
-        val standup = event("Team standup")
-        assertThat(standup.recurrenceRule).isEqualTo("FREQ=WEEKLY;BYDAY=TU")
-        assertThat(standup.exDates).containsExactly("20260929T080000Z")
-    }
-
-    @Test
-    fun `the moved occurrence is skipped rather than imported as a duplicate`() {
-        // Google writes a RECURRENCE-ID override as its own VEVENT carrying the
-        // master's UID. Importing it would put a second "standup" in the
-        // calendar; Calendula models no overrides, so it is reported instead.
-        assertThat(result.events.map { it.summary }).doesNotContain("Team standup (moved)")
-        assertThat(result.warnings).contains(IcsParseWarning.ModifiedOccurrenceSkipped)
-    }
-
-    @Test
-    fun `a folded DESCRIPTION is unfolded and unescaped`() {
-        assertThat(event("Team standup").description).isEqualTo(
-            "Weekly sync with the team.\nAgenda lives in the shared doc, see the link below.",
-        )
-    }
-
-    @Test
-    fun `an escaped comma in LOCATION comes back as a comma`() {
-        assertThat(event("Team standup").location).isEqualTo("Meeting room 2, 3rd floor")
-    }
-
-    @Test
-    fun `attendees are reported rather than silently dropped`() {
-        assertThat(result.warnings).contains(IcsParseWarning.AttendeesIgnored)
-    }
-
-    @Test
-    fun `a timed VALARM becomes its lead time in minutes`() {
-        assertThat(event("Team standup").semanticReminderMinutes()).containsExactly(30)
-    }
-
-    @Test
-    fun `an all-day event keeps the single day the file gives it`() {
-        val dayOff = event("Day off")
-        assertThat(dayOff.isAllDay).isTrue()
-        assertThat((dayOff.end - dayOff.start).inWholeDays).isEqualTo(1)
-        assertThat(dayOff.availability).isEqualTo(Availability.Free)
-    }
-
-    @Test
-    fun `an all-day alarm comes back as whole days before`() {
-        // Google writes an all-day reminder as a whole-day offset from the
-        // event's UTC midnight; a day has to survive as a day.
-        assertThat(event("Day off").semanticReminderMinutes()).containsExactly(1440)
-    }
-
-    @Test
-    fun `a multi-day all-day event keeps its exclusive DTEND span`() {
-        val christmas = event("Christmas break")
-        assertThat(christmas.isAllDay).isTrue()
-        assertThat((christmas.end - christmas.start).inWholeDays).isEqualTo(3)
-    }
-
-    @Test
-    fun `no recurrence rule is repaired - Google writes them well-formed`() {
-        assertThat(result.warnings).doesNotContain(IcsParseWarning.RecurrenceRuleRepaired)
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsUnterminatedComponentTest.kt

@@ -1,66 +0,0 @@
-package de.jeanlucmakiola.calendula.domain.ics
-
-import kotlinx.datetime.TimeZone
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.Test
-
-/**
- * A component whose `END:` line never arrives (a download cut short, a producer
- * that dropped a line). `indexOfEnd` falls back to the end of the file, so the
- * block is read as if it had been closed.
- */
-class IcsUnterminatedComponentTest {
-
-    private val parser = IcsParser(TimeZone.of("Europe/Berlin"))
-
-    @Test
-    fun `file truncated mid-property keeps the event it had started`() {
-        val result = parser.parse(
-            """
-            BEGIN:VCALENDAR
-            VERSION:2.0
-            BEGIN:VEVENT
-            UID:truncated-1@fixture
-            SUMMARY:Cut off mid-file
-            DTSTART:20260924T100000Z
-            DTEND:20260924T1
-            """.trimIndent(),
-        )
-        assertEquals(1, result.events.size)
-        val event = result.events.single()
-        assertEquals("Cut off mid-file", event.summary)
-        // The truncated DTEND does not parse, so the event is zero length.
-        assertEquals(event.start, event.end)
-        assertEquals(emptySet<IcsParseWarning>(), result.warnings)
-    }
-
-    @Test
-    fun `a missing END between two events does not merge them`() {
-        val result = parser.parse(
-            """
-            BEGIN:VCALENDAR
-            VERSION:2.0
-            BEGIN:VEVENT
-            UID:first@fixture
-            SUMMARY:First event
-            DTSTART:20260924T100000Z
-            DTEND:20260924T110000Z
-            BEGIN:VEVENT
-            UID:second@fixture
-            SUMMARY:Second event
-            DTSTART:20260925T100000Z
-            DTEND:20260925T110000Z
-            END:VEVENT
-            END:VCALENDAR
-            """.trimIndent(),
-        )
-        assertEquals(
-            listOf("First event", "Second event"),
-            result.events.map { it.summary },
-        )
-        assertEquals(
-            listOf("first@fixture", "second@fixture"),
-            result.events.map { it.uid },
-        )
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/ui/calendars/BackupUiStateTest.kt

@@ -1,98 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.calendars
-
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.FailureReason
-import org.junit.jupiter.api.Test
-
-/** What the Backup & restore screen offers for a given calendar list (#304). */
-class BackupUiStateTest {
-
-    private fun cal(
-        id: Long,
-        local: Boolean = false,
-        writable: Boolean = true,
-        visible: Boolean = true,
-        managed: Boolean = false,
-        syncs: Boolean = true,
-    ) = CalendarSource(
-        id = id,
-        displayName = "Calendar $id",
-        accountName = "acc@example.com",
-        accountType = if (local) "LOCAL" else "com.google",
-        color = 0,
-        isVisibleInSystem = visible,
-        canModifyContents = writable,
-        isLocal = local,
-        isManaged = managed,
-        syncsEvents = syncs,
-    )
-
-    private fun failure(state: BackupUiState) = (state as BackupUiState.Failure).reason
-
-    private fun ready(state: BackupUiState) = state as BackupUiState.Ready
-
-    @Test
-    fun `no calendars at all reports the empty device`() {
-        // This is #304's device. The screenshots on the issue show Calendula's
-        // own calendar list with no local calendar and an empty "synced
-        // calendars" section — the app saw nothing at all, so both halves of
-        // Backup & restore had nothing to draw and the screen came up blank.
-        // The reporter's "it's synced, I can see it in settings" meant Android's
-        // settings, not this app's.
-        assertThat(failure(backupUiState(emptyList())))
-            .isEqualTo(FailureReason.NoCalendarsConfigured)
-    }
-
-    @Test
-    fun `a synced writable calendar can receive a restore`() {
-        val state = ready(backupUiState(listOf(cal(1L))))
-        assertThat(state.canImport).isTrue()
-        assertThat(state.exportable).isEmpty()
-    }
-
-    @Test
-    fun `an account that has stopped syncing is no import target`() {
-        // A calendar the provider no longer keeps events for: nothing to export
-        // and nowhere to import to, which used to render a blank screen. Not
-        // #304's device — that one had no calendars whatsoever — but the same
-        // dead end, and reachable on its own.
-        assertThat(failure(backupUiState(listOf(cal(1L, syncs = false)))))
-            .isEqualTo(FailureReason.NoImportTarget)
-    }
-
-    @Test
-    fun `a read-only subscription is no import target either`() {
-        assertThat(failure(backupUiState(listOf(cal(1L, writable = false)))))
-            .isEqualTo(FailureReason.NoImportTarget)
-    }
-
-    @Test
-    fun `everything switched off is reported as hidden, not as a missing target`() {
-        // The remedy differs: a visibility switch fixes this one.
-        assertThat(failure(backupUiState(listOf(cal(1L, visible = false)))))
-            .isEqualTo(FailureReason.AllCalendarsHidden)
-    }
-
-    @Test
-    fun `a hidden local calendar still exports`() {
-        // Export reads the provider directly, so system visibility is irrelevant
-        // to it — calling this a failure would hide a working action.
-        val state = ready(backupUiState(listOf(cal(1L, local = true, visible = false))))
-        assertThat(state.exportable).hasSize(1)
-        assertThat(state.canImport).isFalse()
-    }
-
-    @Test
-    fun `a managed special-dates mirror is neither exportable nor a target`() {
-        assertThat(failure(backupUiState(listOf(cal(1L, local = true, managed = true)))))
-            .isEqualTo(FailureReason.NoImportTarget)
-    }
-
-    @Test
-    fun `a local calendar alongside a synced one offers both halves`() {
-        val state = ready(backupUiState(listOf(cal(1L, local = true), cal(2L))))
-        assertThat(state.exportable.map { it.id }).containsExactly(1L)
-        assertThat(state.canImport).isTrue()
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/ui/common/BlockTextMetricsTest.kt

@@ -1,88 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import com.google.common.truth.Truth.assertThat
-import org.junit.jupiter.api.Test
-
-class BlockTextMetricsTest {
-
-    /** One trimmed labelMedium line at font scale 1: a 12sp glyph, leading off. */
-    private val titleLine = 14.dp
-
-    /** A block with room to spare, for the line arithmetic. */
-    private fun metrics(height: Dp = 100.dp) = BlockTextMetrics(
-        inset = blockTextInset(height, titleLine),
-        available = height - blockTextInset(height, titleLine) * 2,
-        titleLine = titleLine,
-        titleLeading = 16.dp,
-        timeLine = 13.dp,
-    )
-
-    @Test
-    fun `a block with room keeps the full inset`() {
-        assertThat(blockTextInset(height = 60.dp, titleLine = titleLine))
-            .isEqualTo(BLOCK_TEXT_INSET)
-    }
-
-    @Test
-    fun `the inset tapers instead of snapping as the block shrinks`() {
-        // Half the inset left over is half the inset kept, so a pinch closes the
-        // gap frame by frame rather than dropping it in one.
-        assertThat(blockTextInset(height = titleLine + 2.dp, titleLine = titleLine))
-            .isEqualTo(1.dp)
-    }
-
-    @Test
-    fun `a block exactly one title tall spends nothing on padding`() {
-        assertThat(blockTextInset(height = titleLine, titleLine = titleLine)).isEqualTo(0.dp)
-    }
-
-    @Test
-    fun `a block shorter than a line never insets negatively`() {
-        assertThat(blockTextInset(height = 4.dp, titleLine = titleLine)).isEqualTo(0.dp)
-    }
-
-    @Test
-    fun `the title survives a block that used to be too short for it`() {
-        // 18dp is under the old floor — a title line plus 2dp of inset at each
-        // edge — and over the new one, which is the line on its own (#289).
-        val m = metrics(height = 18.dp)
-        assertThat(m.fitsTitle).isTrue()
-    }
-
-    @Test
-    fun `a block under one line still drops the title`() {
-        assertThat(metrics(height = 10.dp).fitsTitle).isFalse()
-    }
-
-    @Test
-    fun `every title line after the first costs a whole line box`() {
-        // The trim reaches the outer edges only, so the leading between two
-        // lines is still there to pay for.
-        val m = metrics()
-        assertThat(m.titleHeight(1)).isEqualTo(14.dp)
-        assertThat(m.titleHeight(2)).isEqualTo(30.dp)
-        assertThat(m.titleHeight(3)).isEqualTo(46.dp)
-        assertThat(m.titleHeight(0)).isEqualTo(0.dp)
-    }
-
-    @Test
-    fun `the budget is what the block can actually draw, not what divides into it`() {
-        val m = metrics()
-        // Two lines cost 30dp: 29 buys one, 30 buys the second.
-        assertThat(m.titleBudget(29.dp)).isEqualTo(1)
-        assertThat(m.titleBudget(30.dp)).isEqualTo(2)
-        assertThat(m.titleBudget(13.dp)).isEqualTo(0)
-    }
-
-    @Test
-    fun `a budget line is always one the block can pay for`() {
-        val m = metrics()
-        (0..80).forEach { dp ->
-            val within = dp.dp
-            val budget = m.titleBudget(within)
-            assertThat(m.titleHeight(budget)).isAtMost(within)
-        }
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/ui/common/OutOfViewEdgesTest.kt

@@ -1,147 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.ui.week.TimedBlock
-import kotlin.time.Instant
-import org.junit.jupiter.api.Test
-
-/** Which events a column's edge bars point at, and where a tap scrolls (#188). */
-class OutOfViewEdgesTest {
-
-    private fun block(id: Long, startMin: Int, endMin: Int) = TimedBlock(
-        event = EventInstance(
-            instanceId = id,
-            eventId = id,
-            calendarId = 1L,
-            title = "Event $id",
-            start = Instant.fromEpochMilliseconds(0),
-            end = Instant.fromEpochMilliseconds(0),
-            isAllDay = false,
-            color = 0xFF112233.toInt(),
-            location = null,
-        ),
-        startMin = startMin,
-        endMin = endMin,
-        lane = 0,
-        laneCount = 1,
-    )
-
-    private val early = block(1, 7 * 60, 8 * 60)
-    private val breakfast = block(2, 8 * 60, 9 * 60)
-    private val lunch = block(3, 12 * 60, 13 * 60)
-    private val dinner = block(4, 19 * 60, 20 * 60)
-    private val late = block(5, 21 * 60, 22 * 60)
-
-    // Viewport 10:00–17:00.
-    private fun outOf(vararg blocks: TimedBlock) =
-        outOfViewEvents(blocks.toList(), topMin = 600f, bottomMin = 1020f)
-
-    @Test
-    fun `the nearest hidden event on each side is picked`() {
-        val events = outOf(early, breakfast, lunch, dinner, late)
-        assertThat(events.above).isEqualTo(breakfast)
-        assertThat(events.below).isEqualTo(dinner)
-    }
-
-    @Test
-    fun `an event in view points nowhere`() {
-        assertThat(outOf(lunch)).isEqualTo(OutOfViewEvents.None)
-    }
-
-    @Test
-    fun `an event cut by the edge is not out of view`() {
-        val straddling = block(6, 9 * 60, 11 * 60)
-        assertThat(outOf(straddling).above).isNull()
-    }
-
-    @Test
-    fun `an event disappears from the edge as soon as a sliver enters view`() {
-        val sliver = block(6, 9 * 60, 10 * 60 + 5)
-        assertThat(outOf(sliver).above).isNull()
-        val tip = block(7, 17 * 60 - 5, 18 * 60)
-        assertThat(outOf(tip).below).isNull()
-        val justAbove = block(8, 9 * 60, 10 * 60)
-        val justBelow = block(9, 17 * 60, 18 * 60)
-        assertThat(outOf(justAbove).above).isEqualTo(justAbove)
-        assertThat(outOf(justBelow).below).isEqualTo(justBelow)
-    }
-
-    @Test
-    fun `the bar fades before its event reaches the viewport`() {
-        assertThat(edgeBarAlpha(gapPx = 24f, fadeLeadPx = 24f)).isEqualTo(1f)
-        assertThat(edgeBarAlpha(gapPx = 12f, fadeLeadPx = 24f)).isEqualTo(0.5f)
-        assertThat(edgeBarAlpha(gapPx = 0f, fadeLeadPx = 24f)).isEqualTo(0f)
-        assertThat(edgeBarAlpha(gapPx = -1f, fadeLeadPx = 24f)).isEqualTo(0f)
-    }
-
-    @Test
-    fun `a column scrolled to its top points at nothing above it`() {
-        val first = block(6, 0, 30)
-        val events = outOfViewEvents(listOf(first), topMin = 0f, bottomMin = 420f)
-        assertThat(events.above).isNull()
-    }
-
-    @Test
-    fun `a short event is judged by the height it renders at`() {
-        // Five minutes ending at 09:58 still draws 26 minutes tall, past 10:00.
-        val blip = block(6, 9 * 60 + 53, 9 * 60 + 58)
-        assertThat(outOf(blip).above).isNull()
-    }
-
-    @Test
-    fun `an event above scrolls to its start less the margin`() {
-        val target = revealScrollTarget(breakfast, ViewportEdge.Top, hourPx = 100f, viewportPx = 700, marginPx = 20f, maxScroll = 1700)
-        assertThat(target).isEqualTo(780)
-    }
-
-    @Test
-    fun `an event below that fits lands whole at the bottom`() {
-        val target = revealScrollTarget(dinner, ViewportEdge.Bottom, hourPx = 100f, viewportPx = 700, marginPx = 20f, maxScroll = 1700)
-        // Its end, 2000, plus the margin, sits at the viewport's bottom.
-        assertThat(target).isEqualTo(1320)
-    }
-
-    @Test
-    fun `an event below taller than the viewport lands with its start at the top`() {
-        val long = block(6, 12 * 60, 22 * 60)
-        val target = revealScrollTarget(long, ViewportEdge.Bottom, hourPx = 100f, viewportPx = 700, marginPx = 20f, maxScroll = 1700)
-        assertThat(target).isEqualTo(1180)
-    }
-
-    @Test
-    fun `the target stays within the scroll range`() {
-        val first = block(6, 0, 30)
-        assertThat(
-            revealScrollTarget(first, ViewportEdge.Top, hourPx = 100f, viewportPx = 700, marginPx = 20f, maxScroll = 1700),
-        ).isEqualTo(0)
-        val last = block(7, 23 * 60, 24 * 60)
-        assertThat(
-            revealScrollTarget(last, ViewportEdge.Bottom, hourPx = 100f, viewportPx = 700, marginPx = 20f, maxScroll = 1700),
-        ).isEqualTo(1700)
-    }
-
-    // Viewport 1000..1700 px with both bars showing, 40 px of reach.
-    private fun tapped(y: Float, events: OutOfViewEvents = OutOfViewEvents(breakfast, dinner)) =
-        tappedEdge(events, y, viewportTop = 1000f, viewportPx = 700, reachPx = 40f)
-
-    @Test
-    fun `a tap near an edge with a bar hits that bar`() {
-        assertThat(tapped(1010f)).isEqualTo(ViewportEdge.Top)
-        assertThat(tapped(1040f)).isEqualTo(ViewportEdge.Top)
-        assertThat(tapped(1690f)).isEqualTo(ViewportEdge.Bottom)
-    }
-
-    @Test
-    fun `a tap past the bar's reach is left to the column`() {
-        assertThat(tapped(1041f)).isNull()
-        assertThat(tapped(1350f)).isNull()
-        assertThat(tapped(1659f)).isNull()
-    }
-
-    @Test
-    fun `a tap near an edge without a bar is left to the column`() {
-        assertThat(tapped(1010f, OutOfViewEvents(null, dinner))).isNull()
-        assertThat(tapped(1690f, OutOfViewEvents(breakfast, null))).isNull()
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/ui/common/PageStateCacheTest.kt

@@ -1,53 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import com.google.common.truth.Truth.assertThat
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.awaitCancellation
-import kotlinx.coroutines.flow.flow
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.test.UnconfinedTestDispatcher
-import kotlinx.coroutines.test.runTest
-import org.junit.jupiter.api.Test
-import kotlin.math.abs
-
-@OptIn(ExperimentalCoroutinesApi::class)
-class PageStateCacheTest {
-
-    @Test
-    fun `the same key shares one state`() = runTest {
-        val cache = PageStateCache<Int, Int>(backgroundScope, 0, { a, b -> abs(a - b) <= 1 }) { flow { emit(it) } }
-        assertThat(cache.get(5)).isSameInstanceAs(cache.get(5))
-    }
-
-    @Test
-    fun `a dropped entry stops loading`() = runTest(UnconfinedTestDispatcher()) {
-        var running = 0
-        val cache = PageStateCache<Int, Int>(backgroundScope, 0, { a, b -> abs(a - b) <= 1 }) { key ->
-            flow {
-                running++
-                try {
-                    emit(key)
-                    awaitCancellation()
-                } finally {
-                    running--
-                }
-            }
-        }
-        backgroundScope.launch { cache.get(0).collect {} }
-        assertThat(running).isEqualTo(1)
-
-        // Far enough away that 0 is let go, even though it is still collected.
-        cache.get(10)
-        assertThat(running).isEqualTo(0)
-        assertThat(cache.size).isEqualTo(1)
-    }
-
-    @Test
-    fun `nearby entries are kept`() = runTest {
-        val cache = PageStateCache<Int, Int>(backgroundScope, 0, { a, b -> abs(a - b) <= 2 }) { flow { emit(it) } }
-        cache.get(4)
-        cache.get(5)
-        cache.get(6)
-        assertThat(cache.size).isEqualTo(3)
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/ui/common/TimelineHoursTest.kt

@@ -1,115 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.ui.unit.dp
-import com.google.common.truth.Truth.assertThat
-import org.junit.jupiter.api.Test
-
-class TimelineHoursTest {
-
-    private val viewport = 600.dp
-
-    @Test
-    fun `the chosen range exactly fills the viewport`() {
-        // 07–22 is 15 hours: 600dp / 15 = 40dp an hour.
-        assertThat(TimelineScale.FitHours(7, 22).hourHeight(viewport)).isEqualTo(40.dp)
-    }
-
-    @Test
-    fun `the whole day fits like FitDay`() {
-        assertThat(TimelineScale.FitHours(0, 24).hourHeight(viewport))
-            .isEqualTo(TimelineScale.FitDay.hourHeight(viewport))
-    }
-
-    @Test
-    fun `a short range on a tall screen stops at the pinch ceiling`() {
-        assertThat(TimelineScale.FitHours(9, 11).hourHeight(2000.dp)).isEqualTo(MAX_PINCH_HOUR_HEIGHT)
-    }
-
-    @Test
-    fun `ranges are held to the day and the minimum span`() {
-        assertThat(TimelineHours.of(true, -3, 30)).isEqualTo(TimelineHours(true, 0, 24))
-        assertThat(TimelineHours.of(true, 23, 22)).isEqualTo(TimelineHours(true, 20, 22))
-        assertThat(TimelineHours.of(true, 5, 1)).isEqualTo(TimelineHours(true, 0, 2))
-    }
-
-    @Test
-    fun `the pickers only offer valid pairings`() {
-        assertThat(TimelineHours.startOptions(22)).isEqualTo((0..20).toList())
-        assertThat(TimelineHours.endOptions(7)).isEqualTo((9..24).toList())
-    }
-
-    @Test
-    fun `opening scrolls to the start hour once the layout is at the fitted height`() {
-        // 40px an hour over a 600px viewport: 960px of content, 360px of scroll.
-        assertThat(startHourScroll(maxValue = 360, viewportPx = 600, startHour = 7, hourPx = 40f))
-            .isEqualTo(280)
-    }
-
-    @Test
-    fun `a layout still at the previous scale is waited out`() {
-        // Still 56px an hour: 1344 - 600 = 744 of scroll.
-        assertThat(startHourScroll(maxValue = 744, viewportPx = 600, startHour = 7, hourPx = 40f))
-            .isNull()
-        // Not laid out at all yet.
-        assertThat(startHourScroll(maxValue = Int.MAX_VALUE, viewportPx = 0, startHour = 7, hourPx = 40f))
-            .isNull()
-    }
-
-    @Test
-    fun `the whole day needs no scroll`() {
-        assertThat(startHourScroll(maxValue = 0, viewportPx = 600, startHour = 0, hourPx = 25f))
-            .isEqualTo(0)
-    }
-
-    @Test
-    fun `a fitted range round-trips through storage`() {
-        val scale = TimelineScale.FitHours(6, 20)
-        assertThat(parseTimelineScale(scale.storageValue())).isEqualTo(scale)
-        assertThat(parseTimelineScale("hours:x-2")).isEqualTo(TimelineScale.Regular)
-    }
-
-    @Test
-    fun `opening with visible hours on replaces a pinched scale`() {
-        val persisted = mutableListOf<TimelineScale>()
-        val zoom = TimelineZoom(TimelineScale.custom(90.dp)) { persisted += it }
-        zoom.adoptHours(TimelineHours(true, 7, 22))
-
-        assertThat(zoom.open()).isEqualTo(7)
-        assertThat(zoom.scale).isEqualTo(TimelineScale.FitHours(7, 22))
-
-        // A pinch overrides it for the visit but is not saved over the preference.
-        zoom.beginPinch()
-        zoom.pinchTo(100.dp)
-        zoom.endPinch()
-        assertThat(zoom.scale).isEqualTo(TimelineScale.custom(100.dp))
-        assertThat(persisted).isEmpty()
-
-        // Opening again fits the range again.
-        zoom.open()
-        assertThat(zoom.scale).isEqualTo(TimelineScale.FitHours(7, 22))
-    }
-
-    @Test
-    fun `a late stored scale does not undo the fit, and switching off restores it`() {
-        val zoom = TimelineZoom(TimelineScale.Regular) {}
-        zoom.adoptHours(TimelineHours(true, 7, 22))
-        zoom.open()
-        zoom.adopt(TimelineScale.Comfortable)
-        assertThat(zoom.scale).isEqualTo(TimelineScale.FitHours(7, 22))
-
-        zoom.adoptHours(TimelineHours(false, 7, 22))
-        assertThat(zoom.open()).isNull()
-        assertThat(zoom.scale).isEqualTo(TimelineScale.Comfortable)
-    }
-
-    @Test
-    fun `with visible hours off a pinch is still saved`() {
-        val persisted = mutableListOf<TimelineScale>()
-        val zoom = TimelineZoom(TimelineScale.Regular) { persisted += it }
-        assertThat(zoom.open()).isNull()
-        zoom.beginPinch()
-        zoom.pinchTo(70.dp)
-        zoom.endPinch()
-        assertThat(persisted).containsExactly(TimelineScale.custom(70.dp))
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/ui/day/DayPagingTest.kt

@@ -1,22 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.day
-
-import com.google.common.truth.Truth.assertThat
-import kotlinx.datetime.LocalDate
-import org.junit.jupiter.api.Test
-
-class DayPagingTest {
-
-    @Test
-    fun `a page and its day round-trip`() {
-        listOf(LocalDate(2026, 9, 27), LocalDate(1990, 5, 16), LocalDate(2100, 2, 28)).forEach { day ->
-            assertThat(dayForPage(dayPageFor(day))).isEqualTo(day)
-        }
-    }
-
-    @Test
-    fun `adjacent pages are adjacent days across a month end`() {
-        val page = dayPageFor(LocalDate(2026, 2, 28))
-        assertThat(dayForPage(page + 1)).isEqualTo(LocalDate(2026, 3, 1))
-        assertThat(dayForPage(page - 1)).isEqualTo(LocalDate(2026, 2, 27))
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/ui/month/ChipAtCellYTest.kt

@@ -56,13 +56,7 @@ class ChipAtCellYTest {
     )
 
     private fun MonthWeek.chipAt(col: Int, cellY: Float) =
-        chipAtCellY(
-            col = col,
-            cellY = cellY,
-            bandTopInCell = bandTop,
-            rowHeightPx = laneHeight,
-            laneCap = SPLIT_DOT_LANES,
-        )
+        chipAtCellY(col = col, cellY = cellY, bandTopInCell = bandTop, rowHeightPx = laneHeight)
 
     @Test
     fun `a tap on a lane resolves to the chip seated there`() {
@@ -104,13 +98,13 @@ class ChipAtCellYTest {
 
     @Test
     fun `a tap on the overflow row opens the day rather than a hidden event`() {
-        val events = (1..SPLIT_DOT_LANES + 2).map {
+        val events = (1..MAX_EVENT_ROWS + 2).map {
             timed(LocalDate(2026, 7, 7), hour = it, id = it.toLong())
         }
         val week = rowOfJuly6(events)
 
         // The dots sit one lane below the last one the row draws.
-        val overflowY = bandTop + laneHeight * SPLIT_DOT_LANES + 2f
+        val overflowY = bandTop + laneHeight * MAX_EVENT_ROWS + 2f
         assertThat(week.chipAt(col = 1, cellY = overflowY)).isNull()
     }
 
@@ -119,22 +113,10 @@ class ChipAtCellYTest {
         val week = rowOfJuly6(listOf(timed(LocalDate(2026, 7, 7), hour = 9, id = 2L)))
 
         assertThat(
-            week.chipAtCellY(
-                col = 1,
-                cellY = 45f,
-                bandTopInCell = null,
-                rowHeightPx = laneHeight,
-                laneCap = SPLIT_DOT_LANES,
-            ),
+            week.chipAtCellY(col = 1, cellY = 45f, bandTopInCell = null, rowHeightPx = laneHeight),
         ).isNull()
         assertThat(
-            week.chipAtCellY(
-                col = 1,
-                cellY = 45f,
-                bandTopInCell = bandTop,
-                rowHeightPx = 0f,
-                laneCap = SPLIT_DOT_LANES,
-            ),
+            week.chipAtCellY(col = 1, cellY = 45f, bandTopInCell = bandTop, rowHeightPx = 0f),
         ).isNull()
     }
 }

app/src/test/java/de/jeanlucmakiola/calendula/ui/month/ContinuousMonthIndexTest.kt

@@ -222,17 +222,17 @@ class ContinuousMonthIndexTest {
     }
 
     @Test
-    fun `the split agenda starts at today in the current month`() {
+    fun `the split selection follows the month, landing on today when it's there`() {
         val today = LocalDate(2026, 6, 10)
-        assertThat(agendaStartForMonth(jun26, today)).isEqualTo(today)
+        assertThat(selectionForMonth(jun26, today)).isEqualTo(today)
     }
 
     @Test
-    fun `the split agenda starts at the 1st of another month`() {
+    fun `the split selection falls to the 1st of any other month`() {
         val today = LocalDate(2026, 6, 10)
-        assertThat(agendaStartForMonth(YearMonth(2026, Month.JULY), today))
+        assertThat(selectionForMonth(YearMonth(2026, Month.JULY), today))
             .isEqualTo(LocalDate(2026, 7, 1))
-        assertThat(agendaStartForMonth(YearMonth(2025, Month.JUNE), today))
+        assertThat(selectionForMonth(YearMonth(2025, Month.JUNE), today))
             .isEqualTo(LocalDate(2025, 6, 1))
     }
 }

app/src/test/java/de/jeanlucmakiola/calendula/ui/month/MonthLaneCapTest.kt

@@ -1,93 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.month
-
-import androidx.compose.ui.unit.dp
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.domain.EventInstance
-import kotlinx.datetime.DayOfWeek
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.Month
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.YearMonth
-import kotlinx.datetime.atTime
-import kotlinx.datetime.toInstant
-import org.junit.jupiter.api.Test
-
-/**
- * How many chip lanes a week row seats at a given height (#190) — the cap that
- * used to be a flat three whatever the device had.
- */
-class MonthLaneCapTest {
-
-    private val zone = TimeZone.UTC
-    private val jul26 = YearMonth(2026, Month.JULY)
-    private val monday = LocalDate(2026, 7, 6)
-
-    /** Cell chrome above the band: 6 + 22 + 4. */
-    private val header = 32.dp
-
-    private fun timed(day: LocalDate, hour: Int, id: Long) = EventInstance(
-        instanceId = id,
-        eventId = id,
-        calendarId = 1L,
-        title = "T$id",
-        start = day.atTime(hour, 0).toInstant(zone),
-        end = day.atTime(hour + 1, 0).toInstant(zone),
-        isAllDay = false,
-        color = 0xFFF44336.toInt(),
-        location = null,
-    )
-
-    /** Jul 6-12, wholly inside July 2026. */
-    private fun week(eventsOnMonday: Int) = layoutMonthWeeks(
-        jul26,
-        DayOfWeek.MONDAY,
-        (1..eventsOnMonday).map { timed(monday, hour = it, id = it.toLong()) },
-        zone,
-    )[1]
-
-    private fun rowFor(bandHeight: Int) = header + bandHeight.dp
-
-    /** A labelSmall line at font scale 1 — what the overflow row measures to. */
-    private val overflowRow = 16.dp
-
-    private fun MonthWeek.capAt(rowHeight: androidx.compose.ui.unit.Dp) =
-        laneCapFor(rowHeight, overflowRow)
-
-    @Test
-    fun `a week that fits spends the overflow row on another lane`() {
-        // 80dp of band is four 20dp lanes. Nothing overflows at four, so no
-        // room is set aside for a marker that would never be drawn.
-        assertThat(week(eventsOnMonday = 4).capAt(rowFor(80))).isEqualTo(4)
-    }
-
-    @Test
-    fun `a week that overflows pays for the dots out of its own lanes`() {
-        // The same 80dp, but a fifth event means the dots have to be drawn, and
-        // their 14dp comes off the band before it is divided.
-        assertThat(week(eventsOnMonday = 5).capAt(rowFor(80))).isEqualTo(3)
-    }
-
-    @Test
-    fun `a taller row seats more, with no ceiling`() {
-        assertThat(week(eventsOnMonday = 20).capAt(rowFor(120))).isEqualTo(5)
-        assertThat(week(eventsOnMonday = 20).capAt(rowFor(220))).isEqualTo(10)
-    }
-
-    @Test
-    fun `a cramped row seats fewer rather than drawing past its band`() {
-        // 58dp was three clipped lanes and dots nobody could see. It is two
-        // lanes and a visible marker.
-        assertThat(week(eventsOnMonday = 6).capAt(rowFor(58))).isEqualTo(2)
-    }
-
-    @Test
-    fun `a row with no height to give still seats one lane`() {
-        assertThat(week(eventsOnMonday = 6).capAt(rowFor(0))).isEqualTo(1)
-        assertThat(week(eventsOnMonday = 6).capAt(10.dp)).isEqualTo(1)
-    }
-
-    @Test
-    fun `an empty week never charges itself for dots`() {
-        assertThat(week(eventsOnMonday = 0).capAt(rowFor(80))).isEqualTo(4)
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/ui/onboarding/OnboardingPlanTest.kt

@@ -18,10 +18,6 @@ class OnboardingPlanTest {
         viewDone: Boolean = false,
         monthStyleDone: Boolean = false,
         backupApplies: Boolean? = null,
-        hiddenDone: Boolean = false,
-        hiddenApplies: Boolean? = false,
-        calendarsDone: Boolean = false,
-        calendarsApplies: Boolean? = false,
         visibilityArmed: Boolean = false,
         visibilityDone: Boolean = false,
         doneShown: Boolean = false,
@@ -33,10 +29,6 @@ class OnboardingPlanTest {
         viewDone = viewDone,
         monthStyleDone = monthStyleDone,
         backupApplies = backupApplies,
-        hiddenDone = hiddenDone,
-        hiddenApplies = hiddenApplies,
-        calendarsDone = calendarsDone,
-        calendarsApplies = calendarsApplies,
         visibilityArmed = visibilityArmed,
         visibilityDone = visibilityDone,
         doneShown = doneShown,
@@ -251,144 +243,4 @@ class OnboardingPlanTest {
         )
         assertThat(read.current).isNull()
     }
-
-    // --- the calendar step (#287) -----------------------------------------
-
-    @Test
-    fun `a device with no calendar is offered one, right after the grant`() {
-        val fresh = plan(hasPermission = true, wizardArmed = true, calendarsApplies = null)
-        assertThat(fresh.steps).contains(OnboardingStep.Calendars)
-        assertThat(fresh.current).isEqualTo(OnboardingStep.Calendars)
-        // Before reminders: there is no point asking about notifications for
-        // events that have nowhere to live.
-        assertThat(fresh.steps.indexOf(OnboardingStep.Calendars))
-            .isLessThan(fresh.steps.indexOf(OnboardingStep.Reminders))
-    }
-
-    @Test
-    fun `a device that already has a calendar never sees the step`() {
-        val fresh = plan(hasPermission = true, wizardArmed = true, calendarsApplies = false)
-        assertThat(fresh.steps).doesNotContain(OnboardingStep.Calendars)
-    }
-
-    @Test
-    fun `the step is assumed to apply until a calendar list proves otherwise`() {
-        // Same contract the backup step keeps: an unknown answer keeps the step,
-        // so the plan can only ever get shorter and the counter never grows.
-        val unknown = plan(hasPermission = true, wizardArmed = true, calendarsApplies = null)
-        val known = plan(hasPermission = true, wizardArmed = true, calendarsApplies = false)
-        assertThat(unknown.steps).contains(OnboardingStep.Calendars)
-        assertThat(known.total).isLessThan(unknown.total)
-    }
-
-    @Test
-    fun `answering the step moves on without renumbering the flow`() {
-        val before = plan(hasPermission = true, wizardArmed = true, calendarsApplies = null)
-        val after = before.let {
-            plan(
-                hasPermission = true,
-                wizardArmed = true,
-                calendarsApplies = null,
-                calendarsDone = true,
-            )
-        }
-        assertThat(after.current).isEqualTo(OnboardingStep.Reminders)
-        assertThat(after.steps).isEqualTo(before.steps)
-        assertThat(after.total).isEqualTo(before.total)
-    }
-
-    @Test
-    fun `an existing install is never given the calendar step`() {
-        // Not gated on `fresh` would re-onboard everyone whose read momentarily
-        // came back empty.
-        val existing = plan(
-            hasPermission = true,
-            remindersDone = true,
-            calendarsApplies = null,
-        )
-        assertThat(existing.steps).doesNotContain(OnboardingStep.Calendars)
-    }
-
-    // --- every calendar switched off (#287) -------------------------------
-
-    @Test
-    fun `a fresh install whose calendars are all off is shown them first`() {
-        // Nothing visible leaves the calendar step unresolved too, which is what
-        // puts the two in the same flow.
-        val hidden = plan(
-            hasPermission = true,
-            wizardArmed = true,
-            hiddenApplies = true,
-            calendarsApplies = null,
-        )
-        assertThat(hidden.current).isEqualTo(OnboardingStep.HiddenCalendars)
-        // Switching one back on is the lighter remedy, so it comes before the
-        // offer to make a calendar.
-        assertThat(hidden.steps.indexOf(OnboardingStep.HiddenCalendars))
-            .isLessThan(hidden.steps.indexOf(OnboardingStep.Calendars))
-    }
-
-    @Test
-    fun `declining them leaves the offer to make a calendar standing`() {
-        // The whole point of the order: someone who will not switch their
-        // calendars on still gets the offer a device with none at all gets.
-        val declined = plan(
-            hasPermission = true,
-            wizardArmed = true,
-            hiddenApplies = true,
-            hiddenDone = true,
-            calendarsApplies = null,
-        )
-        assertThat(declined.current).isEqualTo(OnboardingStep.Calendars)
-    }
-
-    @Test
-    fun `switching one on drops the offer to make a calendar`() {
-        // Something is showing now, so there is somewhere to put an event; the
-        // step the user is standing on is held in place by the view model.
-        val fixed = plan(
-            hasPermission = true,
-            wizardArmed = true,
-            hiddenApplies = null,
-            calendarsApplies = false,
-        )
-        assertThat(fixed.steps).contains(OnboardingStep.HiddenCalendars)
-        assertThat(fixed.steps).doesNotContain(OnboardingStep.Calendars)
-    }
-
-    @Test
-    fun `a fresh install with something visible never sees the step`() {
-        val visible = plan(hasPermission = true, wizardArmed = true, hiddenApplies = false)
-        assertThat(visible.steps).doesNotContain(OnboardingStep.HiddenCalendars)
-    }
-
-    @Test
-    fun `the step is assumed until the calendar list proves something is visible`() {
-        // The unreadable answer keeps the step, like the ones around it: the flow
-        // shrinks when the list arrives, and the counter never grows.
-        val unknown = plan(hasPermission = true, wizardArmed = true, hiddenApplies = null)
-        val known = plan(hasPermission = true, wizardArmed = true, hiddenApplies = false)
-        assertThat(unknown.steps).contains(OnboardingStep.HiddenCalendars)
-        assertThat(known.total).isLessThan(unknown.total)
-    }
-
-    @Test
-    fun `an existing install that switched its own calendars off is left alone`() {
-        // Hiding every calendar from Settings is a deliberate act with an empty
-        // state of its own (#239); it must not reopen the wizard.
-        val existing = plan(hasPermission = true, remindersDone = true, hiddenApplies = true)
-        assertThat(existing.steps).isEmpty()
-        assertThat(existing.current).isNull()
-    }
-
-    @Test
-    fun `the upgrade notice stays a notice at the end of the flow`() {
-        val armed = plan(
-            hasPermission = true,
-            remindersDone = true,
-            visibilityArmed = true,
-            hiddenApplies = true,
-        )
-        assertThat(armed.steps).containsExactly(OnboardingStep.Visibility)
-    }
 }

app/src/test/java/de/jeanlucmakiola/calendula/ui/theme/FontsTest.kt

@@ -1,6 +1,5 @@
 package de.jeanlucmakiola.calendula.ui.theme
 
-import androidx.compose.ui.unit.sp
 import com.google.common.truth.Truth.assertThat
 import org.junit.jupiter.api.Test
 
@@ -49,19 +48,6 @@ class FontsTest {
         assertThat(typography.labelSmall.fontFamily).isEqualTo(plain)
     }
 
-    @Test
-    fun `picking a font keeps the tightened label tracking`() {
-        // The font picker only swaps the family; the tracking the grids are laid
-        // out against has to survive it (#190).
-        val typography = calendulaTypography(
-            brand = BundledFont.Lora.family,
-            plain = BundledFont.AtkinsonHyperlegible.family,
-        )
-
-        assertThat(typography.labelSmall.letterSpacing).isEqualTo(0.1.sp)
-        assertThat(typography.labelMedium.letterSpacing).isEqualTo(0.1.sp)
-    }
-
     @Test
     fun `a null role keeps that role's default family while the other is applied`() {
         val plain = BundledFont.Lora.family

app/src/test/java/de/jeanlucmakiola/calendula/ui/week/WeekLayoutTest.kt

@@ -49,8 +49,8 @@ class WeekLayoutTest {
     }
 
     @Test
-    fun `spanRange spans seven days`() {
-        val range = spanRange(mon, 7, zone)
+    fun `weekRange spans seven days`() {
+        val range = weekRange(mon, zone)
         assertThat(range.start).isEqualTo(at(mon, 0, 0))
         // endInclusive is the last second of day 7 (Sunday 2026-06-14)
         assertThat(range.endInclusive).isEqualTo(LocalDate(2026, 6, 14).atTime(23, 59, 59).toInstant(zone))

app/src/test/java/de/jeanlucmakiola/calendula/ui/week/WeekPagingTest.kt

@@ -1,67 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.week
-
-import com.google.common.truth.Truth.assertThat
-import kotlinx.datetime.DateTimeUnit
-import kotlinx.datetime.DayOfWeek
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.plus
-import org.junit.jupiter.api.Test
-
-class WeekPagingTest {
-
-    // 2026-09-27 is a Sunday.
-    private val sunday = LocalDate(2026, 9, 27)
-
-    @Test
-    fun `a page and its week round-trip for every first day`() {
-        DayOfWeek.entries.forEach { firstDay ->
-            val page = weekPageFor(sunday, firstDay)
-            val start = weekStartForPage(page, firstDay)
-            assertThat(start).isEqualTo(sunday.startOfWeek(firstDay))
-            assertThat(weekPageFor(start, firstDay)).isEqualTo(page)
-        }
-    }
-
-    @Test
-    fun `every day of a week maps to the same page`() {
-        val start = sunday.startOfWeek(DayOfWeek.MONDAY)
-        val pages = (0..6).map { weekPageFor(start.plus(it, DateTimeUnit.DAY), DayOfWeek.MONDAY) }
-        assertThat(pages.toSet()).hasSize(1)
-    }
-
-    @Test
-    fun `adjacent pages are adjacent weeks`() {
-        val page = weekPageFor(sunday, DayOfWeek.SUNDAY)
-        assertThat(weekStartForPage(page + 1, DayOfWeek.SUNDAY))
-            .isEqualTo(LocalDate(2026, 10, 4))
-        assertThat(weekStartForPage(page - 1, DayOfWeek.SUNDAY))
-            .isEqualTo(LocalDate(2026, 9, 20))
-    }
-
-    @Test
-    fun `dates before the epoch page resolve too`() {
-        val old = LocalDate(1990, 5, 16)
-        val page = weekPageFor(old, DayOfWeek.MONDAY)
-        assertThat(weekStartForPage(page, DayOfWeek.MONDAY)).isEqualTo(LocalDate(1990, 5, 14))
-    }
-
-    @Test
-    fun `multi-day pages begin on the selected date and advance by the chosen count`() {
-        (3..6).forEach { count ->
-            val grid = DaysGrid.startingAt(sunday, count)
-            val page = grid.pageFor(sunday)
-            assertThat(grid.startForPage(page)).isEqualTo(sunday)
-            assertThat(grid.startForPage(page + 1)).isEqualTo(sunday.plus(count, DateTimeUnit.DAY))
-            assertThat(grid.pageFor(sunday.plus(count - 1, DateTimeUnit.DAY))).isEqualTo(page)
-        }
-    }
-
-    @Test
-    fun `multi-day pages also work before the epoch`() {
-        val date = LocalDate(1990, 5, 16)
-        val grid = DaysGrid.startingAt(date, 3)
-        val page = grid.pageFor(date)
-        assertThat(grid.startForPage(page)).isEqualTo(date)
-        assertThat(grid.startForPage(page - 1)).isEqualTo(LocalDate(1990, 5, 13))
-    }
-}

app/src/test/resources/ics/google-calendar-export.ics

@@ -1,91 +0,0 @@
-BEGIN:VCALENDAR
-PRODID:-//Google Inc//Google Calendar 70.9054//EN
-VERSION:2.0
-CALSCALE:GREGORIAN
-METHOD:PUBLISH
-X-WR-CALNAME:jane@example.com
-X-WR-TIMEZONE:Europe/Berlin
-BEGIN:VTIMEZONE
-TZID:Europe/Berlin
-X-LIC-LOCATION:Europe/Berlin
-BEGIN:DAYLIGHT
-TZOFFSETFROM:+0100
-TZOFFSETTO:+0200
-TZNAME:CEST
-DTSTART:19700329T020000
-RRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=-1SU
-END:DAYLIGHT
-BEGIN:STANDARD
-TZOFFSETFROM:+0200
-TZOFFSETTO:+0100
-TZNAME:CET
-DTSTART:19701025T030000
-RRULE:FREQ=YEARLY;BYMONTH=10;BYDAY=-1SU
-END:STANDARD
-END:VTIMEZONE
-BEGIN:VEVENT
-DTSTART;TZID=Europe/Berlin:20260915T100000
-DTEND;TZID=Europe/Berlin:20260915T113000
-RRULE:FREQ=WEEKLY;BYDAY=TU
-EXDATE;TZID=Europe/Berlin:20260929T100000
-DTSTAMP:20260912T183000Z
-UID:0abcdef1234567890abcdef12345@google.com
-CREATED:20260901T120000Z
-DESCRIPTION:Weekly sync with the team.\nAgenda lives in the shared doc\, see
-  the link below.
-LAST-MODIFIED:20260902T081500Z
-LOCATION:Meeting room 2\, 3rd floor
-SEQUENCE:0
-STATUS:CONFIRMED
-SUMMARY:Team standup
-TRANSP:OPAQUE
-ORGANIZER;CN=Jane Doe:mailto:jane@example.com
-ATTENDEE;CUTYPE=INDIVIDUAL;ROLE=REQ-PARTICIPANT;PARTSTAT=ACCEPTED;CN=John:m
- ailto:john@example.com
-BEGIN:VALARM
-ACTION:DISPLAY
-DESCRIPTION:This is an event reminder
-TRIGGER:-PT30M
-END:VALARM
-END:VEVENT
-BEGIN:VEVENT
-DTSTART;TZID=Europe/Berlin:20260929T140000
-DTEND;TZID=Europe/Berlin:20260929T153000
-DTSTAMP:20260912T183000Z
-UID:0abcdef1234567890abcdef12345@google.com
-RECURRENCE-ID;TZID=Europe/Berlin:20260929T100000
-CREATED:20260901T120000Z
-LAST-MODIFIED:20260910T091500Z
-SEQUENCE:1
-STATUS:CONFIRMED
-SUMMARY:Team standup (moved)
-TRANSP:OPAQUE
-END:VEVENT
-BEGIN:VEVENT
-DTSTART;VALUE=DATE:20261024
-DTEND;VALUE=DATE:20261025
-DTSTAMP:20260912T183000Z
-UID:1bcdef01234567890abcdef23456@google.com
-CREATED:20260820T101500Z
-LAST-MODIFIED:20260820T101500Z
-SEQUENCE:0
-STATUS:CONFIRMED
-SUMMARY:Day off
-TRANSP:TRANSPARENT
-BEGIN:VALARM
-ACTION:DISPLAY
-DESCRIPTION:This is an event reminder
-TRIGGER:-P1D
-END:VALARM
-END:VEVENT
-BEGIN:VEVENT
-DTSTART;VALUE=DATE:20261224
-DTEND;VALUE=DATE:20261227
-DTSTAMP:20260912T183000Z
-UID:2cdef012345678901abcdef34567@google.com
-SEQUENCE:0
-STATUS:CONFIRMED
-SUMMARY:Christmas break
-TRANSP:TRANSPARENT
-END:VEVENT
-END:VCALENDAR

docs/ARCHITECTURE.md

@@ -113,19 +113,6 @@ notice (#75) is a step in front of it rather than a dialog over the app — it
 is the only optional step an *already onboarded* install can be given, which
 is why it alone is not gated on the wizard being armed.
 
-"Every calendar is switched off" is a *state*, not that announcement, so it
-is a step of its own at the front of the flow (#287) rather than another face
-of the notice: the notice is settled once and for good, while the state is
-derived from the live calendar list on every launch. It lists the calendars
-with their own switches — switching one on un-hides it in every other calendar
-app too, which is not a choice to make on the app's word — and it sits *in
-front of* the calendar step, so declining it falls through to the offer to
-make a calendar that a device with none at all gets. That is also why
-`calendarsApplies` resolves on "something is visible" rather than "the list is
-non-empty". Being derived, it is gated on the wizard being armed: an install
-that switched its own calendars off from Settings meant it, and has the in-app
-empty state (#239) instead.
-
 ## Recurring writes
 
 The provider's invariants drive the design (learned the hard way, verified

fastlane/metadata/android/en-US/changelogs/22100.txt

@@ -1,11 +0,0 @@
-New
-• Setup now makes sure you have a calendar to write to — create one, add an account, or switch a hidden one back on.
-
-Changed
-• The month grid gives its days more room: smaller week numbers, a measured gutter, tighter chips.
-• A month day shows as many events as it has height for, instead of a flat three.
-• Split view no longer pads a short month out to six rows.
-
-Fixed
-• Short events show their title in week and day view.
-• Untitled events and unnamed calendars read in your language.