Release v2.23.0-beta.4 (#178, #181, #271, #306, #339, #387)

Follow-up to #394, from two review passes on the tap-opens-editor change.

- The edit form's view model is reused between opens, so work still running for a closed form could land on the next one. Backing out of a slow load and tapping another event showed the old event, and Save wrote to it. A delete finishing after back closed the next editor. Results from a closed form are now dropped.
- Back is ignored while a save or delete runs. The write can't be called back, so the form waits for the result and then closes or reports the error.
- Unsaved changes are now measured against the form as it opened, defaults included, instead of a flag every setter had to set.
- Taps read the setting and whether the calendar takes writes when they happen, so a tap right after a cold start or a return to the app opens the right screen.
- Without write access, the first tap asks once. A refusal opens the details from then on, until the permission is granted.
- Pinning an event to the tapped occurrence lives in one helper (`EventDetail.atOccurrence`), used by the detail, edit and selection-bar paths.

Closes #178

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

CHANGELOG.md

@@ -8,26 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
-- **Six new home-screen widgets.** Quick add (1×1) opens a new event on today with the same defaults as the app's + button ([#435]). Date (1×1) shows today's weekday and day number on a rounded shape and opens today ([#376]). Week strip (4×1) shows this week's days with a dot in each event's colour and today filled ([#436]). Upcoming (2×2) shows today's date over your next events, as many as fit ([#437]). Today lists today's events; once they're over it says "Nothing left today" and shows tomorrow's first one or two ([#438]). Countdown counts down to your next timed event, or to an event or series you pick, like a holiday in 12 days ([#439]).
-- **A month and day widget.** A compact month grid sits beside the events of one day. Tap a day in the grid to see its events, and tap the list to open that day in the app ([#441]).
-- **Each widget has its own settings.** Placing a widget, or long-pressing it and choosing Edit, opens a settings screen with a live preview. Pick a solid, tinted or transparent background, a light or dark theme or the app's, and which calendars it shows. Widgets that list events also have their time range, text size and how past events look. Settings → Widgets lists the widgets on your home screen so you can change them from there. These options used to be shared by all widgets; widgets you already placed keep what you had set ([#292]).
-
-### Changed
-- **The agenda and month widgets have a new look.** The agenda puts each day in its own card, with a round date pill beside the first event and today's pill filled. The month widget has rounded day cells, weekday pills, shaded days outside the month and a + for a new event. The agenda's refresh button is gone, since widgets now update on their own ([#71], [#90]).
-- **Tapping a day in the month widget opens that day,** wherever in its cell you tap ([#386]).
-- **The widget picker shows what each widget looks like.** On Android 15 and later the previews are the real widgets with sample events, in your language and colours; on older versions they are redrawn to match.
-- **Widgets are listed by their name alone,** without "Calendula" in front, and each has a short description in the picker ([#71]).
-- **Past events in widgets stay readable when dimmed.** Their background fades further and their text less ([#90]).
-
-### Fixed
-- **Widgets show your changes straight away.** After you added, edited or deleted an event, a widget could keep showing the old events until something else redrew it ([#420], [#229]).
-- **Widgets follow the app's language.** After you picked a language in Settings, widgets kept the old one until something redrew them ([#90]).
-- **The month widget handles busy months.** It could show "Can't show content", or only one or two events per day. Each day now shows as many events as its height fits, and the rest fold into +N ([#372]).
-
-## [2.23.0] — 2026-10-21
-
-### Added
-- **Long press an event to select it.** In the day, 3-day and week views, a long press lifts the event and selects it. Keep your finger down and move to drag it straight away. A selected event has handles at its top and bottom: drag them to change when it starts or ends, in 15-minute steps and across midnight if you want. The bar at the top edits, duplicates, shares or deletes it, and tapping elsewhere or going back deselects it. The bar shows the new times while you move or resize. Read-only events can be selected but not moved or resized ([#141]).
+- **Long press an event to select it.** In the day, 3-day and week views, a long press lifts the event and selects it. Keep your finger down and move to drag it straight away. A selected event has handles at its top and bottom: drag them to change when it starts or ends, in 15-minute steps and across midnight if you want. The bar at the top edits, duplicates, shares or deletes it, and tapping elsewhere or going back deselects it. Read-only events can be selected but not moved or resized ([#141]).
 - **Long press an empty slot to draft an event.** In the day, 3-day and week views, a long press on free time drops a block of your default event length there. Move it while still holding, or let go and drag it or its handles into place, then tap the tick to open a new event at that time. The ✕, a tap elsewhere or going back throws the draft away ([#153]).
 - **Tap a phone number in an event to call it.** Phone numbers in an event's title, location and description are now links. Tapping one opens your phone app with the number filled in, ready to call. A conference dial-in like "+1 646 558 8656,,850123#" brings its meeting ID along. Meeting IDs and PINs on their own, dates, times and amounts stay plain text. Long-pressing a field copies it, even when you press on a link ([#339]).
 - **Formatted event descriptions read properly.** Descriptions from Outlook, Exchange and Google Calendar are often stored as HTML, which used to show up as a wall of tags. The event view now shows them as formatted text: bold, italics, lists and links work, table rows sit on one line each, and the fonts and colours the sender picked are left out so the text matches the app. Search matches the text you see. The edit form still shows the original, so saving an event never changes its formatting ([#271]).
@@ -35,23 +16,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Create an event from shared or selected text.** Share text to Calendula, or select text in another app and pick Create event from the selection menu, and the new-event form opens with it filled in. A shared subject becomes the title, otherwise the first line does, and the rest goes into the description. The event starts at the next full hour with your default length; Calendula doesn't try to read a date out of the text. If Calendula was opened just for this, saving or closing the form takes you back to the app you came from ([#306]).
 - **Tapping an event can open the edit form.** Settings → Views → Events → Tapping an event opens can now be set to Edit form instead of Details. Taps in the views and in search then go straight to the editor for events you can edit; read-only events, reminder notifications and widgets still open the details. The editor has Duplicate, Share and Delete in its menu, and going back with unsaved changes asks whether to save, discard or keep editing ([#178]).
 - **A black theme for AMOLED screens.** Settings → Appearance → Theme now has Black next to System, Light and Dark. It's the dark theme with pure black backgrounds, which saves battery on AMOLED screens and makes event colours stand out more. Day cells and the hour grid stay a shade above black so the grid lines still show, and sheets and menus still stand out from the page. It works with Material You colours too. The home-screen widgets aren't affected ([#181]).
-- **Donate through Liberapay.** Settings → Support development now offers Liberapay for recurring donations next to Ko-fi for one-off tips.
-- **More haptic feedback.** Swiping between days in the split month pane ticks, and dropping a moved or resized event gives a short buzz ([#116]).
-
-### Changed
-- **The editor says Create for a new event.** New events, duplicates, shared text, imported .ics files and long-press drafts show Create instead of Save, so a duplicate no longer looks like you're editing the original ([#141]).
 
 ### Fixed
 - **Event colours follow the theme you picked in Calendula.** With the app set to Dark on a phone in light mode, or the other way round, events took their colours from the phone's setting, so they could come out too pale or too dark. They now match the app's theme. Starting the app with a theme set in Calendula also no longer flashes the phone's light or dark background first ([#181]).
 - **Events on the day the clocks change show at their real time.** In the day, 3-day and week views, events later on the day of a daylight saving change were drawn an hour off, so a 14:45 event showed at 15:45. They now sit at their own time. When the clocks go back, 02:00 to 03:00 happens twice: an event in that hour now stays in the right one when you move, resize or edit it, and the editor and event details add the zone, like CEST or CET, so you can tell the two apart ([#387]).
 - **The agenda always starts today.** Coming from the month or day view, the agenda used to start at the day you had open there, so "Next 30 days" could show the 1st to the 30th of the month. It now opens on today with your chosen range. Backing out of a day you opened from the agenda still returns you to where you were ([#367]).
 - **Multi-day events dim on the days already behind you.** With past events dimmed, an event running over several days stayed at full strength on its earlier days until it ended. Those days now dim in the agenda, month, week and day views ([#367]).
-- **Moving a recurring event to another calendar keeps the occurrences you changed.** Deleted occurrences used to come back after the move, and edited ones showed up twice. They now stay deleted or edited, and keep their colour.
-- **Sharing an .ics file to Calendula opens the import,** even when the email app adds a subject line as text.
-- **Rotating the phone no longer throws away an open import, duplicate or picker.**
-- **The repeat-until date picker opens on today.** Near midnight it used to open on yesterday or tomorrow.
-- **Tap ripples on week numbers, split-view day cells and the split-view handle stay inside their rounded shape** ([#413]).
-- **The export calendar picker previews the back gesture** like the other full-screen pickers.
 
 ## [2.22.5] — 2026-10-07
 
@@ -1904,19 +1874,3 @@ automatically, with zero telemetry and no internet permission.
 [#181]: https://codeberg.org/jlmakiola/calendula/issues/181
 [#306]: https://codeberg.org/jlmakiola/calendula/issues/306
 [#178]: https://codeberg.org/jlmakiola/calendula/issues/178
-[#116]: https://codeberg.org/jlmakiola/calendula/issues/116
-[#413]: https://codeberg.org/jlmakiola/calendula/issues/413
-[#71]: https://codeberg.org/jlmakiola/calendula/issues/71
-[#90]: https://codeberg.org/jlmakiola/calendula/issues/90
-[#229]: https://codeberg.org/jlmakiola/calendula/issues/229
-[#292]: https://codeberg.org/jlmakiola/calendula/issues/292
-[#372]: https://codeberg.org/jlmakiola/calendula/issues/372
-[#376]: https://codeberg.org/jlmakiola/calendula/issues/376
-[#386]: https://codeberg.org/jlmakiola/calendula/issues/386
-[#420]: https://codeberg.org/jlmakiola/calendula/issues/420
-[#435]: https://codeberg.org/jlmakiola/calendula/issues/435
-[#436]: https://codeberg.org/jlmakiola/calendula/issues/436
-[#437]: https://codeberg.org/jlmakiola/calendula/issues/437
-[#438]: https://codeberg.org/jlmakiola/calendula/issues/438
-[#439]: https://codeberg.org/jlmakiola/calendula/issues/439
-[#441]: https://codeberg.org/jlmakiola/calendula/issues/441

README.md

@@ -23,8 +23,6 @@ It works on top of the system calendar and has no network access.</p>
 <a href="https://apps.obtainium.imranr.dev/redirect?r=obtainium://add/https://codeberg.org/jlmakiola/calendula"><img src="https://github.com/ImranR98/Obtainium/blob/main/assets/graphics/badge_obtainium.png?raw=true" alt="Get it on Obtainium" height="56"></a>
 &nbsp;
 <a href="https://ko-fi.com/jeanlucmakiola"><img src="https://storage.ko-fi.com/cdn/brandasset/v2/support_me_on_kofi_badge_beige.png" alt="Support me on Ko-fi" height="56"></a>
-&nbsp;
-<a href="https://liberapay.com/Jean-Luc_Makiola/donate"><img src="https://liberapay.com/assets/widgets/donate.svg" alt="Donate using Liberapay" height="56"></a>
 </p>
 
 <p>
@@ -205,13 +203,6 @@ anywhere. Your events stay in Android's own calendar store.
 [Privacy policy](https://jeanlucmakiola.de/calendula/privacy), written in
 [`docs/PRIVACY.md`](docs/PRIVACY.md), which is what that page renders.
 
-## Support
-
-Calendula is free and has no ads. If you'd like to support its development,
-you can tip once on [Ko-fi](https://ko-fi.com/jeanlucmakiola) or donate
-regularly on [Liberapay](https://liberapay.com/Jean-Luc_Makiola/donate). Both
-are linked in the app under *Settings → Support development*.
-
 ## License
 
 [MIT](LICENSE), Jean-Luc Makiola, 2026

app/build.gradle.kts

@@ -32,8 +32,8 @@ android {
         // (up to 2.22.3: 2.22.3 -> 22203; from 2.22.4: 2.23.0-beta.1 -> 2230001,
         // 2.22.4 -> 2220499), and CI fails if the committed one doesn't match.
         // See docs/RELEASING.md.
-        versionCode = 2240002
-        versionName = "2.24.0-beta.2"
+        versionCode = 2230004
+        versionName = "2.23.0-beta.4"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -175,13 +175,9 @@ dependencies {
     implementation("de.jeanlucmakiola.floret:core-time")
     implementation("de.jeanlucmakiola.floret:core-locale")
     implementation("de.jeanlucmakiola.floret:core-crash")
-    implementation("de.jeanlucmakiola.floret:core-di")
-    implementation("de.jeanlucmakiola.floret:core-prefs")
     implementation("de.jeanlucmakiola.floret:core-reminders")
-    implementation("de.jeanlucmakiola.floret:core-android")
     implementation("de.jeanlucmakiola.floret:identity")
     implementation("de.jeanlucmakiola.floret:components")
-    implementation("de.jeanlucmakiola.floret:glance")
     implementation(libs.kotlinx.coroutines.core)
 
     debugImplementation(libs.androidx.ui.tooling)

app/src/androidTest/java/de/jeanlucmakiola/calendula/data/calendar/MoveEventExceptionsTest.kt

@@ -1,91 +0,0 @@
-package de.jeanlucmakiola.calendula.data.calendar
-
-import android.Manifest
-import android.content.ContentUris
-import android.content.ContentValues
-import android.provider.CalendarContract
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.test.rule.GrantPermissionRule
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.domain.toEditForm
-import kotlinx.datetime.TimeZone
-import org.junit.Rule
-import org.junit.Test
-import org.junit.runner.RunWith
-
-/**
- * Moving a synced series keeps its deleted and edited occurrences, although the
- * moved row has no `_sync_id` for exception rows to attach to.
- */
-@RunWith(AndroidJUnit4::class)
-class MoveEventExceptionsTest {
-
-    @get:Rule
-    val permissionRule: GrantPermissionRule = GrantPermissionRule.grant(
-        Manifest.permission.READ_CALENDAR,
-        Manifest.permission.WRITE_CALENDAR,
-    )
-
-    private val context = InstrumentationRegistry.getInstrumentation().targetContext
-    private val resolver = context.contentResolver
-    private val ds = AndroidCalendarDataSource(context)
-    private val zone = TimeZone.currentSystemDefault()
-
-    private val day = 86_400_000L
-    private val start = 1_893_492_000_000L // 2030-01-01T10:00Z
-    private val hour = 3_600_000L
-
-    /** "day offset:title" of every instance on [calendarId]. */
-    private fun occurrences(calendarId: Long): List<String> =
-        ds.instances(start - day, start + 10 * day)
-            .filter { it.calendarId == calendarId }
-            .map { "${(it.start.toEpochMilliseconds() - start) / day}:${it.title}" }
-            .sorted()
-
-    @Test
-    fun movedSeriesKeepsCancelledAndModifiedOccurrences() {
-        val a = ds.createLocalCalendar("move-test-a", 0xFF336699.toInt(), null)
-        val b = ds.createLocalCalendar("move-test-b", 0xFF993366.toInt(), null)
-        try {
-            val src = insertSyncedSeries(a)
-            ds.deleteOccurrence(src, start + 2 * day)
-            val occurrence = ds.eventDetail(src, 540)!!.toEditForm(start + 3 * day, start + 3 * day + hour, zone)
-            ds.updateOccurrence(src, start + 3 * day, occurrence, occurrence.copy(title = "edited"), 540)
-            val expected = listOf("0:series", "1:series", "3:edited", "4:series")
-            assertThat(occurrences(a)).isEqualTo(expected)
-
-            val form = ds.eventDetail(src, 540)!!.toEditForm(start, start + hour, zone)
-            ds.moveEvent(src, b, form, form, 540)
-
-            assertThat(occurrences(a)).isEmpty()
-            assertThat(occurrences(b)).isEqualTo(expected)
-        } finally {
-            ds.deleteCalendar(a)
-            ds.deleteCalendar(b)
-        }
-    }
-
-    /** A daily series carrying a `_sync_id`, so its exceptions are real exception rows. */
-    private fun insertSyncedSeries(calendarId: Long): Long {
-        val accountName = resolver.query(
-            ContentUris.withAppendedId(CalendarContract.Calendars.CONTENT_URI, calendarId),
-            arrayOf(CalendarContract.Calendars.ACCOUNT_NAME), null, null, null,
-        )!!.use { it.moveToFirst(); it.getString(0) }
-        val uri = CalendarContract.Events.CONTENT_URI.buildUpon()
-            .appendQueryParameter(CalendarContract.CALLER_IS_SYNCADAPTER, "true")
-            .appendQueryParameter(CalendarContract.Calendars.ACCOUNT_NAME, accountName)
-            .appendQueryParameter(CalendarContract.Calendars.ACCOUNT_TYPE, CalendarContract.ACCOUNT_TYPE_LOCAL)
-            .build()
-        val values = ContentValues().apply {
-            put(CalendarContract.Events.CALENDAR_ID, calendarId)
-            put(CalendarContract.Events.TITLE, "series")
-            put(CalendarContract.Events.DTSTART, start)
-            put(CalendarContract.Events.DURATION, "P3600S")
-            put(CalendarContract.Events.RRULE, "FREQ=DAILY;COUNT=5")
-            put(CalendarContract.Events.EVENT_TIMEZONE, "UTC")
-            put(CalendarContract.Events._SYNC_ID, "move-test-series")
-        }
-        return ContentUris.parseId(resolver.insert(uri, values)!!)
-    }
-}

app/src/androidTest/java/de/jeanlucmakiola/calendula/widget/month/MonthWidgetPayloadTest.kt

@@ -1,140 +0,0 @@
-package de.jeanlucmakiola.calendula.widget.month
-
-import android.Manifest
-import android.content.ContentUris
-import android.content.ContentValues
-import android.net.Uri
-import android.os.Parcel
-import android.provider.CalendarContract
-import android.util.Log
-import android.view.View
-import android.view.ViewGroup
-import android.widget.FrameLayout
-import android.widget.TextView
-import androidx.compose.ui.unit.DpSize
-import androidx.compose.ui.unit.dp
-import androidx.glance.ExperimentalGlanceApi
-import androidx.glance.appwidget.compose
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.test.rule.GrantPermissionRule
-import com.google.common.truth.Truth.assertThat
-import kotlinx.coroutines.runBlocking
-import org.junit.After
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-import org.junit.runner.RunWith
-import de.jeanlucmakiola.calendula.R
-import java.time.LocalDate
-import java.time.ZoneId
-
-/**
- * Renders the month widget for a packed month through Glance's own translator
- * (#372) and checks what one size costs on the wire: the host's binder buffer is
- * 1 MB for every widget update at once, and Exact sends one copy per size (#214).
- */
-@OptIn(ExperimentalGlanceApi::class)
-@RunWith(AndroidJUnit4::class)
-class MonthWidgetPayloadTest {
-
-    @get:Rule
-    val permissionRule: GrantPermissionRule =
-        GrantPermissionRule.grant(Manifest.permission.READ_CALENDAR, Manifest.permission.WRITE_CALENDAR)
-
-    private val instrumentation = InstrumentationRegistry.getInstrumentation()
-    private val context = instrumentation.targetContext
-    private var calendarId = -1L
-
-    private fun Uri.asSyncAdapter(): Uri = buildUpon()
-        .appendQueryParameter(CalendarContract.CALLER_IS_SYNCADAPTER, "true")
-        .appendQueryParameter(CalendarContract.Calendars.ACCOUNT_NAME, ACCOUNT)
-        .appendQueryParameter(CalendarContract.Calendars.ACCOUNT_TYPE, CalendarContract.ACCOUNT_TYPE_LOCAL)
-        .build()
-
-    @Before
-    fun packTheMonth() {
-        val calendar = ContentValues().apply {
-            put(CalendarContract.Calendars.ACCOUNT_NAME, ACCOUNT)
-            put(CalendarContract.Calendars.ACCOUNT_TYPE, CalendarContract.ACCOUNT_TYPE_LOCAL)
-            put(CalendarContract.Calendars.NAME, ACCOUNT)
-            put(CalendarContract.Calendars.CALENDAR_DISPLAY_NAME, ACCOUNT)
-            put(CalendarContract.Calendars.CALENDAR_COLOR, 0xFF3F51B5.toInt())
-            put(CalendarContract.Calendars.CALENDAR_ACCESS_LEVEL, CalendarContract.Calendars.CAL_ACCESS_OWNER)
-            put(CalendarContract.Calendars.OWNER_ACCOUNT, ACCOUNT)
-            put(CalendarContract.Calendars.VISIBLE, 1)
-            put(CalendarContract.Calendars.SYNC_EVENTS, 1)
-        }
-        val uri = context.contentResolver.insert(CalendarContract.Calendars.CONTENT_URI.asSyncAdapter(), calendar)
-        calendarId = ContentUris.parseId(requireNotNull(uri))
-
-        val zone = ZoneId.systemDefault()
-        val first = LocalDate.now(zone).withDayOfMonth(1).minusDays(7)
-        val events = (0 until 49).flatMap { offset ->
-            val day = first.plusDays(offset.toLong())
-            (0 until EVENTS_PER_DAY).map { i ->
-                val start = day.atTime(8 + i, 0).atZone(zone).toInstant().toEpochMilli()
-                ContentValues().apply {
-                    put(CalendarContract.Events.CALENDAR_ID, calendarId)
-                    put(CalendarContract.Events.TITLE, "Busy $i")
-                    put(CalendarContract.Events.DTSTART, start)
-                    put(CalendarContract.Events.DTEND, start + 30 * 60_000L)
-                    put(CalendarContract.Events.EVENT_TIMEZONE, zone.id)
-                }
-            }
-        }
-        context.contentResolver.bulkInsert(CalendarContract.Events.CONTENT_URI.asSyncAdapter(), events.toTypedArray())
-    }
-
-    @After
-    fun removeCalendar() {
-        if (calendarId < 0) return
-        context.contentResolver.delete(
-            ContentUris.withAppendedId(CalendarContract.Calendars.CONTENT_URI, calendarId).asSyncAdapter(),
-            null,
-            null,
-        )
-    }
-
-    @Test
-    fun aPackedMonthRendersWithinItsPayload() = runBlocking {
-        for (size in listOf(DpSize(250.dp, 250.dp), DpSize(320.dp, 360.dp), DpSize(420.dp, 520.dp), DpSize(600.dp, 1000.dp))) {
-            val views = MonthWidget().compose(context, size = size)
-            val bytes = Parcel.obtain().let { parcel ->
-                try {
-                    views.writeToParcel(parcel, 0)
-                    parcel.dataSize()
-                } finally {
-                    parcel.recycle()
-                }
-            }
-            var dayNumbers = 0
-            var bars = 0
-            instrumentation.runOnMainSync {
-                val root = views.apply(context, FrameLayout(context))
-                fun walk(view: View) {
-                    if (view.id in DAY_IDS && view is TextView && view.text.isNotEmpty()) dayNumbers += 1
-                    if (view.id == R.id.bar_title) bars += 1
-                    if (view is ViewGroup) for (i in 0 until view.childCount) walk(view.getChildAt(i))
-                }
-                walk(root)
-            }
-            Log.i(TAG, "size=$size bytes=$bytes days=$dayNumbers bars=$bars")
-            // The grid itself rendered, not Glance's error layout: a number in every day of every week.
-            assertThat(dayNumbers % 7).isEqualTo(0)
-            assertThat(dayNumbers).isAtLeast(28)
-            assertThat(bytes).isAtMost(MAX_BYTES_PER_SIZE)
-        }
-    }
-
-    private companion object {
-        const val TAG = "MonthWidgetPayload"
-        const val ACCOUNT = "calendula-widget-payload-test"
-        const val EVENTS_PER_DAY = 6
-
-        val DAY_IDS = setOf(R.id.day_0, R.id.day_1, R.id.day_2, R.id.day_3, R.id.day_4, R.id.day_5, R.id.day_6)
-
-        /** A quarter of the host's buffer, leaving room for a second size and every other widget. */
-        const val MAX_BYTES_PER_SIZE = 256 * 1024
-    }
-}

app/src/main/AndroidManifest.xml

@@ -152,7 +152,7 @@
             </intent-filter>
 
             <!-- Text shared or selected in another app opens a prefilled new
-                 event (MainActivity.sharedTextRequestOrNull, issue #306). -->
+                 event (MainActivity.sharedTextExtrasOrNull, issue #306). -->
             <intent-filter>
                 <action android:name="android.intent.action.SEND" />
                 <category android:name="android.intent.category.DEFAULT" />
@@ -318,16 +318,6 @@
             android:exported="false" />
 
         <!-- Home-screen widgets (Glance). Exported: the launcher/host binds them. -->
-        <activity
-            android:name=".widget.config.WidgetConfigActivity"
-            android:exported="true"
-            android:excludeFromRecents="true"
-            android:taskAffinity=""
-            android:theme="@style/Theme.Calendula.WidgetConfig">
-            <intent-filter>
-                <action android:name="android.appwidget.action.APPWIDGET_CONFIGURE" />
-            </intent-filter>
-        </activity>
         <receiver
             android:name=".widget.agenda.AgendaWidgetReceiver"
             android:label="@string/widget_agenda_label"
@@ -352,110 +342,14 @@
                 android:resource="@xml/appwidget_info_month" />
         </receiver>
 
-        <receiver
-            android:name=".widget.quickadd.QuickAddWidgetReceiver"
-            android:label="@string/widget_quick_add_label"
-            android:exported="true">
-            <intent-filter>
-                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
-            </intent-filter>
-            <meta-data
-                android:name="android.appwidget.provider"
-                android:resource="@xml/appwidget_info_quick_add" />
-        </receiver>
-
-        <receiver
-            android:name=".widget.date.DateWidgetReceiver"
-            android:label="@string/widget_date_label"
-            android:exported="true">
-            <intent-filter>
-                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
-            </intent-filter>
-            <meta-data
-                android:name="android.appwidget.provider"
-                android:resource="@xml/appwidget_info_date" />
-        </receiver>
-
-        <receiver
-            android:name=".widget.week.WeekStripWidgetReceiver"
-            android:label="@string/widget_week_strip_label"
-            android:exported="true">
-            <intent-filter>
-                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
-            </intent-filter>
-            <meta-data
-                android:name="android.appwidget.provider"
-                android:resource="@xml/appwidget_info_week_strip" />
-        </receiver>
-
-        <receiver
-            android:name=".widget.upcoming.UpcomingWidgetReceiver"
-            android:label="@string/widget_upcoming_label"
-            android:exported="true">
-            <intent-filter>
-                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
-            </intent-filter>
-            <meta-data
-                android:name="android.appwidget.provider"
-                android:resource="@xml/appwidget_info_upcoming" />
-        </receiver>
-
-        <receiver
-            android:name=".widget.today.TodayWidgetReceiver"
-            android:label="@string/widget_today_label"
-            android:exported="true">
-            <intent-filter>
-                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
-            </intent-filter>
-            <meta-data
-                android:name="android.appwidget.provider"
-                android:resource="@xml/appwidget_info_today" />
-        </receiver>
-
-        <receiver
-            android:name=".widget.countdown.CountdownWidgetReceiver"
-            android:label="@string/widget_countdown_label"
-            android:exported="true">
-            <intent-filter>
-                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
-            </intent-filter>
-            <meta-data
-                android:name="android.appwidget.provider"
-                android:resource="@xml/appwidget_info_countdown" />
-        </receiver>
-
-        <!-- A countdown widget's redraw for when its label changes (#439). -->
-        <receiver
-            android:name=".widget.WidgetTickReceiver"
-            android:exported="false" />
-
-        <receiver
-            android:name=".widget.split.MonthDayWidgetReceiver"
-            android:label="@string/widget_month_day_label"
-            android:exported="true">
-            <intent-filter>
-                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
-            </intent-filter>
-            <meta-data
-                android:name="android.appwidget.provider"
-                android:resource="@xml/appwidget_info_month_day" />
-        </receiver>
-
         <!-- Keeps both widgets fresh: the calendar provider broadcasts
-             PROVIDER_CHANGED on any data change (external sync; the app's own
-             writes redraw directly). The day boundary arrives as the app's own
-             ROLLOVER alarm (#228), by explicit PendingIntent, so it needs no
-             filter here; DATE_CHANGED is a free extra only, since Android 8+
-             withholds it from manifest receivers. TIME_SET / TIMEZONE_CHANGED
-             move the boundary, boot / package-replace wipe the alarm, and
-             LOCALE_CHANGED redraws the labels in the new language.
+             PROVIDER_CHANGED on any data change (our writes and external sync).
+             The day boundary arrives as the app's own ROLLOVER alarm (#228), by
+             explicit PendingIntent, so it needs no filter here; DATE_CHANGED is
+             a free extra only, since Android 8+ withholds it from manifest
+             receivers. The four below re-arm that alarm: TIME_SET /
+             TIMEZONE_CHANGED move the boundary, boot / package-replace wipe it.
              Exported: the system broadcasts arrive from outside the app. -->
-        <!-- The app's own redraw request (language change); not exported so
-             other apps can't trigger it. -->
-        <receiver
-            android:name=".widget.WidgetRedrawReceiver"
-            android:exported="false" />
-
         <receiver
             android:name=".widget.WidgetUpdateReceiver"
             android:exported="true">
@@ -471,7 +365,6 @@
                 <action android:name="android.intent.action.TIMEZONE_CHANGED" />
                 <action android:name="android.intent.action.BOOT_COMPLETED" />
                 <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
-                <action android:name="android.intent.action.LOCALE_CHANGED" />
             </intent-filter>
         </receiver>
 

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

@@ -10,12 +10,9 @@ import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesScheduler
 import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesSyncWorker
 import de.jeanlucmakiola.calendula.data.reminders.ReminderMaintenanceScheduler
 import de.jeanlucmakiola.calendula.data.reminders.ReminderMaintenanceWorker
-import de.jeanlucmakiola.calendula.widget.publishCalendulaWidgetPreviews
-import de.jeanlucmakiola.calendula.widget.syncWidgetRollover
-import de.jeanlucmakiola.calendula.widget.widgetEntryPoint
+import de.jeanlucmakiola.calendula.widget.WidgetRolloverScheduler
 import de.jeanlucmakiola.floret.crash.CrashConfig
 import de.jeanlucmakiola.floret.crash.CrashReporter
-import de.jeanlucmakiola.floret.locale.AppLanguage
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -46,11 +43,6 @@ class CalendulaApp : Application() {
                 chooseIssueUrl = getString(R.string.report_issue_choose_url),
             ),
         )
-        // Below API 33 only AppCompat activities get the app language; a process
-        // woken for a widget formats in it too (#90).
-        AppLanguage.applyDefault(this)
-        // Before anything that writes, so the widgets see every change (#420).
-        widgetEntryPoint().widgetRefreshCoordinator().start()
         reconcileAutoBackup()
         reconcileSpecialDates()
         reconcileCalendarVisibility()
@@ -63,12 +55,10 @@ class CalendulaApp : Application() {
      * (#228). Idempotent, and it covers what no broadcast reaches — an alarm
      * dropped by a force-stop is armed again the next time the app is opened.
      * Off the main thread: a handful of binder calls on every process start.
-     * The picker previews are republished here too, once per update.
      */
     private fun reconcileWidgetRollover() {
         CoroutineScope(SupervisorJob() + Dispatchers.Default).launch {
-            syncWidgetRollover(this@CalendulaApp)
-            publishCalendulaWidgetPreviews(this@CalendulaApp)
+            WidgetRolloverScheduler.sync(this@CalendulaApp)
         }
     }
 

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

@@ -6,7 +6,6 @@ import android.content.res.Configuration
 import android.net.Uri
 import android.os.Bundle
 import android.provider.CalendarContract
-import android.provider.OpenableColumns
 import androidx.activity.SystemBarStyle
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
@@ -30,16 +29,11 @@ import androidx.lifecycle.lifecycleScope
 import dagger.hilt.android.AndroidEntryPoint
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
-import de.jeanlucmakiola.floret.locale.AppLanguage
-import de.jeanlucmakiola.floret.prefs.ThemeMode
-import de.jeanlucmakiola.floret.prefs.isDark
-import de.jeanlucmakiola.floret.prefs.isPureBlack
+import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
 import de.jeanlucmakiola.calendula.data.prefs.is24Hour
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.buildInsertEventForm
 import de.jeanlucmakiola.calendula.domain.sharedTextOrNull
-import de.jeanlucmakiola.calendula.ui.ExternalRequests
-import de.jeanlucmakiola.calendula.ui.InsertRequest
 import de.jeanlucmakiola.calendula.ui.RootScreen
 import de.jeanlucmakiola.calendula.ui.common.LocalShowHourGrid
 import de.jeanlucmakiola.calendula.ui.common.LocalMultiDayCount
@@ -63,8 +57,6 @@ import de.jeanlucmakiola.calendula.ui.theme.WindowThemeCache
 import de.jeanlucmakiola.calendula.ui.theme.windowBackgroundRes
 import de.jeanlucmakiola.calendula.ui.theme.calendulaTypography
 import de.jeanlucmakiola.calendula.ui.theme.resolveFontFamily
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.launch
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
@@ -73,6 +65,9 @@ import kotlin.time.Clock
 import kotlin.time.Instant
 import javax.inject.Inject
 
+/** A prefilled create form from an external launch, with the source it came from. */
+private data class InsertRequest(val form: EventForm, val source: ImportSource)
+
 @AndroidEntryPoint
 class MainActivity : AppCompatActivity() {
 
@@ -84,12 +79,23 @@ class MainActivity : AppCompatActivity() {
     // picks up the in-app override instead of the night resource qualifier.
     private var systemBarsDark = false
 
-    private val requests = ExternalRequests(
-        onExternalFormClosed = {
-            insertFormOpen = false
-            if (launchedForInsert) finish()
-        },
-    )
+    // The occurrence a reminder notification was tapped for (eventId, begin,
+    // end — the detail screen's key shape). singleTop + onNewIntent route a
+    // tap into the running activity; CalendarHost consumes and clears it.
+    private var requestedDetailKey by mutableStateOf<LongArray?>(null)
+
+    // A navigation a home-screen widget asked for (open a date / start a
+    // create). Consumed once by CalendarHost, same pattern as the detail key.
+    private var requestedNav by mutableStateOf<WidgetNavRequest?>(null)
+
+    // An .ics file opened/shared into the app (ACTION_VIEW/SEND). Consumed once
+    // by CalendarHost's import flow.
+    private var requestedImportUri by mutableStateOf<Uri?>(null)
+
+    // A prefilled new-event form from an external ACTION_INSERT launch (another
+    // app/widget asking us to create an event, issue #30) or shared text (#306).
+    // Consumed once by CalendarHost, which opens it in the create form for review.
+    private var requestedInsert by mutableStateOf<InsertRequest?>(null)
 
     // Whether such a form is still open. Only then does a recreation re-read the
     // intent to bring it back; a saved or dismissed one stays closed.
@@ -99,6 +105,11 @@ class MainActivity : AppCompatActivity() {
     // app that asked instead of leaving the calendar on top of it.
     private var launchedForInsert = false
 
+    // An external "edit this event" (ACTION_EDIT on content://.../events/<id>):
+    // opens the occurrence in the edit form. Same occurrence-key shape as the
+    // detail channel; consumed once by CalendarHost.
+    private var requestedEditKey by mutableStateOf<LongArray?>(null)
+
     // A captured crash report awaiting the user's decision, surfaced as a dialog
     // over the calendar on the next launch (the single-crash path). A startup
     // crash-loop is handled out of band, before setContent — see below.
@@ -126,19 +137,16 @@ class MainActivity : AppCompatActivity() {
         // backdrop and bar icons instead of the night qualifier's (#181).
         val cachedTheme = WindowThemeCache.read(this)
         cachedTheme?.windowBackgroundRes()?.let { window.setBackgroundDrawableResource(it) }
-        systemBarsDark = (cachedTheme ?: ThemeMode.SYSTEM).isDark(systemDark)
+        systemBarsDark = when (cachedTheme) {
+            null, ThemeMode.SYSTEM -> systemDark
+            ThemeMode.LIGHT -> false
+            ThemeMode.DARK, ThemeMode.BLACK -> true
+        }
         applyEdgeToEdge()
-        val appearance = MutableStateFlow(
-            Appearance(
-                themeMode = cachedTheme ?: ThemeMode.SYSTEM,
-                dynamicColor = WindowThemeCache.readDynamicColor(this),
-            ),
-        )
         lifecycleScope.launch {
-            combine(settingsPrefs.themeMode, settingsPrefs.dynamicColor, ::Appearance).collect { stored ->
-                WindowThemeCache.write(this@MainActivity, stored.themeMode, stored.dynamicColor ?: true)
-                window.setBackgroundDrawableResource(stored.themeMode.windowBackgroundRes() ?: R.color.window_background)
-                appearance.value = stored
+            settingsPrefs.themeMode.collect { mode ->
+                WindowThemeCache.write(this@MainActivity, mode)
+                window.setBackgroundDrawableResource(mode.windowBackgroundRes() ?: R.color.window_background)
             }
         }
         // Android hands the intent that started the task back to onCreate every
@@ -154,30 +162,29 @@ class MainActivity : AppCompatActivity() {
         // is what carries one through a recreation — the create form only while
         // it's still open.
         val replaying = savedInstanceState != null || intent.isRelaunch()
-        requests.replayed = savedInstanceState != null
         if (!replaying) {
-            requests.detailKey = intent.detailKeyOrNull() ?: intent.viewEventKeyOrNull()
-            requests.editKey = intent.editEventKeyOrNull()
+            requestedDetailKey = intent.detailKeyOrNull() ?: intent.viewEventKeyOrNull()
+            requestedEditKey = intent.editEventKeyOrNull()
         }
-        requests.nav = intent.navRequestOrNull()
+        requestedNav = intent.navRequestOrNull()
             ?.takeUnless { replaying && it is WidgetNavRequest.OpenEvent }
-        requests.importUri = intent.importUriOrNull()
+        requestedImportUri = intent.importUriOrNull()
         val insertOpenBefore = savedInstanceState?.getBoolean(KEY_INSERT_FORM_OPEN) == true
-        requests.insert = intent.createRequestOrNull()?.takeIf { !replaying || insertOpenBefore }
-        insertFormOpen = requests.insert != null
+        requestedInsert = intent.createRequestOrNull()?.takeIf { !replaying || insertOpenBefore }
+        insertFormOpen = requestedInsert != null
         launchedForInsert = savedInstanceState?.getBoolean(KEY_LAUNCHED_FOR_INSERT)
-            ?: (requests.insert != null)
+            ?: (requestedInsert != null)
         if (CrashReporter.shouldPrompt(this)) pendingCrashReport = CrashReporter.pendingReport(this)
         setContent {
             // One activity-scoped SettingsViewModel drives both the theme here
             // and the Settings screen, so a theme change applies app-wide at once.
             val settingsViewModel: SettingsViewModel = hiltViewModel()
             val settings by settingsViewModel.state.collectAsStateWithLifecycle()
-            // Seeded from the cache, so the first frame doesn't draw the default
-            // theme and palette before the stored choices arrive.
-            val shownAppearance by appearance.collectAsStateWithLifecycle()
-            val themeMode = shownAppearance.themeMode
-            val darkTheme = themeMode.isDark(isSystemInDarkTheme())
+            val darkTheme = when (settings.themeMode) {
+                ThemeMode.SYSTEM -> isSystemInDarkTheme()
+                ThemeMode.LIGHT -> false
+                ThemeMode.DARK, ThemeMode.BLACK -> true
+            }
             // onCreate can only see the night resource qualifier, not the in-app
             // override — re-apply from the resolved theme so the bar icons follow
             // the app's light/dark choice.
@@ -215,8 +222,8 @@ class MainActivity : AppCompatActivity() {
             }
             CalendulaTheme(
                 darkTheme = darkTheme,
-                dynamicColor = shownAppearance.dynamicColor ?: settings.dynamicColor,
-                pureBlack = themeMode.isPureBlack,
+                dynamicColor = settings.dynamicColor,
+                pureBlack = settings.themeMode == ThemeMode.BLACK,
                 typography = typography,
             ) {
                 Box(modifier = Modifier.fillMaxSize()) {
@@ -229,7 +236,21 @@ class MainActivity : AppCompatActivity() {
                     ) {
                         RootScreen(
                             modifier = Modifier.fillMaxSize(),
-                            requests = requests,
+                            requestedDetailKey = requestedDetailKey,
+                            onDetailKeyConsumed = { requestedDetailKey = null },
+                            widgetNavRequest = requestedNav,
+                            onWidgetNavConsumed = { requestedNav = null },
+                            requestedImportUri = requestedImportUri,
+                            onImportConsumed = { requestedImportUri = null },
+                            requestedInsertForm = requestedInsert?.form,
+                            requestedInsertSource = requestedInsert?.source ?: ImportSource.Insert,
+                            onInsertConsumed = { requestedInsert = null },
+                            onExternalFormClosed = {
+                                insertFormOpen = false
+                                if (launchedForInsert) finish()
+                            },
+                            requestedEditKey = requestedEditKey,
+                            onEditKeyConsumed = { requestedEditKey = null },
                         )
                     }
                     // A persistent corner marker so a debug build is never
@@ -279,7 +300,6 @@ class MainActivity : AppCompatActivity() {
         super.onResume()
         // Reaching a running UI means startup succeeded; reset the loop trail.
         CrashReporter.markHealthy(this)
-        AppLanguage.syncMirror(this)
     }
 
     override fun onSaveInstanceState(outState: Bundle) {
@@ -290,22 +310,14 @@ class MainActivity : AppCompatActivity() {
 
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
-        requests.replayed = false
-        (intent.detailKeyOrNull() ?: intent.viewEventKeyOrNull())?.let { requests.detailKey = it }
-        intent.navRequestOrNull()?.let { requests.nav = it }
-        intent.importUriOrNull()?.let { requests.importUri = it }
+        (intent.detailKeyOrNull() ?: intent.viewEventKeyOrNull())?.let { requestedDetailKey = it }
+        intent.navRequestOrNull()?.let { requestedNav = it }
+        intent.importUriOrNull()?.let { requestedImportUri = it }
         intent.createRequestOrNull()?.let {
-            requests.insert = it
+            requestedInsert = it
             insertFormOpen = true
         }
-        intent.editEventKeyOrNull()?.let { requests.editKey = it }
-        // The user moved on into the app, so closing the create form no longer
-        // hands control back to the app that started it.
-        if (requests.detailKey != null || requests.nav != null || requests.importUri != null ||
-            requests.editKey != null
-        ) {
-            launchedForInsert = false
-        }
+        intent.editEventKeyOrNull()?.let { requestedEditKey = it }
     }
 
     /**
@@ -326,10 +338,9 @@ class MainActivity : AppCompatActivity() {
     private fun Intent.importUriOrNull(): Uri? {
         val uri = when (action) {
             Intent.ACTION_VIEW -> data
-            // Shared text is a create (#306); a text/plain file is imported only
-            // when it is calendar data, e.g. an .ics attachment labelled text/plain.
-            Intent.ACTION_SEND -> sharedStreamOrNull()
-                ?.takeUnless { type == SHARED_TEXT_TYPE && !it.isCalendarFile() }
+            // Plain text is a create (#306), never a file to import.
+            Intent.ACTION_SEND -> IntentCompat.getParcelableExtra(this, Intent.EXTRA_STREAM, Uri::class.java)
+                .takeUnless { type == SHARED_TEXT_TYPE }
             else -> null
         } ?: return null
         // The calendar "view time" Uri (a date tap) is also ACTION_VIEW/content;
@@ -383,7 +394,7 @@ class MainActivity : AppCompatActivity() {
      */
     private fun Intent.sharedTextRequestOrNull(): InsertRequest? {
         val shared = when (action) {
-            Intent.ACTION_SEND -> if (type == SHARED_TEXT_TYPE && sharedStreamOrNull()?.isCalendarFile() != true) {
+            Intent.ACTION_SEND -> if (type == SHARED_TEXT_TYPE) {
                 sharedTextOrNull(
                     subject = getCharSequenceExtra(Intent.EXTRA_SUBJECT)?.toString(),
                     text = getCharSequenceExtra(Intent.EXTRA_TEXT)?.toString(),
@@ -404,23 +415,6 @@ class MainActivity : AppCompatActivity() {
         return InsertRequest(form, ImportSource.InsertOpenEnded)
     }
 
-    private fun Intent.sharedStreamOrNull(): Uri? =
-        IntentCompat.getParcelableExtra(this, Intent.EXTRA_STREAM, Uri::class.java)
-
-    /** Whether a shared file is iCalendar/vCalendar data, by its resolved type or its name. */
-    private fun Uri.isCalendarFile(): Boolean {
-        val resolvedType = runCatching { contentResolver.getType(this) }.getOrNull()
-        if (resolvedType in CALENDAR_TYPES) return true
-        val name = when (scheme) {
-            "content" -> runCatching {
-                contentResolver.query(this, arrayOf(OpenableColumns.DISPLAY_NAME), null, null, null)
-                    ?.use { c -> if (c.moveToFirst()) c.getString(0) else null }
-            }.getOrNull()
-            else -> lastPathSegment
-        } ?: return false
-        return CALENDAR_EXTENSIONS.any { name.endsWith(it, ignoreCase = true) }
-    }
-
     /** A Long extra's value, or null when the extra is absent. */
     private fun Intent.longExtraOrNull(key: String): Long? =
         if (hasExtra(key)) getLongExtra(key, 0L) else null
@@ -547,8 +541,6 @@ class MainActivity : AppCompatActivity() {
         // ACTION_VIEW on content://com.android.calendar/time/<epochMillis>.
         private const val CALENDAR_PROVIDER_HOST = "com.android.calendar"
         private const val SHARED_TEXT_TYPE = "text/plain"
-        private val CALENDAR_TYPES = setOf("text/calendar", "text/x-vcalendar", "application/ics")
-        private val CALENDAR_EXTENSIONS = listOf(".ics", ".vcs")
         private const val KEY_INSERT_FORM_OPEN = "insert_form_open"
         private const val KEY_LAUNCHED_FOR_INSERT = "launched_for_insert"
 
@@ -595,9 +587,7 @@ class MainActivity : AppCompatActivity() {
          */
         fun openDateIntent(context: Context, date: LocalDate, source: CalendarView): Intent =
             Intent(context, MainActivity::class.java).apply {
-                // The source is part of the URI so widgets of different kinds
-                // tapping the same date don't share one PendingIntent.
-                data = "calendula://date/$date/${source.name}".toUri()
+                data = "calendula://date/$date".toUri()
                 putExtra(EXTRA_DATE_ISO, date.toString())
                 putExtra(EXTRA_SOURCE_VIEW, source.name)
                 addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
@@ -616,7 +606,6 @@ class MainActivity : AppCompatActivity() {
             endMillis: Long,
             source: CalendarView,
         ): Intent = eventDetailIntent(context, eventId, beginMillis, endMillis).apply {
-            data = "calendula://event/$eventId/$beginMillis/${source.name}".toUri()
             putExtra(EXTRA_SOURCE_VIEW, source.name)
         }
 
@@ -644,6 +633,3 @@ class MainActivity : AppCompatActivity() {
             }
     }
 }
-
-/** The theme choices the window needs before the settings screen's state loads. */
-private data class Appearance(val themeMode: ThemeMode, val dynamicColor: Boolean?)

app/src/main/java/de/jeanlucmakiola/calendula/data/backup/AutoBackup.kt

@@ -5,10 +5,12 @@ import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.PendingIntent
 import android.content.Context
+import android.content.pm.PackageManager
 import android.os.Build
 import android.util.Log
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.ContextCompat
 import androidx.core.net.toUri
 import androidx.work.CoroutineWorker
 import androidx.work.ExistingPeriodicWorkPolicy
@@ -26,7 +28,6 @@ import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.ics.IcsExporter
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
-import de.jeanlucmakiola.floret.android.hasPermission
 import kotlinx.coroutines.flow.first
 import java.util.concurrent.TimeUnit
 import kotlin.time.Clock
@@ -132,7 +133,8 @@ class BackupWorker(
 
     private fun notifyFailure(context: Context) {
         val canPost = Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU ||
-            context.hasPermission(Manifest.permission.POST_NOTIFICATIONS)
+            ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) ==
+            PackageManager.PERMISSION_GRANTED
         if (!canPost) return
         val manager = NotificationManagerCompat.from(context)
         manager.createNotificationChannel(

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

@@ -1,12 +1,13 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
-import de.jeanlucmakiola.floret.android.hasPermission
+import de.jeanlucmakiola.floret.time.toEpochMillis
 import de.jeanlucmakiola.floret.time.toKotlinInstantFromEpochMillis
 import android.Manifest
 import android.content.ContentResolver
 import android.content.ContentUris
 import android.content.ContentValues
 import android.content.Context
+import android.content.pm.PackageManager
 import android.database.ContentObserver
 import android.database.Cursor
 import android.net.Uri
@@ -14,6 +15,7 @@ import android.os.Handler
 import android.os.Looper
 import android.provider.CalendarContract
 import android.util.Log
+import androidx.core.content.ContextCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.domain.Attendee
 import de.jeanlucmakiola.calendula.domain.AttendeeRelationship
@@ -26,6 +28,7 @@ import de.jeanlucmakiola.calendula.domain.curatedForPicker
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.EventSearch
+import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.Reminder
 import de.jeanlucmakiola.calendula.domain.SearchCandidate
 import de.jeanlucmakiola.calendula.domain.contacts.MANAGED_UID_PREFIX
@@ -33,11 +36,9 @@ import de.jeanlucmakiola.calendula.domain.contacts.SpecialDateType
 import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
 import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
 import de.jeanlucmakiola.calendula.domain.ics.semanticReminderMinutes
-import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
 import de.jeanlucmakiola.calendula.domain.rruleTruncatedAt
-import de.jeanlucmakiola.calendula.domain.toEditForm
-import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toJavaLocalDate
+import java.time.Instant
 import java.time.LocalDate
 import java.time.ZoneId
 import java.time.ZoneOffset
@@ -56,10 +57,6 @@ import javax.inject.Singleton
 interface CalendarDataSource {
     fun calendars(): List<CalendarSource>
     fun instances(beginMillis: Long, endMillis: Long): List<EventInstance>
-
-    /** [instances] of event [eventId] alone, soonest first. */
-    fun eventInstances(eventId: Long, beginMillis: Long, endMillis: Long): List<EventInstance> =
-        instances(beginMillis, endMillis).filter { it.eventId == eventId }
     /**
      * [allDayReminderTimeMinutes]: the hour all-day reminders fire at, needed to
      * decode their stored offsets back to whole-day lead times (see
@@ -79,13 +76,21 @@ interface CalendarDataSource {
 
     /**
      * The event-colour palette the calendar's account publishes
-     * (`CalendarContract.Colors`, `TYPE_EVENT`), every key in provider order.
+     * (`CalendarContract.Colors`, `TYPE_EVENT`), curated for display — deduped,
+     * thinned to visually distinct swatches when oversized (CalDAV adapters
+     * publish all ~147 CSS3 names, #22) and hue-sorted; see [curatedForPicker].
      * Empty when the account exposes no palette (most local calendars, some
      * CalDAV) — the signal that a custom colour can only be written as a raw
-     * `EVENT_COLOR`, which a synced calendar may drop on its next sync. The
-     * picker shows it curated ([curatedForPicker]); matching a colour that came
-     * from outside the account runs against this full set, since those keys are
-     * all the calendar accepts.
+     * `EVENT_COLOR`, which a synced calendar may drop on its next sync.
+     */
+    fun eventColorPalette(calendarId: Long): List<EventColorOption>
+
+    /**
+     * The same palette **uncurated** — every key the account publishes, in
+     * provider order. Curation is a display concession (it folds look-alikes and
+     * drops the neutrals outright from an oversized palette), so matching a
+     * colour that came from outside the account has to run against the full set:
+     * those keys are all the calendar accepts. See [eventColorPalette].
      */
     fun publishedEventColors(calendarId: Long): List<EventColorOption>
 
@@ -233,10 +238,8 @@ interface CalendarDataSource {
      * and cancelled occurrences) to [targetCalendarId], returning the new
      * `Events._ID`. `CALENDAR_ID` is sync-adapter-owned and can't be updated in
      * place, so this is copy+delete: the row is re-inserted on the target (its
-     * `UID_2445` preserved), its reminders and editable guests copied, its
-     * exceptions turned into EXDATEs (modified ones also into standalone events,
-     * as the new row has no `_sync_id` to attach them to), the
-     * [original]→[updated] field edits applied, then the source
+     * `UID_2445` preserved), its exceptions, reminders and editable guests
+     * replayed, the [original]→[updated] field edits applied, then the source
      * deleted. The source is removed only once the copy fully succeeds; a failure
      * before that rolls the new event back, leaving the original untouched.
      * [allDayReminderTimeMinutes]: see [insertEvent].
@@ -320,7 +323,8 @@ class AndroidCalendarDataSource @Inject constructor(
     private val registeredObservers = mutableSetOf<ContentObserver>()
 
     private fun hasCalendarPermission(): Boolean =
-        context.hasPermission(Manifest.permission.READ_CALENDAR)
+        ContextCompat.checkSelfPermission(context, Manifest.permission.READ_CALENDAR) ==
+            PackageManager.PERMISSION_GRANTED
 
     /**
      * Attach any not-yet-registered observers to the provider, but only once the
@@ -354,7 +358,7 @@ class AndroidCalendarDataSource @Inject constructor(
             CalendarProjection.COLUMNS,
             null, null,
             CalendarContract.Calendars.CALENDAR_DISPLAY_NAME + " ASC",
-        )?.use { c -> c.mapRows { toCalendarSource() } } ?: emptyList()
+        )?.use { it.mapAll(::toCalendarSource) } ?: emptyList()
     }
 
     /**
@@ -371,20 +375,7 @@ class AndroidCalendarDataSource @Inject constructor(
         )
         .build()
 
-    override fun createLocalCalendar(displayName: String, color: Int, description: String?): Long =
-        insertLocalCalendar(displayName, color, "create local calendar") { putDescription(description) }
-
-    /**
-     * Insert an owned, visible, syncing calendar on the Calendula local account;
-     * [extra] adds the columns that tell the kinds apart. [what] names the write
-     * in the failure — never the calendar name, which can reach a crash report.
-     */
-    private fun insertLocalCalendar(
-        displayName: String,
-        color: Int,
-        what: String,
-        extra: ContentValues.() -> Unit,
-    ): Long {
+    override fun createLocalCalendar(displayName: String, color: Int, description: String?): Long {
         val name = displayName.trim()
         val values = ContentValues().apply {
             put(CalendarContract.Calendars.ACCOUNT_NAME, LOCAL_ACCOUNT_NAME)
@@ -400,9 +391,11 @@ class AndroidCalendarDataSource @Inject constructor(
             )
             put(CalendarContract.Calendars.VISIBLE, 1)
             put(CalendarContract.Calendars.SYNC_EVENTS, 1)
-            extra()
+            putDescription(description)
         }
-        val uri = resolver.insert(localCalendarsUri(), values) ?: throw WriteFailedException(what)
+        val uri = resolver.insert(localCalendarsUri(), values)
+            // No calendar name in the message — it can reach a crash report.
+            ?: throw WriteFailedException("create local calendar")
         return ContentUris.parseId(uri)
     }
 
@@ -467,15 +460,33 @@ class AndroidCalendarDataSource @Inject constructor(
     }
 
     override fun canWriteCalendars(): Boolean =
-        context.hasPermission(Manifest.permission.WRITE_CALENDAR)
+        ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_CALENDAR) ==
+            PackageManager.PERMISSION_GRANTED
 
-    override fun createManagedCalendar(displayName: String, color: Int, type: SpecialDateType): Long =
-        insertLocalCalendar(displayName, color, "create managed calendar") {
+    override fun createManagedCalendar(displayName: String, color: Int, type: SpecialDateType): Long {
+        val name = displayName.trim()
+        val values = ContentValues().apply {
+            put(CalendarContract.Calendars.ACCOUNT_NAME, LOCAL_ACCOUNT_NAME)
+            put(CalendarContract.Calendars.ACCOUNT_TYPE, CalendarContract.ACCOUNT_TYPE_LOCAL)
+            put(CalendarContract.Calendars.OWNER_ACCOUNT, LOCAL_ACCOUNT_NAME)
+            put(CalendarContract.Calendars.NAME, name)
+            put(CalendarContract.Calendars.CALENDAR_DISPLAY_NAME, name)
+            put(CalendarContract.Calendars.CALENDAR_COLOR, color)
+            put(
+                CalendarContract.Calendars.CALENDAR_ACCESS_LEVEL,
+                CalendarContract.Calendars.CAL_ACCESS_OWNER,
+            )
+            put(CalendarContract.Calendars.VISIBLE, 1)
+            put(CalendarContract.Calendars.SYNC_EVENTS, 1)
             // The marker that identifies this as our special-dates calendar,
             // independent of the (user-editable) display name. CAL_SYNC1 already
             // holds the description, so the marker lives in CAL_SYNC2.
             put(MANAGED_MARKER_COLUMN, markerFor(type))
         }
+        val uri = resolver.insert(localCalendarsUri(), values)
+            ?: throw WriteFailedException("create managed calendar")
+        return ContentUris.parseId(uri)
+    }
 
     override fun findManagedCalendars(): List<ManagedCalendarRow> = resolver.query(
         CalendarContract.Calendars.CONTENT_URI,
@@ -539,16 +550,22 @@ class AndroidCalendarDataSource @Inject constructor(
         // Seeded once, then never re-touched by sync — so a user who moves a
         // birthday reminder keeps their change. Encoded against the upcoming
         // occurrence, not the ancient DTSTART anchor (wrong timezone offset).
+        val anchor = Instant.ofEpochMilli(times.dtStartMillis).atZone(ZoneOffset.UTC).toLocalDate()
         insertReminderRows(
             eventId,
-            managedAllDayReminderMinutes(utcDate(times.dtStartMillis), form.reminders, allDayReminderTimeMinutes),
+            managedAllDayReminderMinutes(anchor, form.reminders, allDayReminderTimeMinutes),
         )
         return eventId
     }
 
     override fun updateManagedFields(eventId: Long, values: Map<String, Any?>) {
         if (values.isEmpty()) return
-        updateEventRow(eventId, values.toContentValues(), "update managed event id=$eventId")
+        val rows = resolver.update(
+            ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
+            values.toContentValues(),
+            null, null,
+        )
+        if (rows == 0) throw WriteFailedException("update managed event id=$eventId")
     }
 
     override fun applyManagedCalendarReminders(
@@ -556,56 +573,51 @@ class AndroidCalendarDataSource @Inject constructor(
         allDayReminderTimeMinutes: Int,
         minutes: List<Int>,
     ) {
-        // Only our own mirror events, so a stray user event in this calendar
-        // isn't all-day-re-encoded or stripped of its own reminders.
-        queryManagedEvents(calendarId).forEach { event ->
-            // Managed events are all-day: DTSTART is a UTC midnight anchor.
-            reconcileReminders(
-                event.eventId,
-                managedAllDayReminderMinutes(utcDate(event.dtStartMillis), minutes, allDayReminderTimeMinutes),
-            )
+        resolver.query(
+            CalendarContract.Events.CONTENT_URI,
+            arrayOf(CalendarContract.Events._ID, CalendarContract.Events.DTSTART),
+            // Only our own mirror events, so a stray user event in this calendar
+            // isn't all-day-re-encoded or stripped of its own reminders.
+            "${CalendarContract.Events.CALENDAR_ID} = ? AND " +
+                "${CalendarContract.Events.DELETED} = 0 AND " +
+                "${CalendarContract.Events.UID_2445} LIKE ?",
+            arrayOf(calendarId.toString(), "$MANAGED_UID_PREFIX%"),
+            null,
+        )?.use { c ->
+            while (c.moveToNext()) {
+                val eventId = c.getLong(0)
+                // Managed events are all-day: DTSTART is a UTC midnight anchor.
+                val anchor = Instant.ofEpochMilli(c.getLong(1))
+                    .atZone(ZoneOffset.UTC).toLocalDate()
+                reconcileReminders(
+                    eventId,
+                    managedAllDayReminderMinutes(anchor, minutes, allDayReminderTimeMinutes),
+                )
+            }
         }
     }
 
-    override fun instances(beginMillis: Long, endMillis: Long): List<EventInstance> =
-        queryInstances(beginMillis, endMillis, null, null)
-
-    override fun eventInstances(eventId: Long, beginMillis: Long, endMillis: Long): List<EventInstance> =
-        // The series' own rows plus its exceptions, so an occurrence edited on
-        // its own is still one of the series' occurrences.
-        queryInstances(
-            beginMillis,
-            endMillis,
-            "(${CalendarContract.Instances.EVENT_ID} = ? OR ${CalendarContract.Instances.ORIGINAL_ID} = ?)",
-            arrayOf(eventId.toString(), eventId.toString()),
-        )
-
-    private fun queryInstances(
-        beginMillis: Long,
-        endMillis: Long,
-        extraSelection: String?,
-        args: Array<String>?,
-    ): List<EventInstance> {
+    override fun instances(beginMillis: Long, endMillis: Long): List<EventInstance> {
         ensureObserversRegistered()
-        // Hide cancelled occurrences: "delete only this event" writes a
-        // cancelled exception for the one instance (#47). A cancelled event or
-        // series of its own stays, crossed out (#388), so only exception rows
-        // are filtered. A NULL status is a normal, un-cancelled event, so it
-        // must survive the filter — a bare `!= CANCELED` would drop it (NULL !=
-        // 2 is NULL, not true). DELETED = 0: a provider that soft-deletes may
-        // keep the row's instances until a purge (#364).
-        val visible = "(${CalendarContract.Instances.STATUS} IS NULL OR " +
-            "${CalendarContract.Instances.STATUS} != ${CalendarContract.Events.STATUS_CANCELED} OR " +
-            "(${CalendarContract.Instances.ORIGINAL_ID} IS NULL AND " +
-            "${CalendarContract.Instances.ORIGINAL_SYNC_ID} IS NULL)) AND " +
-            "${CalendarContract.Events.DELETED} = 0"
+        val uri = CalendarContract.Instances.CONTENT_URI.buildUpon().apply {
+            ContentUris.appendId(this, beginMillis)
+            ContentUris.appendId(this, endMillis)
+        }.build()
         return resolver.query(
-            instancesUri(beginMillis, endMillis),
+            uri,
             InstanceProjection.COLUMNS,
-            if (extraSelection == null) visible else "$visible AND $extraSelection",
-            args,
+            // Hide cancelled occurrences: "delete only this event" writes a
+            // cancelled exception for the one instance (#47). A NULL status is a
+            // normal, un-cancelled event, so it must survive the filter — a bare
+            // `!= CANCELED` would drop it (NULL != 2 is NULL, not true).
+            // DELETED = 0: a provider that soft-deletes may keep the row's
+            // instances until a purge (#364).
+            "(${CalendarContract.Instances.STATUS} IS NULL OR " +
+                "${CalendarContract.Instances.STATUS} != ${CalendarContract.Events.STATUS_CANCELED}) AND " +
+                "${CalendarContract.Events.DELETED} = 0",
+            null,
             CalendarContract.Instances.BEGIN + " ASC",
-        )?.use { c -> c.mapRowsNotNull { toEventInstance() } } ?: emptyList()
+        )?.use { c -> c.mapAllNotNull { CursorColumnReader(c).toEventInstance() } } ?: emptyList()
     }
 
     override fun searchEvents(query: String): List<SearchCandidate> {
@@ -709,9 +721,13 @@ class AndroidCalendarDataSource @Inject constructor(
         endMillis: Long,
         soonestFirst: Boolean,
     ): Pair<Long, Long>? {
+        val uri = CalendarContract.Instances.CONTENT_URI.buildUpon().apply {
+            ContentUris.appendId(this, beginMillis)
+            ContentUris.appendId(this, endMillis)
+        }.build()
         val order = CalendarContract.Instances.BEGIN + if (soonestFirst) " ASC" else " DESC"
         return resolver.query(
-            instancesUri(beginMillis, endMillis),
+            uri,
             arrayOf(CalendarContract.Instances.BEGIN, CalendarContract.Instances.END),
             "${CalendarContract.Instances.EVENT_ID} = ?",
             arrayOf(eventId.toString()),
@@ -725,7 +741,7 @@ class AndroidCalendarDataSource @Inject constructor(
         val attendees = queryAttendees(eventId)
         val reminders = queryReminders(eventId)
         return resolver.query(
-            eventUri(eventId),
+            ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
             EventDetailProjection.COLUMNS,
             null, null, null,
         )?.use { c ->
@@ -736,6 +752,9 @@ class AndroidCalendarDataSource @Inject constructor(
         }
     }
 
+    override fun eventColorPalette(calendarId: Long): List<EventColorOption> =
+        publishedEventColors(calendarId).curatedForPicker()
+
     override fun publishedEventColors(calendarId: Long): List<EventColorOption> {
         val account = calendarAccount(calendarId) ?: return emptyList()
         return resolver.query(
@@ -751,7 +770,7 @@ class AndroidCalendarDataSource @Inject constructor(
             ),
             null,
         )?.use { c ->
-            c.mapRows { EventColorOption(key = getString(0).orEmpty(), argb = getInt(1)) }
+            c.mapAll { EventColorOption(key = it.getString(0).orEmpty(), argb = it.getInt(1)) }
         }
             ?.filter { it.key.isNotEmpty() }
             ?: emptyList()
@@ -788,10 +807,11 @@ class AndroidCalendarDataSource @Inject constructor(
             null,
             CalendarContract.Events.DTSTART + " ASC",
         )?.use { c ->
-            c.mapRows {
-                val eventId = getLong(EventExportProjection.IDX_ID)
-                val calendarId = getLong(EventExportProjection.IDX_CALENDAR_ID)
-                toIcsEvent(
+            c.mapAll {
+                val reader = CursorColumnReader(c)
+                val eventId = reader.getLong(EventExportProjection.IDX_ID)
+                val calendarId = reader.getLong(EventExportProjection.IDX_CALENDAR_ID)
+                reader.toIcsEvent(
                     reminderMinutes = queryReminders(eventId).map { it.minutes },
                     calendarName = names[calendarId],
                     allDayReminderTimeMinutes = allDayReminderTimeMinutes,
@@ -826,7 +846,7 @@ class AndroidCalendarDataSource @Inject constructor(
             calendarId = calendarId,
             // Preserve the file's UID so a re-import dedups against it; mint one
             // only when the source event carried none.
-            uid = event.uid?.takeIf { it.isNotBlank() } ?: mintUid(),
+            uid = event.uid?.takeIf { it.isNotBlank() } ?: "${UUID.randomUUID()}@calendula",
             palette = colorPalette,
         )
         val uri = resolver.insert(CalendarContract.Events.CONTENT_URI, values.toContentValues())
@@ -839,7 +859,8 @@ class AndroidCalendarDataSource @Inject constructor(
         // (see [importedAllDayReminderDate]).
         val reminderDate = if (event.isAllDay) {
             importedAllDayReminderDate(
-                startDate = utcDate(event.start.toEpochMilliseconds()),
+                startDate = Instant.ofEpochMilli(event.start.toEpochMilliseconds())
+                    .atZone(ZoneOffset.UTC).toLocalDate(),
                 recurrenceRule = event.recurrenceRule,
                 today = LocalDate.now(zone),
             )
@@ -857,7 +878,24 @@ class AndroidCalendarDataSource @Inject constructor(
             } else {
                 minutes
             }
-            insertReminderRow(eventId, providerMinutes)
+            val reminder = ContentValues().apply {
+                put(CalendarContract.Reminders.EVENT_ID, eventId)
+                put(CalendarContract.Reminders.MINUTES, providerMinutes)
+                put(CalendarContract.Reminders.METHOD, CalendarContract.Reminders.METHOD_ALERT)
+            }
+            // The event row is already in. A reminder that won't attach costs
+            // that one alarm, not the event: throwing here would have the import
+            // count an event it did create as failed, and the retry would then
+            // skip it as a duplicate.
+            val attached = try {
+                resolver.insert(CalendarContract.Reminders.CONTENT_URI, reminder)
+            } catch (e: Exception) {
+                Log.w(TAG, "Reminder insert threw for imported event $eventId", e)
+                null
+            }
+            if (attached == null) {
+                Log.w(TAG, "Failed to attach reminder ($minutes min) to imported event $eventId")
+            }
         }
         return eventId
     }
@@ -913,13 +951,18 @@ class AndroidCalendarDataSource @Inject constructor(
         // back to a stable synthesised UID at export time (deriveIcsUid).
         val values = buildEventInsertValues(
             form,
-            uid = mintUid(),
+            uid = "${UUID.randomUUID()}@calendula",
             times = form.toWriteTimes(ZoneId.systemDefault()),
-        ) + eventColorColumns(form.colorKey, form.color)
-            // A new row has nothing to clear: unset columns inherit the
-            // calendar's colour, so only the key/raw values are written.
-            .filterValues { it != null }
-        val uri = resolver.insert(CalendarContract.Events.CONTENT_URI, values.toContentValues())
+        ).toContentValues().apply {
+            // A null colour just leaves both columns unset (the event inherits
+            // its calendar's colour), so only the key/raw cases are written.
+            when {
+                form.colorKey != null ->
+                    put(CalendarContract.Events.EVENT_COLOR_KEY, form.colorKey)
+                form.color != null -> put(CalendarContract.Events.EVENT_COLOR, form.color)
+            }
+        }
+        val uri = resolver.insert(CalendarContract.Events.CONTENT_URI, values)
             ?: throw WriteFailedException("insert event into calendar id=${form.calendarId}")
         val eventId = ContentUris.parseId(uri)
         seedReminders(eventId, form, allDayReminderTimeMinutes)
@@ -940,32 +983,16 @@ class AndroidCalendarDataSource @Inject constructor(
 
     /** Insert one `METHOD_ALERT` reminder row per raw provider offset. */
     private fun insertReminderRows(eventId: Long, encodedMinutes: List<Int>) {
-        encodedMinutes.forEach { insertReminderRow(eventId, it) }
-    }
-
-    /**
-     * Best effort: the event row is already in, so a reminder that won't attach
-     * costs that one alarm, not the event. Throwing would report an event that
-     * was created as failed — and an import retry would then skip it as a
-     * duplicate.
-     */
-    private fun insertReminderRow(
-        eventId: Long,
-        minutes: Int,
-        method: Int = CalendarContract.Reminders.METHOD_ALERT,
-    ) {
-        val reminder = ContentValues().apply {
-            put(CalendarContract.Reminders.EVENT_ID, eventId)
-            put(CalendarContract.Reminders.MINUTES, minutes)
-            put(CalendarContract.Reminders.METHOD, method)
+        encodedMinutes.forEach { minutes ->
+            val reminder = ContentValues().apply {
+                put(CalendarContract.Reminders.EVENT_ID, eventId)
+                put(CalendarContract.Reminders.MINUTES, minutes)
+                put(CalendarContract.Reminders.METHOD, CalendarContract.Reminders.METHOD_ALERT)
+            }
+            if (resolver.insert(CalendarContract.Reminders.CONTENT_URI, reminder) == null) {
+                Log.w(TAG, "Failed to attach reminder ($minutes min) to event $eventId")
+            }
         }
-        val attached = try {
-            resolver.insert(CalendarContract.Reminders.CONTENT_URI, reminder)
-        } catch (e: Exception) {
-            Log.w(TAG, "Reminder insert threw for event $eventId", e)
-            null
-        }
-        if (attached == null) Log.w(TAG, "Failed to attach reminder ($minutes min) to event $eventId")
     }
 
     /**
@@ -1002,7 +1029,12 @@ class AndroidCalendarDataSource @Inject constructor(
             zone = ZoneId.systemDefault(),
         )
         if (values.isNotEmpty()) {
-            updateEventRow(eventId, values.toContentValues(), "update event id=$eventId")
+            val rows = resolver.update(
+                ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
+                values.toContentValues(),
+                null, null,
+            )
+            if (rows == 0) throw WriteFailedException("update event id=$eventId")
         }
         // Untouched reminder sets are left alone so unrelated edits can't
         // disturb provider rows the form never knew about. The diff is on the
@@ -1035,17 +1067,16 @@ class AndroidCalendarDataSource @Inject constructor(
             ?: throw WriteFailedException("read event to move id=$eventId")
         // Keep the source UID so an .ics backup dedups and a sync adapter can
         // recognise the moved event; mint one only if the source carried none.
-        val uid = master.uid?.takeIf { it.isNotEmpty() } ?: mintUid()
+        val uid = master.uid?.takeIf { it.isNotEmpty() } ?: "${UUID.randomUUID()}@calendula"
         val newEventId = resolver.insert(
             CalendarContract.Events.CONTENT_URI,
             buildMovedMasterValues(master.event, targetCalendarId, uid).toContentValues(),
         )?.let(ContentUris::parseId)
             ?: throw WriteFailedException("insert moved event into calendar id=$targetCalendarId")
-        val detached = mutableListOf<Long>()
         try {
             copyReminderRows(fromEventId = eventId, toEventId = newEventId)
             insertAttendees(newEventId, editableAttendees(eventId))
-            copyExceptions(eventId, newEventId, targetCalendarId, allDayReminderTimeMinutes, detached)
+            copyExceptions(fromEventId = eventId, toEventId = newEventId)
             // Apply the user's field edits exactly as a same-calendar "all
             // events" save would: the moved master carries the source's values,
             // so the dirty diff against [original] writes only what changed
@@ -1055,7 +1086,6 @@ class AndroidCalendarDataSource @Inject constructor(
             // Undo the partial copy so a failed move leaves nothing behind; the
             // source is still intact (it's deleted only past this point).
             runCatching { deleteEvent(newEventId) }
-            detached.forEach(::rollBackDetached)
             throw t
         }
         deleteEvent(eventId)
@@ -1064,7 +1094,7 @@ class AndroidCalendarDataSource @Inject constructor(
 
     /** The master row of the event to move, as a verbatim-insert snapshot. */
     private fun queryMoveMaster(eventId: Long): MoveMaster? = resolver.query(
-        eventUri(eventId),
+        ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
         MoveMasterProjection.COLUMNS,
         null, null, null,
     )?.use { c ->
@@ -1076,7 +1106,8 @@ class AndroidCalendarDataSource @Inject constructor(
                 title = r.getString(MoveMasterProjection.IDX_TITLE).orEmpty(),
                 isAllDay = r.getInt(MoveMasterProjection.IDX_ALL_DAY) != 0,
                 dtStartMillis = r.getLong(MoveMasterProjection.IDX_DTSTART),
-                dtEndMillis = r.getLongOrNull(MoveMasterProjection.IDX_DTEND),
+                dtEndMillis = r.getLong(MoveMasterProjection.IDX_DTEND)
+                    .takeUnless { r.isNull(MoveMasterProjection.IDX_DTEND) },
                 duration = r.getString(MoveMasterProjection.IDX_DURATION),
                 rrule = r.getString(MoveMasterProjection.IDX_RRULE)?.takeIf { it.isNotBlank() },
                 rdate = r.getString(MoveMasterProjection.IDX_RDATE),
@@ -1084,7 +1115,8 @@ class AndroidCalendarDataSource @Inject constructor(
                 timezone = r.getString(MoveMasterProjection.IDX_EVENT_TIMEZONE),
                 availability = r.getInt(MoveMasterProjection.IDX_AVAILABILITY),
                 accessLevel = r.getInt(MoveMasterProjection.IDX_ACCESS_LEVEL),
-                status = r.getIntOrNull(MoveMasterProjection.IDX_STATUS),
+                status = r.getInt(MoveMasterProjection.IDX_STATUS)
+                    .takeUnless { r.isNull(MoveMasterProjection.IDX_STATUS) },
                 location = r.getString(MoveMasterProjection.IDX_LOCATION),
                 description = r.getString(MoveMasterProjection.IDX_DESCRIPTION),
             ),
@@ -1101,7 +1133,16 @@ class AndroidCalendarDataSource @Inject constructor(
         arrayOf(fromEventId.toString()),
         null,
     )?.use { c ->
-        while (c.moveToNext()) insertReminderRow(toEventId, minutes = c.getInt(0), method = c.getInt(1))
+        while (c.moveToNext()) {
+            val values = ContentValues().apply {
+                put(CalendarContract.Reminders.EVENT_ID, toEventId)
+                put(CalendarContract.Reminders.MINUTES, c.getInt(0))
+                put(CalendarContract.Reminders.METHOD, c.getInt(1))
+            }
+            if (resolver.insert(CalendarContract.Reminders.CONTENT_URI, values) == null) {
+                Log.w(TAG, "Failed to copy a reminder to moved event $toEventId")
+            }
+        }
     } ?: Unit
 
     /**
@@ -1121,33 +1162,44 @@ class AndroidCalendarDataSource @Inject constructor(
         }
 
     /**
-     * Carry every exception of the series [fromEventId] over to the moved series
-     * [toEventId]. The moved row has no `_sync_id` yet, so exception rows would
-     * never attach to it ([deleteOccurrence], [detachOccurrence]): a cancelled
-     * occurrence becomes an EXDATE, a modified one an EXDATE plus a standalone
-     * event on [targetCalendarId], its id added to [detached] for rollback.
+     * Replay every exception of the series [fromEventId] against the moved series
+     * [toEventId]. The copy preserved the recurrence skeleton, so each occurrence
+     * time still resolves: a cancelled occurrence is re-hidden with a cancelled
+     * exception, a modified one is re-inserted with its fields (then its reminders
+     * reconciled and editable guests copied). No-op for a non-recurring event.
      */
-    private fun copyExceptions(
-        fromEventId: Long,
-        toEventId: Long,
-        targetCalendarId: Long,
-        allDayReminderTimeMinutes: Int,
-        detached: MutableList<Long>,
-    ) {
-        val exceptions = queryExceptionRows(fromEventId)
-        if (exceptions.isEmpty()) return
-        val zone = TimeZone.currentSystemDefault()
-        exceptions.filterNot { it.isCancelled }.forEach { ex ->
-            val detail = eventDetail(ex.exceptionEventId, allDayReminderTimeMinutes)
-                ?: throw WriteFailedException("read modified occurrence id=${ex.exceptionEventId}")
-            val endMillis = ex.dtEndMillis ?: (ex.dtStartMillis + parseRfc2445DurationMillis(ex.duration))
-            val form = detail.toEditForm(ex.dtStartMillis, endMillis, zone)
-                .copy(calendarId = targetCalendarId, colorKey = null)
-                .toDetachedOccurrence()
-            detached += insertEvent(form, allDayReminderTimeMinutes)
+    private fun copyExceptions(fromEventId: Long, toEventId: Long) {
+        queryExceptionRows(fromEventId).forEach { ex ->
+            if (ex.isCancelled) {
+                val values = ContentValues().apply {
+                    put(CalendarContract.Events.ORIGINAL_INSTANCE_TIME, ex.originalInstanceMillis)
+                    put(CalendarContract.Events.STATUS, CalendarContract.Events.STATUS_CANCELED)
+                }
+                resolver.insert(
+                    ContentUris.withAppendedId(
+                        CalendarContract.Events.CONTENT_EXCEPTION_URI, toEventId,
+                    ),
+                    values,
+                ) ?: throw WriteFailedException("copy cancelled occurrence to event id=$toEventId")
+            } else {
+                val uri = resolver.insert(
+                    ContentUris.withAppendedId(
+                        CalendarContract.Events.CONTENT_EXCEPTION_URI, toEventId,
+                    ),
+                    buildCopiedExceptionValues(ex).toContentValues(),
+                ) ?: throw WriteFailedException("copy modified occurrence to event id=$toEventId")
+                val newExceptionId = ContentUris.parseId(uri)
+                // The provider may clone the parent's reminders onto the new
+                // exception; reconcile to the source exception's exact set so
+                // they neither double nor drop. Same DTSTART → same all-day
+                // encoding, so the stored offsets match directly.
+                reconcileReminders(
+                    newExceptionId,
+                    queryReminders(ex.exceptionEventId).map { it.minutes },
+                )
+                insertAttendees(newExceptionId, editableAttendees(ex.exceptionEventId))
+            }
         }
-        val values = querySeriesRow(toEventId).exdateValues(exceptions.map { it.originalInstanceMillis })
-        updateEventRow(toEventId, values, "exdate moved exceptions event id=$toEventId")
     }
 
     /** The series' exception rows (modified + cancelled), oldest occurrence first. */
@@ -1158,14 +1210,26 @@ class AndroidCalendarDataSource @Inject constructor(
         arrayOf(seriesEventId.toString()),
         CalendarContract.Events.ORIGINAL_INSTANCE_TIME + " ASC",
     )?.use { c ->
-        c.mapRows {
+        c.mapAll {
+            val r = CursorColumnReader(c)
+            val status = r.getInt(ExceptionProjection.IDX_STATUS)
+                .takeUnless { r.isNull(ExceptionProjection.IDX_STATUS) }
             ExceptionRowSnapshot(
-                exceptionEventId = getLong(ExceptionProjection.IDX_ID),
-                originalInstanceMillis = getLong(ExceptionProjection.IDX_ORIGINAL_INSTANCE_TIME),
-                isCancelled = getIntOrNull(ExceptionProjection.IDX_STATUS) == CalendarContract.Events.STATUS_CANCELED,
-                dtStartMillis = getLong(ExceptionProjection.IDX_DTSTART),
-                dtEndMillis = getLongOrNull(ExceptionProjection.IDX_DTEND),
-                duration = getString(ExceptionProjection.IDX_DURATION),
+                exceptionEventId = r.getLong(ExceptionProjection.IDX_ID),
+                originalInstanceMillis = r.getLong(ExceptionProjection.IDX_ORIGINAL_INSTANCE_TIME),
+                isCancelled = status == CalendarContract.Events.STATUS_CANCELED,
+                status = status,
+                title = r.getString(ExceptionProjection.IDX_TITLE).orEmpty(),
+                isAllDay = r.getInt(ExceptionProjection.IDX_ALL_DAY) != 0,
+                dtStartMillis = r.getLong(ExceptionProjection.IDX_DTSTART),
+                dtEndMillis = r.getLong(ExceptionProjection.IDX_DTEND)
+                    .takeUnless { r.isNull(ExceptionProjection.IDX_DTEND) },
+                duration = r.getString(ExceptionProjection.IDX_DURATION),
+                timezone = r.getString(ExceptionProjection.IDX_EVENT_TIMEZONE),
+                availability = r.getInt(ExceptionProjection.IDX_AVAILABILITY),
+                accessLevel = r.getInt(ExceptionProjection.IDX_ACCESS_LEVEL),
+                location = r.getString(ExceptionProjection.IDX_LOCATION),
+                description = r.getString(ExceptionProjection.IDX_DESCRIPTION),
             )
         }
     } ?: emptyList()
@@ -1202,7 +1266,7 @@ class AndroidCalendarDataSource @Inject constructor(
         val exceptionId = ContentUris.parseId(uri)
         form.colorKey?.let { key ->
             resolver.update(
-                eventUri(exceptionId),
+                ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, exceptionId),
                 ContentValues().apply { put(CalendarContract.Events.EVENT_COLOR_KEY, key) },
                 null, null,
             )
@@ -1256,19 +1320,34 @@ class AndroidCalendarDataSource @Inject constructor(
         // a fresh UID — the detached row is a separate event now, and sharing the
         // parent's would collide with it in .ics restore dedup.
         val detachedId = insertEvent(form.toDetachedOccurrence(), allDayReminderTimeMinutes)
+        val values = buildOccurrenceExdateValues(
+            existingExdate = row.exdate,
+            occurrenceMillis = beginMillis,
+            dtStartMillis = row.dtStartMillis,
+            rrule = row.rrule,
+            rdate = row.rdate,
+            duration = row.duration,
+            timezone = row.timezone,
+            allDay = row.allDay,
+        )
         // Rows touched, not occurrences excluded — 1 whenever the series row still
         // exists. It catches the row disappearing under us, not an EXDATE the
         // provider's expansion fails to match.
-        try {
-            updateEventRow(
-                eventId,
-                row.exdateValues(listOf(beginMillis)),
-                "exdate occurrence for edit, event id=$eventId begin=$beginMillis",
+        val updatedRows = try {
+            resolver.update(
+                ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
+                values.toContentValues(), null, null,
             )
         } catch (t: Throwable) {
             rollBackDetached(detachedId)
             throw t
         }
+        if (updatedRows == 0) {
+            rollBackDetached(detachedId)
+            throw WriteFailedException(
+                "exdate occurrence for edit, event id=$eventId begin=$beginMillis",
+            )
+        }
         return detachedId
     }
 
@@ -1341,11 +1420,23 @@ class AndroidCalendarDataSource @Inject constructor(
             updated = updated,
             zone = ZoneId.systemDefault(),
         ) ?: return
-        val values = querySeriesRow(newEventId).timeColumns().apply {
+        val row = querySeriesRow(newEventId)
+        val values = ContentValues().apply {
             put(CalendarContract.Events.EXDATE, carried)
+            put(CalendarContract.Events.DTSTART, row.dtStartMillis)
+            put(CalendarContract.Events.RRULE, row.rrule)
+            put(CalendarContract.Events.DURATION, row.duration)
+            put(CalendarContract.Events.EVENT_TIMEZONE, row.timezone)
+            put(CalendarContract.Events.ALL_DAY, row.allDay)
         }
         try {
-            updateEventRow(newEventId, values, "carry exdate onto split series id=$newEventId")
+            val rows = resolver.update(
+                ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, newEventId),
+                values, null, null,
+            )
+            if (rows == 0) {
+                throw WriteFailedException("carry exdate onto split series id=$newEventId")
+            }
         } catch (t: Throwable) {
             runCatching { deleteEvent(newEventId) }
             throw t
@@ -1373,18 +1464,29 @@ class AndroidCalendarDataSource @Inject constructor(
      */
     private fun truncateSeries(eventId: Long, row: SeriesRow, beginMillis: Long) {
         requireNotNull(row.rrule) { "truncateSeries needs a recurring row" }
-        val values = row.timeColumns().apply {
+        val values = ContentValues().apply {
+            put(CalendarContract.Events.DTSTART, row.dtStartMillis)
+            put(CalendarContract.Events.DURATION, row.duration)
+            put(CalendarContract.Events.EVENT_TIMEZONE, row.timezone)
+            put(CalendarContract.Events.ALL_DAY, row.allDay)
             put(
                 CalendarContract.Events.RRULE,
                 rruleTruncatedAt(row.rrule, untilUtcMillis = row.truncationCutoff(beginMillis)),
             )
         }
-        updateEventRow(eventId, values, "truncate series event id=$eventId begin=$beginMillis")
+        val rows = resolver.update(
+            ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
+            values,
+            null, null,
+        )
+        if (rows == 0) {
+            throw WriteFailedException("truncate series event id=$eventId begin=$beginMillis")
+        }
     }
 
     /** The series anchor: every time-related column of the Events row. */
     private fun querySeriesRow(eventId: Long): SeriesRow = resolver.query(
-        eventUri(eventId),
+        ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
         arrayOf(
             CalendarContract.Events.DTSTART,
             CalendarContract.Events.RRULE,
@@ -1432,30 +1534,6 @@ class AndroidCalendarDataSource @Inject constructor(
          */
         val recurs: Boolean get() = !rrule.isNullOrBlank() || !rdate.isNullOrBlank()
 
-        /**
-         * The time/recurrence set a series write carries together: the provider
-         * re-expands instances only from what the update itself holds.
-         */
-        fun timeColumns(): ContentValues = ContentValues().apply {
-            put(CalendarContract.Events.DTSTART, dtStartMillis)
-            put(CalendarContract.Events.RRULE, rrule)
-            put(CalendarContract.Events.DURATION, duration)
-            put(CalendarContract.Events.EVENT_TIMEZONE, timezone)
-            put(CalendarContract.Events.ALL_DAY, allDay)
-        }
-
-        /** This row's columns with [occurrences] added to EXDATE ([buildOccurrencesExdateValues]). */
-        fun exdateValues(occurrences: List<Long>): Map<String, Any?> = buildOccurrencesExdateValues(
-            existingExdate = exdate,
-            occurrences = occurrences,
-            dtStartMillis = dtStartMillis,
-            rrule = rrule,
-            rdate = rdate,
-            duration = duration,
-            timezone = timezone,
-            allDay = allDay,
-        )
-
         /** UNTIL cutoff for ending the series before the occurrence at [beginMillis]. */
         fun truncationCutoff(beginMillis: Long): Long = previousLocalDayEndUtcMillis(
             beginMillis = beginMillis,
@@ -1481,10 +1559,20 @@ class AndroidCalendarDataSource @Inject constructor(
                 arrayOf(eventId.toString(), minutes.toString()),
             )
         }
-        insertReminderRows(eventId, (target - existing).toList())
+        (target - existing).forEach { minutes ->
+            val reminder = ContentValues().apply {
+                put(CalendarContract.Reminders.EVENT_ID, eventId)
+                put(CalendarContract.Reminders.MINUTES, minutes)
+                put(CalendarContract.Reminders.METHOD, CalendarContract.Reminders.METHOD_ALERT)
+            }
+            if (resolver.insert(CalendarContract.Reminders.CONTENT_URI, reminder) == null) {
+                Log.w(TAG, "Failed to attach reminder ($minutes min) to event $eventId")
+            }
+        }
     }
 
-    private fun EventAttendee.key(): String = emailKey(email)
+    /** Normalised key an attendee is matched/deduped on (case-insensitive email). */
+    private fun EventAttendee.key(): String = email.trim().lowercase()
 
     /** Distinct guests by email; blanks dropped (we key and write on the address). */
     private fun List<EventAttendee>.distinctByEmail(): List<EventAttendee> {
@@ -1536,7 +1624,7 @@ class AndroidCalendarDataSource @Inject constructor(
         val relationship: Int,
         val type: Int,
     ) {
-        val key: String get() = emailKey(email)
+        val key: String get() = email.trim().lowercase()
     }
 
     private fun queryAttendeeRows(eventId: Long): List<AttendeeRow> = resolver.query(
@@ -1601,20 +1689,17 @@ class AndroidCalendarDataSource @Inject constructor(
                 )
             }
         }
-        insertAttendees(eventId, target.filterNot { it.key() in editableKeys })
+        target.filterNot { it.key() in editableKeys }.forEach { attendee ->
+            if (resolver.insert(
+                    CalendarContract.Attendees.CONTENT_URI,
+                    attendeeValues(eventId, attendee),
+                ) == null
+            ) {
+                Log.w(TAG, "Failed to attach a guest to event $eventId")
+            }
+        }
     }
 
-    private fun eventUri(eventId: Long): Uri =
-        ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId)
-
-    /** Update the Events row [eventId]; [what] names the write when no row was touched. */
-    private fun updateEventRow(eventId: Long, values: ContentValues, what: String) {
-        if (resolver.update(eventUri(eventId), values, null, null) == 0) throw WriteFailedException(what)
-    }
-
-    private fun updateEventRow(eventId: Long, values: Map<String, Any?>, what: String) =
-        updateEventRow(eventId, values.toContentValues(), what)
-
     private fun Map<String, Any?>.toContentValues(): ContentValues =
         ContentValues().also { cv ->
             forEach { (column, value) ->
@@ -1631,7 +1716,7 @@ class AndroidCalendarDataSource @Inject constructor(
 
     override fun deleteEvent(eventId: Long) {
         val deleted = resolver.delete(
-            eventUri(eventId),
+            ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
             null, null,
         )
         if (deleted == 0) throw WriteFailedException("delete event id=$eventId")
@@ -1653,11 +1738,23 @@ class AndroidCalendarDataSource @Inject constructor(
             // occurrence with it (#47 on a local calendar). EXDATE needs no link.
             // Calendula's own contact special-date calendars are local and hold
             // yearly series, so this path is reached in normal use.
-            updateEventRow(
-                eventId,
-                row.exdateValues(listOf(beginMillis)),
-                "exdate occurrence event id=$eventId begin=$beginMillis",
+            val values = buildOccurrenceExdateValues(
+                existingExdate = row.exdate,
+                occurrenceMillis = beginMillis,
+                dtStartMillis = row.dtStartMillis,
+                rrule = row.rrule,
+                rdate = row.rdate,
+                duration = row.duration,
+                timezone = row.timezone,
+                allDay = row.allDay,
             )
+            val updated = resolver.update(
+                ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
+                values.toContentValues(), null, null,
+            )
+            if (updated == 0) {
+                throw WriteFailedException("exdate occurrence event id=$eventId begin=$beginMillis")
+            }
             return
         }
         // A cancelled exception row hides exactly this occurrence; the sync
@@ -1707,7 +1804,7 @@ class AndroidCalendarDataSource @Inject constructor(
         CalendarContract.Attendees.EVENT_ID + " = ?",
         arrayOf(eventId.toString()),
         null,
-    )?.use { c -> c.mapRows { toAttendee() } } ?: emptyList()
+    )?.use { c -> c.mapAll { CursorColumnReader(c).toAttendee() } } ?: emptyList()
 
     private fun queryReminders(eventId: Long): List<Reminder> = resolver.query(
         CalendarContract.Reminders.CONTENT_URI,
@@ -1715,10 +1812,19 @@ class AndroidCalendarDataSource @Inject constructor(
         CalendarContract.Reminders.EVENT_ID + " = ?",
         arrayOf(eventId.toString()),
         null,
-    )?.use { c -> c.mapRows { toReminder() } } ?: emptyList()
+    )?.use { c -> c.mapAll { CursorColumnReader(c).toReminder() } } ?: emptyList()
 
-    /** A fresh globally-unique `UID_2445`, for an event that carries none of its own. */
-    private fun mintUid(): String = "${UUID.randomUUID()}@calendula"
+    private fun toCalendarSource(c: Cursor): CalendarSource = CursorColumnReader(c).toCalendarSource()
+
+    /** Iterate every row and map; skips nothing. */
+    private inline fun <T> Cursor.mapAll(mapper: (Cursor) -> T): List<T> = buildList {
+        while (moveToNext()) add(mapper(this@mapAll))
+    }
+
+    /** Iterate every row and map; drops nulls. */
+    private inline fun <T : Any> Cursor.mapAllNotNull(mapper: (Cursor) -> T?): List<T> = buildList {
+        while (moveToNext()) mapper(this@mapAllNotNull)?.let(::add)
+    }
 
     /** The `CAL_SYNC2` marker value identifying a managed calendar's [type]. */
     private fun markerFor(type: SpecialDateType): String = when (type) {
@@ -1734,9 +1840,6 @@ class AndroidCalendarDataSource @Inject constructor(
     private companion object {
         const val TAG = "CalendarDataSource"
 
-        /** Normalised key an attendee is matched/deduped on (case-insensitive email). */
-        fun emailKey(email: String): String = email.trim().lowercase()
-
         /**
          * Shared account for every app-created local calendar, so they group
          * together (by account) in the filter sheet and calendar manager.

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

@@ -10,22 +10,14 @@ import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
 import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
 import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.emptyFlow
 import kotlin.time.Instant
 
 interface CalendarRepository {
     fun calendars(): Flow<List<CalendarSource>>
     fun instances(range: ClosedRange<Instant>): Flow<List<EventInstance>>
 
-    /** One read of event [eventId]'s occurrences overlapping [range], soonest first, whatever calendar it is in. */
-    suspend fun eventOccurrences(eventId: Long, range: ClosedRange<Instant>): List<EventInstance>
-
     /** Re-query every open [calendars] / [instances] flow. */
     fun refresh()
-
-    /** Emits on the app's own writes and visibility changes; not on provider notifications or [refresh]. */
-    val localChanges: Flow<Unit>
-
     suspend fun eventDetail(eventId: Long): EventDetail
 
     /**
@@ -37,7 +29,7 @@ interface CalendarRepository {
 
     /**
      * The event-colour palette a calendar's account publishes; empty when it
-     * exposes none (see [CalendarDataSource.publishedEventColors]).
+     * exposes none (see [CalendarDataSource.eventColorPalette]).
      */
     suspend fun eventColorPalette(calendarId: Long): List<EventColorOption>
 
@@ -109,12 +101,6 @@ interface CalendarRepository {
         form: EventForm,
     ): Long
 
-    /**
-     * Every series split the app makes ([updateEventFromOccurrence]), so what
-     * follows a series by id can move on to the part that continues it.
-     */
-    val seriesSplits: Flow<SeriesSplit> get() = emptyFlow()
-
     /**
      * Change a recurring event from [beginMillis] onwards (series split);
      * returns the new event's `Events._ID`.
@@ -142,6 +128,3 @@ class NoSuchEventException(eventId: Long) :
 /** A ContentResolver write affected no rows or returned no URI. */
 class WriteFailedException(operation: String) :
     RuntimeException("Calendar write failed: $operation")
-
-/** A "this and following" edit: [oldEventId] now ends where [newEventId] picks up. */
-data class SeriesSplit(val oldEventId: Long, val newEventId: Long)

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

@@ -1,11 +1,10 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
 import android.util.Log
-import de.jeanlucmakiola.floret.di.IoDispatcher
 import de.jeanlucmakiola.floret.time.toEpochMillis
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
-import de.jeanlucmakiola.calendula.domain.curatedForPicker
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventDetail
@@ -78,28 +77,15 @@ class CalendarRepositoryImpl @Inject constructor(
         ticks.tryEmit(Unit)
     }
 
-    private val writes = MutableSharedFlow<Unit>(
-        replay = 0,
-        extraBufferCapacity = 1,
-        onBufferOverflow = BufferOverflow.DROP_OLDEST,
-    )
-
     /** Run a provider write on [io], then re-query whether or not it threw. */
     private suspend fun <T> write(block: suspend () -> T): T = withContext(io) {
         try {
             block()
         } finally {
             refresh()
-            writes.tryEmit(Unit)
         }
     }
 
-    override val localChanges: Flow<Unit> = merge(
-        writes,
-        prefs.pendingDisabledCalendarIds.distinctUntilChanged().drop(1).map {},
-        prefs.hiddenCalendarIds.distinctUntilChanged().drop(1).map {},
-    )
-
     /**
      * Re-query signal for everything filtered by visibility: the provider's own
      * notifications, plus every change to the pending switch-off set.
@@ -139,7 +125,8 @@ class CalendarRepositoryImpl @Inject constructor(
                         beginMillis = range.start.toEpochMillis(),
                         endMillis = range.endInclusive.toEpochMillis(),
                     ),
-                    switchedOffCalendarIds = switchedOffCalendarIds(),
+                    switchedOffCalendarIds = invisibleCalendarIds() +
+                        prefs.pendingDisabledCalendarIds.first(),
                 )
             },
             prefs.hiddenCalendarIds,
@@ -164,10 +151,6 @@ class CalendarRepositoryImpl @Inject constructor(
         .filterNot { it.isVisibleInSystem }
         .mapTo(mutableSetOf()) { it.id }
 
-    /** [invisibleCalendarIds] plus the switch-offs still waiting to be written. */
-    private suspend fun switchedOffCalendarIds(): Set<Long> =
-        invisibleCalendarIds() + prefs.pendingDisabledCalendarIds.first()
-
     private val calendarsLock = Mutex()
     private var cachedGeneration = -1L
     private var cachedPending: Set<Long>? = null
@@ -194,11 +177,6 @@ class CalendarRepositoryImpl @Inject constructor(
         cachedCalendars
     }
 
-    override suspend fun eventOccurrences(eventId: Long, range: ClosedRange<Instant>): List<EventInstance> =
-        withContext(io) {
-            dataSource.eventInstances(eventId, range.start.toEpochMillis(), range.endInclusive.toEpochMillis())
-        }
-
     override suspend fun eventDetail(eventId: Long): EventDetail = withContext(io) {
         dataSource.eventDetail(eventId, allDayReminderTimeMinutes())
             ?: throw NoSuchEventException(eventId)
@@ -206,13 +184,15 @@ class CalendarRepositoryImpl @Inject constructor(
 
     override suspend fun searchEvents(query: String): List<SearchCandidate> = withContext(io) {
         if (query.isBlank()) return@withContext emptyList()
-        val excluded = prefs.hiddenCalendarIds.first() + switchedOffCalendarIds()
+        val excluded = prefs.hiddenCalendarIds.first() +
+            prefs.pendingDisabledCalendarIds.first() +
+            invisibleCalendarIds()
         dataSource.searchEvents(query)
             .let { if (excluded.isEmpty()) it else it.filterNot { c -> c.event.calendarId in excluded } }
     }
 
     override suspend fun eventColorPalette(calendarId: Long): List<EventColorOption> =
-        withContext(io) { dataSource.publishedEventColors(calendarId).curatedForPicker() }
+        withContext(io) { dataSource.eventColorPalette(calendarId) }
 
     override suspend fun createLocalCalendar(
         displayName: String,
@@ -234,15 +214,16 @@ class CalendarRepositoryImpl @Inject constructor(
 
     override suspend fun setCalendarsVisible(ids: Collection<Long>, visible: Boolean) =
         write {
-            val canWrite = dataSource.canWriteCalendars()
-            if (canWrite) ids.forEach { dataSource.setCalendarVisible(it, visible) }
-            // Nothing of ours is left waiting for the provider once the write
-            // lands, and switching one back on retires its entry. With read-only
-            // permission a switch-off still works, app-side, and the reconciler
-            // flushes it if WRITE_CALENDAR ever arrives.
-            if (canWrite || visible) {
+            if (dataSource.canWriteCalendars()) {
+                ids.forEach { dataSource.setCalendarVisible(it, visible) }
+                // Nothing of ours is left waiting for the provider once the
+                // write lands (and switching one back on retires its entry).
+                prefs.removePendingDisabledCalendarIds(ids)
+            } else if (visible) {
                 prefs.removePendingDisabledCalendarIds(ids)
             } else {
+                // Read-only permission: the switch still works, app-side, and
+                // the reconciler flushes it if WRITE_CALENDAR ever arrives.
                 prefs.addPendingDisabledCalendarIds(ids)
             }
         }
@@ -351,11 +332,7 @@ class CalendarRepositoryImpl @Inject constructor(
         dataSource.updateEventFromOccurrence(
             eventId, beginMillis, original, updated, allDayReminderTimeMinutes(),
         )
-    }.also { newId -> if (newId != eventId) splits.tryEmit(SeriesSplit(eventId, newId)) }
-
-    private val splits = MutableSharedFlow<SeriesSplit>(extraBufferCapacity = 8)
-
-    override val seriesSplits: Flow<SeriesSplit> = splits
+    }
 
     override suspend fun deleteOccurrence(eventId: Long, beginMillis: Long) = write {
         dataSource.deleteOccurrence(eventId, beginMillis)

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

@@ -4,15 +4,15 @@ import android.Manifest
 import android.content.Context
 import android.content.pm.PackageManager
 import android.util.Log
+import androidx.core.content.ContextCompat
 import dagger.hilt.EntryPoint
 import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.domain.calendarVisibilityPlan
 import de.jeanlucmakiola.calendula.domain.hasSystemHiddenCalendars
-import de.jeanlucmakiola.floret.android.hasPermission
-import de.jeanlucmakiola.floret.di.IoDispatcher
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.withContext
@@ -47,7 +47,7 @@ class CalendarVisibilityReconciler @Inject constructor(
             // Settled ahead of the permission gate, so an update installed
             // before the first grant can't later look like an upgrade.
             if (!isUpgradeInstall()) settleNoticeOnce(pending = false)
-            if (!context.hasPermission(Manifest.permission.READ_CALENDAR)) return@withContext
+            if (!hasPermission(Manifest.permission.READ_CALENDAR)) return@withContext
             val pending = prefs.pendingDisabledCalendarIds.first()
             val noticeSettled = prefs.visibilityNoticePending.first() != null
             if (pending.isEmpty() && noticeSettled) return@withContext
@@ -56,7 +56,7 @@ class CalendarVisibilityReconciler @Inject constructor(
             // Both decisions below are one-way, so leave them to the next run.
             if (calendars.isEmpty()) return@withContext
             settleNoticeOnce(hasSystemHiddenCalendars(calendars, pending))
-            if (pending.isEmpty() || !context.hasPermission(Manifest.permission.WRITE_CALENDAR)) {
+            if (pending.isEmpty() || !hasPermission(Manifest.permission.WRITE_CALENDAR)) {
                 return@withContext
             }
             val plan = calendarVisibilityPlan(calendars, pending)
@@ -97,6 +97,9 @@ class CalendarVisibilityReconciler @Inject constructor(
         false
     }
 
+    private fun hasPermission(permission: String): Boolean =
+        ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED
+
     /** Lets non-injectable entry points (the Application) reach the reconciler. */
     @EntryPoint
     @InstallIn(SingletonComponent::class)

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

@@ -1,11 +1,6 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
 import android.database.Cursor
-import de.jeanlucmakiola.calendula.domain.EventStatus
-import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
-import java.time.Instant
-import java.time.LocalDate
-import java.time.ZoneOffset
 
 /**
  * Read-only view over a single row's columns by index. Lets the mappers work
@@ -25,33 +20,3 @@ internal class CursorColumnReader(private val cursor: Cursor) : ColumnReader {
     override fun getInt(index: Int): Int = cursor.getInt(index)
     override fun isNull(index: Int): Boolean = cursor.isNull(index)
 }
-
-internal fun ColumnReader.getIntOrNull(index: Int): Int? = if (isNull(index)) null else getInt(index)
-
-internal fun ColumnReader.getLongOrNull(index: Int): Long? = if (isNull(index)) null else getLong(index)
-
-/**
- * The row's end: DTEND, or DTSTART + DURATION for a recurring row, which stores
- * no DTEND. Unclamped; a missing/blank both means a zero-length event.
- */
-internal fun ColumnReader.endMillis(dtStartMillis: Long, dtEndIndex: Int, durationIndex: Int): Long =
-    getLongOrNull(dtEndIndex) ?: (dtStartMillis + parseRfc2445DurationMillis(getString(durationIndex)))
-
-/** STATUS shares value 0 with TENTATIVE, so an absent column must read as Confirmed. */
-internal fun ColumnReader.eventStatus(index: Int): EventStatus =
-    getIntOrNull(index)?.let(::mapEventStatus) ?: EventStatus.Confirmed
-
-/** Map every row, reading each through one [CursorColumnReader]. */
-internal inline fun <T> Cursor.mapRows(map: ColumnReader.() -> T): List<T> {
-    val reader = CursorColumnReader(this)
-    return buildList { while (moveToNext()) add(reader.map()) }
-}
-
-/** [mapRows], dropping the rows [map] returns null for. */
-internal inline fun <T : Any> Cursor.mapRowsNotNull(map: ColumnReader.() -> T?): List<T> {
-    val reader = CursorColumnReader(this)
-    return buildList { while (moveToNext()) reader.map()?.let(::add) }
-}
-
-/** The UTC calendar day of [millis] — an all-day row's date, since it sits at UTC midnight. */
-internal fun utcDate(millis: Long): LocalDate = Instant.ofEpochMilli(millis).atZone(ZoneOffset.UTC).toLocalDate()

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

@@ -15,7 +15,9 @@ import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.Reminder
 import de.jeanlucmakiola.calendula.domain.ReminderMethod
 import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
+import java.time.Instant
 import java.time.ZoneId
+import java.time.ZoneOffset
 
 private const val TAG = "EventDetailMapper"
 
@@ -46,8 +48,11 @@ internal fun ColumnReader.toEventDetailCore(
     // — the same trap as the pre-1970 DTSTART bug above (issue #34): it would
     // surface as the generic error screen with no way to open the event and fix
     // it. Clamp to a zero-length event instead (matching SearchMapper).
-    val end = getLongOrNull(EventDetailProjection.IDX_DTEND)?.coerceAtLeast(begin)
-        ?: (begin + parseRfc2445DurationMillis(getString(EventDetailProjection.IDX_DURATION)))
+    val end = if (isNull(EventDetailProjection.IDX_DTEND)) {
+        begin + parseRfc2445DurationMillis(getString(EventDetailProjection.IDX_DURATION))
+    } else {
+        getLong(EventDetailProjection.IDX_DTEND).coerceAtLeast(begin)
+    }
 
     // Kept raw (no untitled fallback): the detail screen substitutes its own
     // localized placeholder, and the edit form must prefill the true value.
@@ -56,7 +61,11 @@ internal fun ColumnReader.toEventDetailCore(
     // The event's own colour (null = inherits the calendar's) is kept apart
     // from the resolved display colour: the edit form needs to tell the two
     // cases apart, while the instance carries the calendar fallback for display.
-    val eventColor = getIntOrNull(EventDetailProjection.IDX_EVENT_COLOR)
+    val eventColor = if (isNull(EventDetailProjection.IDX_EVENT_COLOR)) {
+        null
+    } else {
+        getInt(EventDetailProjection.IDX_EVENT_COLOR)
+    }
     val eventColorKey = getString(EventDetailProjection.IDX_EVENT_COLOR_KEY)
     val color = eventColor ?: getInt(EventDetailProjection.IDX_CALENDAR_COLOR)
 
@@ -79,7 +88,7 @@ internal fun ColumnReader.toEventDetailCore(
     // and detail screen speak. DTSTART is UTC midnight for all-day events, so the
     // event's date is its UTC date.
     val displayReminders = if (isAllDay) {
-        val startDate = utcDate(begin)
+        val startDate = Instant.ofEpochMilli(begin).atZone(ZoneOffset.UTC).toLocalDate()
         val zone = ZoneId.systemDefault()
         reminders.map {
             it.copy(
@@ -92,6 +101,14 @@ internal fun ColumnReader.toEventDetailCore(
         reminders
     }
 
+    // STATUS shares its 0 value with STATUS_TENTATIVE, so a missing column must
+    // be distinguished from a present 0 — an absent status means "just confirmed".
+    val status = if (isNull(EventDetailProjection.IDX_STATUS)) {
+        EventStatus.Confirmed
+    } else {
+        mapEventStatus(getInt(EventDetailProjection.IDX_STATUS))
+    }
+
     return EventDetail(
         instance = instance,
         description = getString(EventDetailProjection.IDX_DESCRIPTION),
@@ -99,7 +116,7 @@ internal fun ColumnReader.toEventDetailCore(
         attendees = attendees,
         rrule = getString(EventDetailProjection.IDX_RRULE),
         reminders = displayReminders,
-        status = eventStatus(EventDetailProjection.IDX_STATUS),
+        status = status,
         // BUSY and DEFAULT are both 0, so a null column folds into the same
         // default these mappers already return — no isNull guard needed.
         availability = mapAvailability(getInt(EventDetailProjection.IDX_AVAILABILITY)),

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

@@ -132,7 +132,6 @@ internal fun buildEventInsertValues(
     put(CalendarContract.Events.EVENT_TIMEZONE, times.timezone)
     put(CalendarContract.Events.AVAILABILITY, form.availability.toProviderValue())
     put(CalendarContract.Events.ACCESS_LEVEL, form.accessLevel.toProviderValue())
-    if (form.status != EventStatus.Confirmed) put(CalendarContract.Events.STATUS, form.status.toProviderStatus())
     form.location.trim().takeIf { it.isNotEmpty() }
         ?.let { put(CalendarContract.Events.EVENT_LOCATION, it) }
     form.description.trim().takeIf { it.isNotEmpty() }
@@ -180,9 +179,6 @@ internal fun buildEventUpdateValues(
     if (updated.accessLevel != original.accessLevel) {
         put(CalendarContract.Events.ACCESS_LEVEL, updated.accessLevel.toProviderValue())
     }
-    if (updated.status != original.status) {
-        put(CalendarContract.Events.STATUS, updated.status.toProviderStatus())
-    }
     if (updated.colorKey != original.colorKey || updated.color != original.color) {
         putAll(eventColorColumns(updated.colorKey, updated.color))
     }
@@ -283,7 +279,6 @@ internal fun buildOccurrenceExceptionValues(
     put(CalendarContract.Events.EVENT_TIMEZONE, times.timezone)
     put(CalendarContract.Events.AVAILABILITY, form.availability.toProviderValue())
     put(CalendarContract.Events.ACCESS_LEVEL, form.accessLevel.toProviderValue())
-    put(CalendarContract.Events.STATUS, form.status.toProviderStatus())
     put(CalendarContract.Events.EVENT_LOCATION, form.location.trim().ifEmpty { null })
     put(CalendarContract.Events.DESCRIPTION, form.description.trim().ifEmpty { null })
     if (form.colorKey == null) putAll(eventColorColumns(null, form.color))
@@ -377,11 +372,48 @@ internal data class ExceptionRowSnapshot(
     val exceptionEventId: Long,
     val originalInstanceMillis: Long,
     val isCancelled: Boolean,
+    val status: Int?,
+    val title: String,
+    val isAllDay: Boolean,
     val dtStartMillis: Long,
     val dtEndMillis: Long?,
     val duration: String?,
+    val timezone: String?,
+    val availability: Int,
+    val accessLevel: Int,
+    val location: String?,
+    val description: String?,
 )
 
+/**
+ * Column values replaying a *modified* occurrence [snapshot] against the moved
+ * series via `CONTENT_EXCEPTION_URI`. Like [buildOccurrenceExceptionValues] the
+ * length travels as DURATION (the provider rejects DTEND on an exception). A
+ * cancelled occurrence is written separately (ORIGINAL_INSTANCE_TIME +
+ * STATUS_CANCELED) — this builder is only for the modified case.
+ */
+internal fun buildCopiedExceptionValues(snapshot: ExceptionRowSnapshot): Map<String, Any?> =
+    buildMap {
+        put(CalendarContract.Events.ORIGINAL_INSTANCE_TIME, snapshot.originalInstanceMillis)
+        put(CalendarContract.Events.TITLE, snapshot.title)
+        put(CalendarContract.Events.ALL_DAY, if (snapshot.isAllDay) 1 else 0)
+        put(CalendarContract.Events.DTSTART, snapshot.dtStartMillis)
+        put(
+            CalendarContract.Events.DURATION,
+            snapshot.duration?.takeIf { it.isNotBlank() }
+                ?: rfc2445Duration(
+                    (snapshot.dtEndMillis ?: snapshot.dtStartMillis) - snapshot.dtStartMillis,
+                    snapshot.isAllDay,
+                ),
+        )
+        put(CalendarContract.Events.EVENT_TIMEZONE, snapshot.timezone ?: "UTC")
+        put(CalendarContract.Events.AVAILABILITY, snapshot.availability)
+        put(CalendarContract.Events.ACCESS_LEVEL, snapshot.accessLevel)
+        put(CalendarContract.Events.EVENT_LOCATION, snapshot.location?.ifEmpty { null })
+        put(CalendarContract.Events.DESCRIPTION, snapshot.description?.ifEmpty { null })
+        snapshot.status?.let { put(CalendarContract.Events.STATUS, it) }
+    }
+
 /**
  * Column values for a *cancelled*-occurrence exception row ("delete only this
  * event"): inserting them at `Events.CONTENT_EXCEPTION_URI/<id>` makes the
@@ -447,24 +479,9 @@ internal fun buildOccurrenceExdateValues(
     duration: String?,
     timezone: String?,
     allDay: Int,
-): Map<String, Any?> = buildOccurrencesExdateValues(
-    existingExdate, listOf(occurrenceMillis), dtStartMillis, rrule, rdate, duration, timezone, allDay,
-)
-
-/** [buildOccurrenceExdateValues] excluding every one of [occurrences] in one write. */
-internal fun buildOccurrencesExdateValues(
-    existingExdate: String?,
-    occurrences: List<Long>,
-    dtStartMillis: Long,
-    rrule: String?,
-    rdate: String?,
-    duration: String?,
-    timezone: String?,
-    allDay: Int,
 ): Map<String, Any?> = mapOf(
-    CalendarContract.Events.EXDATE to occurrences.fold(existingExdate) { exdate, millis ->
-        mergedExdate(exdate, millis, allDay != 0, timezone)
-    },
+    CalendarContract.Events.EXDATE to
+        mergedExdate(existingExdate, occurrenceMillis, allDay != 0, timezone),
     CalendarContract.Events.DTSTART to dtStartMillis,
     CalendarContract.Events.RRULE to rrule,
     CalendarContract.Events.RDATE to rdate,
@@ -614,7 +631,7 @@ internal fun exdateAfter(
  * optionally behind the parameter prefix AOSP's `RecurrenceSet` puts in front of
  * a zoned one ([exdateListZone] reads that half).
  */
-internal fun exdateStamps(exdate: String?): List<String> = exdate
+private fun exdateStamps(exdate: String?): List<String> = exdate
     ?.withoutExdateParameters()
     ?.split(',')
     ?.map { it.trim() }
@@ -884,7 +901,7 @@ internal fun buildImportedEventValues(
  */
 private fun importDuration(startMillis: Long, endMillis: Long, isAllDay: Boolean): String {
     val span = (endMillis - startMillis).coerceAtLeast(0)
-    return rfc2445Duration(if (isAllDay) span.coerceAtLeast(MILLIS_PER_DAY) else span, isAllDay)
+    return if (isAllDay) "P${(span / 86_400_000L).coerceAtLeast(1)}D" else "P${span / 1_000L}S"
 }
 
 private fun EventStatus.toProviderStatus(): Int = when (this) {

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

@@ -1,9 +1,13 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
 import de.jeanlucmakiola.floret.time.toKotlinInstantFromEpochMillis
+import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
 import de.jeanlucmakiola.calendula.domain.ics.deriveIcsUid
+import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
+import java.time.Instant
 import java.time.ZoneId
+import java.time.ZoneOffset
 
 /**
  * Map one Events row (read through [EventExportProjection]) into an [IcsEvent]
@@ -29,8 +33,19 @@ internal fun ColumnReader.toIcsEvent(
     val rrule = getString(EventExportProjection.IDX_RRULE)?.takeIf { it.isNotBlank() }
     val isAllDay = getInt(EventExportProjection.IDX_ALL_DAY) != 0
 
-    // Unclamped: the writer renders DTEND as stored.
-    val end = endMillis(dtStart, EventExportProjection.IDX_DTEND, EventExportProjection.IDX_DURATION)
+    // Recurring rows store DURATION instead of DTEND; reconstruct the end from it
+    // so the writer can render DTEND. A missing/blank both means a zero-length event.
+    val end = when {
+        !isNull(EventExportProjection.IDX_DTEND) -> getLong(EventExportProjection.IDX_DTEND)
+        else -> dtStart + parseRfc2445DurationMillis(getString(EventExportProjection.IDX_DURATION))
+    }
+
+    // STATUS shares value 0 with TENTATIVE, so an absent column must read as Confirmed.
+    val status = if (isNull(EventExportProjection.IDX_STATUS)) {
+        EventStatus.Confirmed
+    } else {
+        mapEventStatus(getInt(EventExportProjection.IDX_STATUS))
+    }
 
     return IcsEvent(
         uid = deriveIcsUid(getString(EventExportProjection.IDX_UID), eventId, dtStart),
@@ -53,14 +68,14 @@ internal fun ColumnReader.toIcsEvent(
         location = getString(EventExportProjection.IDX_LOCATION),
         description = getString(EventExportProjection.IDX_DESCRIPTION),
         reminderMinutes = if (isAllDay) {
-            val startDate = utcDate(dtStart)
+            val startDate = Instant.ofEpochMilli(dtStart).atZone(ZoneOffset.UTC).toLocalDate()
             reminderMinutes.map {
                 fromProviderAllDayMinutes(it, startDate, zone, allDayReminderTimeMinutes)
             }
         } else {
             reminderMinutes
         },
-        status = eventStatus(EventExportProjection.IDX_STATUS),
+        status = status,
         availability = mapAvailability(getInt(EventExportProjection.IDX_AVAILABILITY)),
         calendarName = calendarName,
     )
@@ -97,7 +112,11 @@ internal fun exportExDates(
 ): List<String> {
     if (exdate.isNullOrBlank()) return emptyList()
     val zone = exdateListZone(exdate, eventTimezone)
-    return exdateStamps(exdate)
+    return exdate
+        .withoutExdateParameters()
+        .split(',')
+        .map { it.trim() }
+        .filter { it.isNotEmpty() }
         .map { stamp ->
             if (isAllDay) {
                 stamp.substringBefore('T')

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

@@ -25,7 +25,11 @@ internal fun ColumnReader.toEventInstance(): EventInstance? {
     // string, so it belongs to the UI layer where it can be localised (#321).
     val title = getString(InstanceProjection.IDX_TITLE).orEmpty()
 
-    val color = getIntOrNull(InstanceProjection.IDX_EVENT_COLOR) ?: getInt(InstanceProjection.IDX_CALENDAR_COLOR)
+    val color = if (isNull(InstanceProjection.IDX_EVENT_COLOR)) {
+        getInt(InstanceProjection.IDX_CALENDAR_COLOR)
+    } else {
+        getInt(InstanceProjection.IDX_EVENT_COLOR)
+    }
 
     return EventInstance(
         instanceId = getLong(InstanceProjection.IDX_INSTANCE_ID),
@@ -38,7 +42,6 @@ internal fun ColumnReader.toEventInstance(): EventInstance? {
         color = color,
         location = getString(InstanceProjection.IDX_LOCATION),
         response = mapEventResponse(getInt(InstanceProjection.IDX_SELF_ATTENDEE_STATUS)),
-        status = eventStatus(InstanceProjection.IDX_STATUS),
     )
 }
 

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

@@ -1,16 +1,7 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
-import android.content.ContentUris
-import android.net.Uri
 import android.provider.CalendarContract
 
-/** The `Instances` table over the window [beginMillis]..[endMillis]. */
-internal fun instancesUri(beginMillis: Long, endMillis: Long): Uri =
-    CalendarContract.Instances.CONTENT_URI.buildUpon().apply {
-        ContentUris.appendId(this, beginMillis)
-        ContentUris.appendId(this, endMillis)
-    }.build()
-
 internal object CalendarProjection {
     val COLUMNS: Array<String> = arrayOf(
         CalendarContract.Calendars._ID,
@@ -62,7 +53,6 @@ internal object InstanceProjection {
         CalendarContract.Instances.CALENDAR_COLOR,
         CalendarContract.Instances.EVENT_LOCATION,
         CalendarContract.Instances.SELF_ATTENDEE_STATUS,
-        CalendarContract.Instances.STATUS,
     )
 
     const val IDX_INSTANCE_ID = 0
@@ -76,7 +66,6 @@ internal object InstanceProjection {
     const val IDX_CALENDAR_COLOR = 8
     const val IDX_LOCATION = 9
     const val IDX_SELF_ATTENDEE_STATUS = 10
-    const val IDX_STATUS = 11
 }
 
 internal object EventDetailProjection {
@@ -200,7 +189,6 @@ internal object SearchProjection {
         // Excerpted, not just filtered on: a hit has to show what it matched.
         CalendarContract.Events.DESCRIPTION,
         CalendarContract.Events.SELF_ATTENDEE_STATUS,
-        CalendarContract.Events.STATUS,
     )
 
     const val IDX_ID = 0
@@ -217,7 +205,6 @@ internal object SearchProjection {
     const val IDX_RDATE = 11
     const val IDX_DESCRIPTION = 12
     const val IDX_SELF_ATTENDEE_STATUS = 13
-    const val IDX_STATUS = 14
 }
 
 /**
@@ -264,26 +251,40 @@ internal object MoveMasterProjection {
 
 /**
  * The exception rows of a recurring series (`ORIGINAL_ID` = the series), read to
- * carry them over to a moved copy (see [ExceptionRowSnapshot]). Both modified
+ * replay them against a moved copy (see [ExceptionRowSnapshot]). Both modified
  * occurrences and cancellations (`STATUS_CANCELED`) are read; the query filters
- * `DELETED = 0` so provider tombstones aren't carried over.
+ * `DELETED = 0` so provider tombstones aren't replayed.
  */
 internal object ExceptionProjection {
     val COLUMNS: Array<String> = arrayOf(
         CalendarContract.Events._ID,
         CalendarContract.Events.ORIGINAL_INSTANCE_TIME,
         CalendarContract.Events.STATUS,
+        CalendarContract.Events.TITLE,
+        CalendarContract.Events.ALL_DAY,
         CalendarContract.Events.DTSTART,
         CalendarContract.Events.DTEND,
         CalendarContract.Events.DURATION,
+        CalendarContract.Events.EVENT_TIMEZONE,
+        CalendarContract.Events.AVAILABILITY,
+        CalendarContract.Events.ACCESS_LEVEL,
+        CalendarContract.Events.EVENT_LOCATION,
+        CalendarContract.Events.DESCRIPTION,
     )
 
     const val IDX_ID = 0
     const val IDX_ORIGINAL_INSTANCE_TIME = 1
     const val IDX_STATUS = 2
-    const val IDX_DTSTART = 3
-    const val IDX_DTEND = 4
-    const val IDX_DURATION = 5
+    const val IDX_TITLE = 3
+    const val IDX_ALL_DAY = 4
+    const val IDX_DTSTART = 5
+    const val IDX_DTEND = 6
+    const val IDX_DURATION = 7
+    const val IDX_EVENT_TIMEZONE = 8
+    const val IDX_AVAILABILITY = 9
+    const val IDX_ACCESS_LEVEL = 10
+    const val IDX_LOCATION = 11
+    const val IDX_DESCRIPTION = 12
 }
 
 internal object AttendeeProjection {

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

@@ -2,6 +2,7 @@ package de.jeanlucmakiola.calendula.data.calendar
 
 import de.jeanlucmakiola.floret.time.toKotlinInstantFromEpochMillis
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
 
 /**
  * Map an Events-table row (a search hit) to an [EventInstance]. Unlike the
@@ -15,11 +16,17 @@ internal fun ColumnReader.toSearchResult(): EventInstance? {
     // long-running birthdays/anniversaries still surface in search.
     if (isNull(SearchProjection.IDX_DTSTART)) return null
     val dtStart = getLong(SearchProjection.IDX_DTSTART)
-    val end = endMillis(dtStart, SearchProjection.IDX_DTEND, SearchProjection.IDX_DURATION)
-        .coerceAtLeast(dtStart)
+    val end = when {
+        !isNull(SearchProjection.IDX_DTEND) -> getLong(SearchProjection.IDX_DTEND)
+        else -> dtStart + parseRfc2445DurationMillis(getString(SearchProjection.IDX_DURATION))
+    }.coerceAtLeast(dtStart)
 
     val title = getString(SearchProjection.IDX_TITLE).orEmpty()
-    val color = getIntOrNull(SearchProjection.IDX_EVENT_COLOR) ?: getInt(SearchProjection.IDX_CALENDAR_COLOR)
+    val color = if (isNull(SearchProjection.IDX_EVENT_COLOR)) {
+        getInt(SearchProjection.IDX_CALENDAR_COLOR)
+    } else {
+        getInt(SearchProjection.IDX_EVENT_COLOR)
+    }
     val eventId = getLong(SearchProjection.IDX_ID)
 
     return EventInstance(
@@ -35,6 +42,5 @@ internal fun ColumnReader.toSearchResult(): EventInstance? {
         isRecurring = !getString(SearchProjection.IDX_RRULE).isNullOrEmpty() ||
             !getString(SearchProjection.IDX_RDATE).isNullOrEmpty(),
         response = mapEventResponse(getInt(SearchProjection.IDX_SELF_ATTENDEE_STATUS)),
-        status = eventStatus(SearchProjection.IDX_STATUS),
     )
 }

app/src/main/java/de/jeanlucmakiola/calendula/data/contacts/ContactSpecialDatesDataSource.kt

@@ -2,15 +2,16 @@ package de.jeanlucmakiola.calendula.data.contacts
 
 import android.Manifest
 import android.content.Context
+import android.content.pm.PackageManager
 import android.provider.ContactsContract
 import android.provider.ContactsContract.CommonDataKinds.Event
 import android.util.Log
+import androidx.core.content.ContextCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.domain.contacts.ContactSpecialDate
 import de.jeanlucmakiola.calendula.domain.contacts.SpecialDateType
 import de.jeanlucmakiola.calendula.domain.contacts.managedUid
 import de.jeanlucmakiola.calendula.domain.contacts.parseContactEventDate
-import de.jeanlucmakiola.floret.android.hasPermission
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -30,7 +31,8 @@ interface ContactSpecialDatesDataSource {
 
 /** Whether `READ_CONTACTS` is granted — the gate for every contacts read. */
 fun Context.hasContactsPermission(): Boolean =
-    hasPermission(Manifest.permission.READ_CONTACTS)
+    ContextCompat.checkSelfPermission(this, Manifest.permission.READ_CONTACTS) ==
+        PackageManager.PERMISSION_GRANTED
 
 /** Map a `ContactsContract` event `TYPE` to our calendar bucket. */
 internal fun specialDateTypeForRawEventType(type: Int): SpecialDateType = when (type) {

app/src/main/java/de/jeanlucmakiola/calendula/data/di/DataModule.kt

@@ -24,9 +24,8 @@ import de.jeanlucmakiola.calendula.data.time.AndroidTodaySource
 import de.jeanlucmakiola.calendula.data.time.AndroidZoneSource
 import de.jeanlucmakiola.calendula.data.time.TodaySource
 import de.jeanlucmakiola.calendula.data.time.ZoneSource
-import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
 import javax.inject.Singleton
 
 private val Context.calendulaDataStore: DataStore<Preferences> by preferencesDataStore(
@@ -90,7 +89,6 @@ object DataProvideModule {
         context.calendulaDataStore
 
     @Provides
-    @Singleton
-    @ApplicationScope
-    fun provideApplicationScope(): CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+    @IoDispatcher
+    fun provideIoDispatcher(): CoroutineDispatcher = Dispatchers.IO
 }

app/src/main/java/de/jeanlucmakiola/calendula/data/di/Qualifiers.kt

@@ -2,7 +2,6 @@ package de.jeanlucmakiola.calendula.data.di
 
 import javax.inject.Qualifier
 
-/** The process-wide `CoroutineScope` that app-lifetime singletons share their flows in. */
 @Qualifier
 @Retention(AnnotationRetention.BINARY)
-annotation class ApplicationScope
+annotation class IoDispatcher

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

@@ -1,13 +1,15 @@
 package de.jeanlucmakiola.calendula.data.prefs
 
 import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.MutablePreferences
 import androidx.datastore.preferences.core.Preferences
-import de.jeanlucmakiola.floret.prefs.Pref
-import de.jeanlucmakiola.floret.prefs.PrefStore
-import de.jeanlucmakiola.floret.prefs.nullableBooleanPref
-import de.jeanlucmakiola.floret.prefs.nullableLongPref
-import de.jeanlucmakiola.floret.prefs.nullableStringPref
+import androidx.datastore.preferences.core.booleanPreferencesKey
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.longPreferencesKey
+import androidx.datastore.preferences.core.stringPreferencesKey
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -24,13 +26,18 @@ import javax.inject.Singleton
  */
 @Singleton
 class CalendarPrefs @Inject constructor(
-    store: DataStore<Preferences>,
+    private val store: DataStore<Preferences>,
 ) {
-    private val prefs = PrefStore(store)
 
-    val hiddenCalendarIds: Flow<Set<Long>> = prefs.flow(HIDDEN_IDS)
+    // Both id sets are deduped: the store is shared with SettingsPrefs, so any
+    // unrelated write would otherwise re-emit an identical set.
+    val hiddenCalendarIds: Flow<Set<Long>> = store.data
+        .map { prefs -> prefs[HIDDEN_IDS_KEY].parseIds() }
+        .distinctUntilChanged()
 
-    suspend fun setHiddenCalendarIds(ids: Set<Long>) = prefs.set(HIDDEN_IDS, ids)
+    suspend fun setHiddenCalendarIds(ids: Set<Long>) {
+        store.edit { prefs -> prefs.writeIds(HIDDEN_IDS_KEY, ids) }
+    }
 
     /**
      * Switch-offs the provider does not know about yet, because writing
@@ -41,18 +48,24 @@ class CalendarPrefs @Inject constructor(
      * second visibility model: `CalendarVisibilityReconciler` drains it entry by
      * entry as soon as the app may write, and nothing adds to it while it may.
      */
-    val pendingDisabledCalendarIds: Flow<Set<Long>> = prefs.flow(DISABLED_IDS)
+    val pendingDisabledCalendarIds: Flow<Set<Long>> = store.data
+        .map { prefs -> prefs[DISABLED_IDS_KEY].parseIds() }
+        .distinctUntilChanged()
 
-    suspend fun addPendingDisabledCalendarIds(ids: Collection<Long>) {
-        prefs.update(DISABLED_IDS) { it + ids }
-    }
+    suspend fun addPendingDisabledCalendarIds(ids: Collection<Long>) =
+        editPendingDisabled { it + ids }
 
     /**
      * Drop [ids] from the pending set, one at a time as the reconciler flushes
      * them, so a run that fails part-way never re-applies what already landed.
      */
-    suspend fun removePendingDisabledCalendarIds(ids: Collection<Long>) {
-        prefs.update(DISABLED_IDS) { it - ids.toSet() }
+    suspend fun removePendingDisabledCalendarIds(ids: Collection<Long>) =
+        editPendingDisabled { it - ids.toSet() }
+
+    private suspend fun editPendingDisabled(transform: (Set<Long>) -> Set<Long>) {
+        store.edit { prefs ->
+            prefs.writeIds(DISABLED_IDS_KEY, transform(prefs[DISABLED_IDS_KEY].parseIds()))
+        }
     }
 
     /**
@@ -60,28 +73,39 @@ class CalendarPrefs @Inject constructor(
      * owed. Null until the reconciler has evaluated it (which needs the calendar
      * permission), false once it has been shown or was never needed.
      */
-    val visibilityNoticePending: Flow<Boolean?> = prefs.flow(VISIBILITY_NOTICE)
+    val visibilityNoticePending: Flow<Boolean?> = store.data.map { prefs ->
+        prefs[VISIBILITY_NOTICE_KEY]
+    }
 
-    suspend fun setVisibilityNoticePending(pending: Boolean) = prefs.set(VISIBILITY_NOTICE, pending)
+    suspend fun setVisibilityNoticePending(pending: Boolean) {
+        store.edit { prefs -> prefs[VISIBILITY_NOTICE_KEY] = pending }
+    }
 
     /**
      * The calendar the user last created an event in; preselected in the
      * event form. Null until the first event is created.
      */
-    val lastUsedCalendarId: Flow<Long?> = prefs.flow(LAST_USED_CALENDAR)
+    val lastUsedCalendarId: Flow<Long?> = store.data.map { prefs ->
+        prefs[LAST_USED_CALENDAR_KEY]
+    }
 
-    suspend fun setLastUsedCalendarId(id: Long) = prefs.set(LAST_USED_CALENDAR, id)
+    suspend fun setLastUsedCalendarId(id: Long) {
+        store.edit { prefs -> prefs[LAST_USED_CALENDAR_KEY] = id }
+    }
 
-    private companion object {
-        val HIDDEN_IDS = idSetPref("hidden_calendar_ids")
-        val DISABLED_IDS = idSetPref("disabled_calendar_ids")
-        val VISIBILITY_NOTICE = nullableBooleanPref("visibility_notice_pending")
-        val LAST_USED_CALENDAR = nullableLongPref("last_used_calendar_id")
+    companion object {
+        internal val HIDDEN_IDS_KEY = stringPreferencesKey("hidden_calendar_ids")
+        internal val DISABLED_IDS_KEY = stringPreferencesKey("disabled_calendar_ids")
+        internal val VISIBILITY_NOTICE_KEY = booleanPreferencesKey("visibility_notice_pending")
+        internal val LAST_USED_CALENDAR_KEY = longPreferencesKey("last_used_calendar_id")
     }
 }
 
-/** A comma-joined id set; non-numeric tokens are dropped, and an empty set removes the key. */
-private fun idSetPref(name: String): Pref<Set<Long>> = nullableStringPref(name).map(
-    { stored -> stored.orEmpty().split(',').mapNotNull { it.trim().toLongOrNull() }.toSet() },
-    { ids -> if (ids.isEmpty()) null else ids.sorted().joinToString(",") },
-)
+private fun String?.parseIds(): Set<Long> = orEmpty()
+    .split(',')
+    .mapNotNull { it.trim().toLongOrNull() }
+    .toSet()
+
+private fun MutablePreferences.writeIds(key: Preferences.Key<String>, ids: Set<Long>) {
+    if (ids.isEmpty()) remove(key) else set(key, ids.sorted().joinToString(","))
+}

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

@@ -2,8 +2,10 @@ package de.jeanlucmakiola.calendula.data.prefs
 
 import androidx.datastore.core.DataStore
 import androidx.datastore.preferences.core.Preferences
-import de.jeanlucmakiola.floret.prefs.PrefStore
-import de.jeanlucmakiola.floret.prefs.nullableLongPref
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.longPreferencesKey
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -18,16 +20,17 @@ import javax.inject.Singleton
  */
 @Singleton
 class ReminderStatePrefs @Inject constructor(
-    store: DataStore<Preferences>,
+    private val store: DataStore<Preferences>,
 ) {
-    private val prefs = PrefStore(store)
 
     /** The watermark, or `null` before the first scan has ever run. */
-    suspend fun lastScanMillis(): Long? = prefs.get(LAST_SCAN)
+    suspend fun lastScanMillis(): Long? = store.data.map { it[LAST_SCAN_KEY] }.first()
 
-    suspend fun setLastScanMillis(millis: Long) = prefs.set(LAST_SCAN, millis)
+    suspend fun setLastScanMillis(millis: Long) {
+        store.edit { prefs -> prefs[LAST_SCAN_KEY] = millis }
+    }
 
     private companion object {
-        val LAST_SCAN = nullableLongPref("reminder_last_scan_millis")
+        val LAST_SCAN_KEY = longPreferencesKey("reminder_last_scan_millis")
     }
 }

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

@@ -6,8 +6,11 @@ import android.content.Intent
 import androidx.core.net.toUri
 import dagger.hilt.android.AndroidEntryPoint
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
-import de.jeanlucmakiola.floret.android.goAsync
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 /**
@@ -38,24 +41,30 @@ class ReminderActionReceiver : BroadcastReceiver() {
             ACTION_DISMISS -> notifier.cancel(alert)
 
             ACTION_SNOOZE -> {
-                // Tapped on a stale view: the reminder that replaced it stays put.
-                if (notifier.isSuperseded(alert)) return
                 // Cancel now so the notification doesn't linger until the alarm;
                 // the snooze delay read is the only async work.
                 notifier.cancel(alert)
-                goAsync {
-                    val minutes = settingsPrefs.snoozeMinutes.first()
-                    val triggerAt = System.currentTimeMillis() + minutes * 60_000L
-                    scheduler.schedule(alert, triggerAt)
+                val pendingResult = goAsync()
+                CoroutineScope(SupervisorJob() + Dispatchers.IO).launch {
+                    try {
+                        val minutes = settingsPrefs.snoozeMinutes.first()
+                        val triggerAt = System.currentTimeMillis() + minutes * 60_000L
+                        scheduler.schedule(alert, triggerAt)
+                    } finally {
+                        pendingResult.finish()
+                    }
                 }
             }
 
             ACTION_SHOW -> {
-                goAsync {
-                    // A later reminder posted while this one was snoozed has taken its place.
-                    if (notifier.isSuperseded(alert)) return@goAsync
-                    if (settingsPrefs.remindersEnabled.first() && notifier.canPost()) {
-                        notifier.post(alert)
+                val pendingResult = goAsync()
+                CoroutineScope(SupervisorJob() + Dispatchers.IO).launch {
+                    try {
+                        if (settingsPrefs.remindersEnabled.first() && notifier.canPost()) {
+                            notifier.post(alert)
+                        }
+                    } finally {
+                        pendingResult.finish()
                     }
                 }
             }
@@ -86,14 +95,12 @@ class ReminderActionReceiver : BroadcastReceiver() {
         /**
          * An explicit intent to this receiver carrying [alert] as extras. The
          * data URI duplicates no information but is what keeps two reminders'
-         * `PendingIntent`s apart — `filterEquals` never compares extras. The
-         * snooze alarm is the exception: one per occurrence, so a later snooze
-         * replaces an earlier one and a newer reminder can cancel it.
+         * `PendingIntent`s apart — `filterEquals` never compares extras.
          */
         fun intent(context: Context, action: String, alert: ReminderAlert): Intent =
             Intent(context, ReminderActionReceiver::class.java).apply {
                 this.action = action
-                data = "calendula://reminder/${identity(alert, action)}".toUri()
+                data = "calendula://reminder/${alert.key}".toUri()
                 putExtra(EXTRA_ALERT_KEY, alert.key)
                 putExtra(EXTRA_EVENT_ID, alert.eventId)
                 putExtra(EXTRA_CALENDAR_ID, alert.calendarId)
@@ -107,7 +114,7 @@ class ReminderActionReceiver : BroadcastReceiver() {
         /**
          * A stable request code per (alert, action), so one notification's
          * PendingIntents stay distinct. The shift keeps the action slot intact;
-         * the top bits it drops are separated by [intent]'s URI.
+         * the top bits it drops are separated by [intent]'s per-reminder URI.
          */
         fun requestCode(alert: ReminderAlert, action: String): Int {
             val actionOffset = when (action) {
@@ -117,12 +124,9 @@ class ReminderActionReceiver : BroadcastReceiver() {
                 ACTION_OPEN -> 4
                 else -> 0
             }
-            return (identity(alert, action).toInt() shl 3) + actionOffset
+            return (alert.key.toInt() shl 3) + actionOffset
         }
 
-        private fun identity(alert: ReminderAlert, action: String): Long =
-            if (action == ACTION_SHOW) alert.occurrenceKey else alert.key
-
         private fun alertFrom(intent: Intent): ReminderAlert? {
             if (!intent.hasExtra(EXTRA_ALERT_KEY)) return null
             return ReminderAlert(

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

@@ -4,12 +4,20 @@ import android.app.AlarmManager
 import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
+import android.os.Build
 import androidx.core.content.getSystemService
 import dagger.hilt.android.qualifiers.ApplicationContext
-import de.jeanlucmakiola.floret.android.setWakeup
 import javax.inject.Inject
 import javax.inject.Singleton
 
+/**
+ * True on API < 31 (no restriction), and on 31+ when the exact-alarm capability
+ * is held — auto-granted via `USE_EXACT_ALARM` on API 33+ (Calendula is a
+ * calendar app), user-revocable on 31–32.
+ */
+internal fun AlarmManager.canScheduleExactCompat(): Boolean =
+    Build.VERSION.SDK_INT < Build.VERSION_CODES.S || canScheduleExactAlarms()
+
 /**
  * Holds the app's own wake-up for the next reminder (#75). Exactly one alarm
  * exists at a time, for the earliest reminder ahead; every firing re-scans and
@@ -23,7 +31,16 @@ class ReminderAlarmScheduler @Inject constructor(
 
     fun scheduleScan(triggerAtMillis: Long) {
         val alarmManager = context.getSystemService<AlarmManager>() ?: return
-        alarmManager.setWakeup(triggerAtMillis, scanPendingIntent(PendingIntent.FLAG_UPDATE_CURRENT))
+        val pendingIntent = scanPendingIntent(PendingIntent.FLAG_UPDATE_CURRENT)
+        if (alarmManager.canScheduleExactCompat()) {
+            alarmManager.setExactAndAllowWhileIdle(
+                AlarmManager.RTC_WAKEUP, triggerAtMillis, pendingIntent,
+            )
+        } else {
+            alarmManager.setAndAllowWhileIdle(
+                AlarmManager.RTC_WAKEUP, triggerAtMillis, pendingIntent,
+            )
+        }
     }
 
     /** Drop the pending wake-up — reminders are off, or there is nothing to wait for. */

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

@@ -1,7 +1,6 @@
 package de.jeanlucmakiola.calendula.data.reminders
 
 import de.jeanlucmakiola.calendula.domain.reminders.PlannedReminder
-import de.jeanlucmakiola.calendula.domain.reminders.occurrenceKey
 
 /**
  * One reminder as the notification layer needs it: what to show, and the stable
@@ -21,13 +20,6 @@ data class ReminderAlert(
     val isAllDay: Boolean,
 )
 
-/**
- * The occurrence [ReminderAlert] belongs to. Keys the notification and the
- * snooze alarm, so a later reminder for the same occurrence replaces the earlier
- * one instead of stacking beside it (#463).
- */
-val ReminderAlert.occurrenceKey: Long get() = occurrenceKey(eventId, beginMillis)
-
 fun PlannedReminder.toAlert(): ReminderAlert = ReminderAlert(
     key = key,
     eventId = instance.eventId,

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

@@ -1,9 +1,9 @@
 package de.jeanlucmakiola.calendula.data.reminders
 
 import android.content.Context
+import android.content.ContentUris
 import android.provider.CalendarContract
 import dagger.hilt.android.qualifiers.ApplicationContext
-import de.jeanlucmakiola.calendula.data.calendar.instancesUri
 import de.jeanlucmakiola.calendula.domain.reminders.ReminderEventInstance
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -37,7 +37,10 @@ class ProviderReminderInstanceSource @Inject constructor(
 ) : ReminderInstanceSource {
 
     override fun occurrences(fromMillis: Long, toMillis: Long): List<ReminderEventInstance> {
-        val uri = instancesUri(fromMillis, toMillis)
+        val uri = CalendarContract.Instances.CONTENT_URI.buildUpon().apply {
+            ContentUris.appendId(this, fromMillis)
+            ContentUris.appendId(this, toMillis)
+        }.build()
         // `visible` is the flag the app's one visibility model writes (#75).
         // The status clause mirrors CalendarDataSource.instances: NULL means
         // "normal", so a bare `!= CANCELED` would drop every ordinary event.

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

@@ -5,11 +5,12 @@ import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.PendingIntent
 import android.content.Context
+import android.content.pm.PackageManager
 import android.os.Build
-import android.os.Bundle
 import android.util.Log
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.ContextCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.MainActivity
 import de.jeanlucmakiola.calendula.R
@@ -18,7 +19,6 @@ import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.is24Hour
 import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
-import de.jeanlucmakiola.floret.android.hasPermission
 import kotlinx.coroutines.flow.first
 import kotlinx.datetime.isoDayNumber
 import java.time.DayOfWeek
@@ -29,13 +29,13 @@ import javax.inject.Inject
 import javax.inject.Singleton
 
 /**
- * Posts one notification per occurrence on a dedicated channel. Tapping opens
+ * Posts one notification per due reminder on a dedicated channel. Tapping opens
  * the event's detail screen.
  *
- * The tag is the [occurrenceKey], so each reminder for an occurrence replaces
- * the one before it in place (#463). A different reminder alerts afresh; the
- * same one posted again — a catch-up pass overlapping the alarm that already
- * fired — replaces its notification silently.
+ * The tag is the reminder's stable key, so a scan that posts the same reminder
+ * again — a catch-up pass overlapping the alarm that already fired — replaces
+ * its notification silently ([NotificationCompat.Builder.setOnlyAlertOnce])
+ * instead of stacking a second one.
  */
 @Singleton
 class ReminderNotifier @Inject constructor(
@@ -48,7 +48,8 @@ class ReminderNotifier @Inject constructor(
     /** False when the user declined `POST_NOTIFICATIONS` or muted the app. */
     fun canPost(): Boolean {
         val granted = Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU ||
-            context.hasPermission(Manifest.permission.POST_NOTIFICATIONS)
+            ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) ==
+            PackageManager.PERMISSION_GRANTED
         return granted && NotificationManagerCompat.from(context).areNotificationsEnabled()
     }
 
@@ -62,11 +63,15 @@ class ReminderNotifier @Inject constructor(
         calendarId in calendarPrefs.pendingDisabledCalendarIds.first() ||
             calendarDataSource.isCalendarVisible(calendarId) == false
 
-    /** Post [alert], unless its calendar is switched off. */
-    suspend fun post(alert: ReminderAlert) {
-        if (isSilenced(alert.calendarId)) return
+    /**
+     * Post [alert], unless its calendar is switched off. Returns whether the
+     * notification was put up, which the snooze re-show path uses to tell a
+     * silenced reminder from a delivered one.
+     */
+    suspend fun post(alert: ReminderAlert): Boolean {
+        if (isSilenced(alert.calendarId)) return false
         ensureChannel()
-        val title = displayTitle(alert)
+        val title = alert.title.ifBlank { context.getString(R.string.event_untitled) }
         val is24Hour = settingsPrefs.timeFormat.first()
             .is24Hour(android.text.format.DateFormat.is24HourFormat(context))
         val zone = ZoneId.systemDefault()
@@ -97,8 +102,7 @@ class ReminderNotifier @Inject constructor(
             .setCategory(NotificationCompat.CATEGORY_EVENT)
             .setPriority(NotificationCompat.PRIORITY_HIGH)
             .setAutoCancel(true)
-            .setOnlyAlertOnce(shownKey(alert) == alert.key)
-            .addExtras(Bundle().apply { putLong(EXTRA_REMINDER_KEY, alert.key) })
+            .setOnlyAlertOnce(true)
             .setContentIntent(detailIntent(alert))
             .addAction(
                 R.drawable.ic_notification_snooze,
@@ -111,58 +115,22 @@ class ReminderNotifier @Inject constructor(
                 actionIntent(alert, ReminderActionReceiver.ACTION_DISMISS),
             )
             .build()
-        val manager = NotificationManagerCompat.from(context)
-        cancelLegacy(alert)
         try {
-            manager.notify(alert.occurrenceKey.toString(), NOTIFICATION_ID, notification)
+            NotificationManagerCompat.from(context)
+                .notify(alert.key.toString(), NOTIFICATION_ID, notification)
         } catch (e: SecurityException) {
             // POST_NOTIFICATIONS was revoked between canPost() and here.
             Log.w(TAG, "Could not post reminder for event ${alert.eventId}", e)
         }
+        // Handled either way — a retry hits the same revoked permission.
+        return true
     }
 
-    /**
-     * Remove [alert]'s notification (snooze re-shows it later; dismiss is final),
-     * unless a later reminder has replaced it — an action tapped on a stale view
-     * mustn't take the newer one with it.
-     */
+    /** Remove a posted reminder (snooze re-shows it later; dismiss is final). */
     fun cancel(alert: ReminderAlert) {
-        val manager = NotificationManagerCompat.from(context)
-        if (shownKey(alert) == alert.key) manager.cancel(alert.occurrenceKey.toString(), NOTIFICATION_ID)
-        // Posted before reminders shared a notification, under the reminder's own key.
-        manager.cancel(alert.key.toString(), NOTIFICATION_ID)
+        NotificationManagerCompat.from(context).cancel(alert.key.toString(), NOTIFICATION_ID)
     }
 
-    /** Whether a different reminder for [alert]'s occurrence is on screen now. */
-    fun isSuperseded(alert: ReminderAlert): Boolean = shownKey(alert).let { it != null && it != alert.key }
-
-    /** The key of the reminder showing for [alert]'s occurrence, if any. */
-    private fun shownKey(alert: ReminderAlert): Long? {
-        val tag = alert.occurrenceKey.toString()
-        return NotificationManagerCompat.from(context).activeNotifications
-            .firstOrNull { it.tag == tag && it.id == NOTIFICATION_ID }
-            ?.notification?.extras
-            ?.takeIf { it.containsKey(EXTRA_REMINDER_KEY) }
-            ?.getLong(EXTRA_REMINDER_KEY)
-    }
-
-    /**
-     * Remove a reminder for the same occurrence posted before reminders shared a
-     * notification. It carries no reminder key; its time and title identify it.
-     */
-    private fun cancelLegacy(alert: ReminderAlert) {
-        val manager = NotificationManagerCompat.from(context)
-        manager.activeNotifications
-            .filter { it.id == NOTIFICATION_ID && it.notification.channelId == CHANNEL_ID }
-            .filter { !it.notification.extras.containsKey(EXTRA_REMINDER_KEY) }
-            .filter { it.notification.`when` == alert.beginMillis }
-            .filter { it.notification.extras.getCharSequence(NotificationCompat.EXTRA_TITLE)?.toString() == displayTitle(alert) }
-            .forEach { manager.cancel(it.tag, it.id) }
-    }
-
-    private fun displayTitle(alert: ReminderAlert): String =
-        alert.title.ifBlank { context.getString(R.string.event_untitled) }
-
     private fun actionIntent(alert: ReminderAlert, action: String): PendingIntent =
         PendingIntent.getBroadcast(
             context,
@@ -197,10 +165,8 @@ class ReminderNotifier @Inject constructor(
         const val TAG = "ReminderNotifier"
         const val CHANNEL_ID = "reminders"
 
-        // One id, distinct tags: the tag (occurrence) already keys the
+        // One id, distinct tags: the tag (alert id) already keys the
         // notification, so a fixed id keeps cancellation/replacement simple.
         const val NOTIFICATION_ID = 1
-
-        const val EXTRA_REMINDER_KEY = "de.jeanlucmakiola.calendula.reminder_key"
     }
 }

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

@@ -2,18 +2,19 @@ package de.jeanlucmakiola.calendula.data.reminders
 
 import android.Manifest
 import android.content.Context
+import android.content.pm.PackageManager
 import android.util.Log
+import androidx.core.content.ContextCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.data.calendar.CalendarDataSource
 import de.jeanlucmakiola.calendula.data.calendar.withoutProviderDefaults
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.ReminderStatePrefs
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.reminders.planReminders
 import de.jeanlucmakiola.calendula.domain.reminders.reminderQueryHorizon
 import de.jeanlucmakiola.calendula.domain.reminders.reminderWatermark
 import de.jeanlucmakiola.calendula.domain.reminders.scheduleReminders
-import de.jeanlucmakiola.floret.android.hasPermission
-import de.jeanlucmakiola.floret.di.IoDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.CoroutineStart
 import kotlinx.coroutines.SupervisorJob
@@ -43,7 +44,6 @@ class ReminderScanner @Inject constructor(
     private val source: ReminderInstanceSource,
     private val calendarDataSource: CalendarDataSource,
     private val notifier: ReminderNotifier,
-    private val snoozes: ReminderSnoozeScheduler,
     private val alarms: ReminderAlarmScheduler,
     private val state: ReminderStatePrefs,
     private val settingsPrefs: SettingsPrefs,
@@ -105,11 +105,7 @@ class ReminderScanner @Inject constructor(
         )
 
         if (notifier.canPost()) {
-            schedule.due.forEach {
-                val alert = it.toAlert()
-                snoozes.cancel(alert)
-                notifier.post(alert)
-            }
+            schedule.due.forEach { notifier.post(it.toAlert()) }
         }
         // Advance even when nothing could be posted, so muting notifications
         // doesn't build a backlog.
@@ -117,7 +113,9 @@ class ReminderScanner @Inject constructor(
         alarms.scheduleScan(schedule.nextAlarmMillis)
     }
 
-    private fun hasReadCalendar(): Boolean = context.hasPermission(Manifest.permission.READ_CALENDAR)
+    private fun hasReadCalendar(): Boolean = ContextCompat.checkSelfPermission(
+        context, Manifest.permission.READ_CALENDAR,
+    ) == PackageManager.PERMISSION_GRANTED
 
     /**
      * Re-scan when the provider changes, so a saved or deleted event re-arms the

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

@@ -4,7 +4,10 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import dagger.hilt.android.AndroidEntryPoint
-import de.jeanlucmakiola.floret.android.goAsync
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 /**
@@ -26,7 +29,14 @@ class ReminderScheduleReceiver : BroadcastReceiver() {
         // exported and the broadcasts it takes are protected, so any other
         // action did not come from where it claims to.
         if (intent.action !in HANDLED_ACTIONS) return
-        goAsync { scanner.scan() }
+        val pendingResult = goAsync()
+        CoroutineScope(SupervisorJob() + Dispatchers.IO).launch {
+            try {
+                scanner.scan()
+            } finally {
+                pendingResult.finish()
+            }
+        }
     }
 
     companion object {

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

@@ -3,9 +3,9 @@ package de.jeanlucmakiola.calendula.data.reminders
 import android.app.AlarmManager
 import android.app.PendingIntent
 import android.content.Context
+import android.os.Build
 import androidx.core.content.getSystemService
 import dagger.hilt.android.qualifiers.ApplicationContext
-import de.jeanlucmakiola.floret.android.setWakeup
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -31,18 +31,24 @@ class ReminderSnoozeScheduler @Inject constructor(
             ReminderActionReceiver.intent(context, ReminderActionReceiver.ACTION_SHOW, alert),
             PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
         )
-        alarmManager.setWakeup(triggerAtMillis, pendingIntent)
+        if (canScheduleExact(alarmManager)) {
+            alarmManager.setExactAndAllowWhileIdle(
+                AlarmManager.RTC_WAKEUP, triggerAtMillis, pendingIntent,
+            )
+        } else {
+            // Exact alarms revoked (API 31–32); an inexact wake is the best
+            // available without nagging for SCHEDULE_EXACT_ALARM.
+            alarmManager.setAndAllowWhileIdle(
+                AlarmManager.RTC_WAKEUP, triggerAtMillis, pendingIntent,
+            )
+        }
     }
 
-    /** Drop a snooze still pending for [alert]'s occurrence, so it can't re-show over a newer reminder. */
-    fun cancel(alert: ReminderAlert) {
-        val pendingIntent = PendingIntent.getBroadcast(
-            context,
-            ReminderActionReceiver.requestCode(alert, ReminderActionReceiver.ACTION_SHOW),
-            ReminderActionReceiver.intent(context, ReminderActionReceiver.ACTION_SHOW, alert),
-            PendingIntent.FLAG_NO_CREATE or PendingIntent.FLAG_IMMUTABLE,
-        ) ?: return
-        context.getSystemService<AlarmManager>()?.cancel(pendingIntent)
-        pendingIntent.cancel()
-    }
+    /**
+     * True on API < 31 (no restriction), and on 31+ when the exact-alarm
+     * capability is held — auto-granted via `USE_EXACT_ALARM` on API 33+
+     * (Calendula is a calendar app), user-revocable on 31–32.
+     */
+    private fun canScheduleExact(alarmManager: AlarmManager): Boolean =
+        Build.VERSION.SDK_INT < Build.VERSION_CODES.S || alarmManager.canScheduleExactAlarms()
 }

app/src/main/java/de/jeanlucmakiola/calendula/data/time/TodaySource.kt

@@ -1,20 +1,18 @@
 package de.jeanlucmakiola.calendula.data.time
 
+import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
+import android.content.IntentFilter
+import androidx.core.content.ContextCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
-import de.jeanlucmakiola.calendula.data.di.ApplicationScope
-import de.jeanlucmakiola.floret.android.broadcastTicks
-import de.jeanlucmakiola.floret.android.stateWhileSubscribed
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.shareIn
-import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.callbackFlow
 import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.onStart
 import kotlinx.coroutines.flow.transformLatest
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
@@ -30,16 +28,27 @@ interface TodaySource {
 /**
  * Re-reads the date on every minute boundary while collected, and at once on the
  * system's date, time and zone broadcasts, which can arrive late or not at all.
- * One receiver and tick loop is shared by every collector.
  */
 @OptIn(ExperimentalCoroutinesApi::class)
 class AndroidTodaySource @Inject constructor(
     @ApplicationContext private val context: Context,
-    @ApplicationScope scope: CoroutineScope,
 ) : TodaySource {
 
-    override val today: Flow<LocalDate> = context
-        .broadcastTicks(Intent.ACTION_DATE_CHANGED, Intent.ACTION_TIME_CHANGED, Intent.ACTION_TIMEZONE_CHANGED)
+    override val today: Flow<LocalDate> = callbackFlow {
+        val receiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context, intent: Intent) {
+                trySend(Unit)
+            }
+        }
+        val filter = IntentFilter().apply {
+            addAction(Intent.ACTION_DATE_CHANGED)
+            addAction(Intent.ACTION_TIME_CHANGED)
+            addAction(Intent.ACTION_TIMEZONE_CHANGED)
+        }
+        ContextCompat.registerReceiver(context, receiver, filter, ContextCompat.RECEIVER_NOT_EXPORTED)
+        awaitClose { context.unregisterReceiver(receiver) }
+    }
+        .onStart { emit(Unit) }
         .transformLatest {
             while (true) {
                 emit(currentDate())
@@ -47,27 +56,8 @@ class AndroidTodaySource @Inject constructor(
             }
         }
         .distinctUntilChanged()
-        .shareIn(scope, SharingStarted.WhileSubscribed(replayExpirationMillis = 0), replay = 1)
 }
 
 private const val MINUTE_MILLIS = 60_000L
 
 fun currentDate(): LocalDate = Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()).date
-
-/**
- * Today as a hot flow seeded with [initial]. [onRollover] runs with the previous
- * and the new date each time the day changes while collected, so a screen left
- * open over midnight can move off yesterday (#373).
- */
-fun Flow<LocalDate>.stateFollowingDays(
-    scope: CoroutineScope,
-    initial: LocalDate,
-    onRollover: (old: LocalDate, new: LocalDate) -> Unit,
-): StateFlow<LocalDate> {
-    var last = initial
-    return onEach { date ->
-        val old = last
-        last = date
-        if (old != date) onRollover(old, date)
-    }.stateWhileSubscribed(scope, initial)
-}

app/src/main/java/de/jeanlucmakiola/calendula/data/time/ZoneSource.kt

@@ -1,16 +1,17 @@
 package de.jeanlucmakiola.calendula.data.time
 
+import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
+import android.content.IntentFilter
+import androidx.core.content.ContextCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
-import de.jeanlucmakiola.calendula.data.di.ApplicationScope
-import de.jeanlucmakiola.floret.android.broadcastTicks
-import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.callbackFlow
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.shareIn
+import kotlinx.coroutines.flow.onStart
 import kotlinx.datetime.TimeZone
 import javax.inject.Inject
 
@@ -27,16 +28,24 @@ interface ZoneSource {
     fun current(): TimeZone
 }
 
-/** Follows the system's zone broadcast, one receiver shared by every collector. */
+/** Follows the system's zone broadcast. */
 class AndroidZoneSource @Inject constructor(
     @ApplicationContext private val context: Context,
-    @ApplicationScope scope: CoroutineScope,
 ) : ZoneSource {
 
-    override val zone: Flow<TimeZone> = context.broadcastTicks(Intent.ACTION_TIMEZONE_CHANGED)
+    override val zone: Flow<TimeZone> = callbackFlow {
+        val receiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context, intent: Intent) {
+                trySend(Unit)
+            }
+        }
+        val filter = IntentFilter(Intent.ACTION_TIMEZONE_CHANGED)
+        ContextCompat.registerReceiver(context, receiver, filter, ContextCompat.RECEIVER_NOT_EXPORTED)
+        awaitClose { context.unregisterReceiver(receiver) }
+    }
+        .onStart { emit(Unit) }
         .map { current() }
         .distinctUntilChanged()
-        .shareIn(scope, SharingStarted.WhileSubscribed(replayExpirationMillis = 0), replay = 1)
 
     override fun current(): TimeZone = TimeZone.currentSystemDefault()
 }

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

@@ -4,7 +4,7 @@ import kotlinx.datetime.TimeZone
 
 /** Lower values appear first in lists and get the upper visible lanes in grids. */
 fun EventInstance.displayPriority(zone: TimeZone): Int = when {
-    isCrossedOut -> 3
+    isDeclined -> 3
     spansMultipleDays(zone) -> 0
     isAllDay -> 1
     else -> 2

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

@@ -42,8 +42,6 @@ data class EventForm(
     val reminders: List<Int> = emptyList(),
     val availability: Availability = Availability.Busy,
     val accessLevel: AccessLevel = AccessLevel.Default,
-    /** Confirmed / Tentative / Cancelled (#388). */
-    val status: EventStatus = EventStatus.Confirmed,
     /**
      * Bare RRULE value (`Events.RRULE` convention, no "RRULE:" prefix); null
      * means a one-off event. May hold rules the simple picker can't express —
@@ -115,7 +113,6 @@ enum class EventFormField {
     Reminders,
     Recurrence,
     Availability,
-    Status,
     Visibility,
     Color,
     Attendees,
@@ -151,21 +148,23 @@ enum class EventFormProblem {
 fun EventDetail.toEditForm(beginMillis: Long, endMillis: Long, zone: TimeZone): EventForm {
     // All-day events are date-anchored and carry a nominal "UTC" that is an
     // anchor, not a location, so they never pin a zone.
-    val pinned = if (instance.isAllDay) {
+    val pinnedZone = if (instance.isAllDay) {
         null
     } else {
         eventTimezone
             ?.takeIf { it != zone.id }
             // An unparseable id (a malformed sync row) can't be honoured or
             // shown; fall back to the device zone rather than failing the open.
-            ?.let { id -> zoneOrNull(id)?.let { id to it } }
+            ?.takeIf { runCatching { TimeZone.of(it) }.isSuccess }
     }
-    val pinnedZone = pinned?.first
-    val formZone = pinned?.second ?: zone
+    val formZone = pinnedZone?.let { TimeZone.of(it) } ?: zone
     val begin = Instant.fromEpochMilliseconds(beginMillis)
     val finish = Instant.fromEpochMilliseconds(endMillis)
     val (start, end) = if (instance.isAllDay) {
-        allDayFormTimes(begin.toLocalDateTime(TimeZone.UTC).date, finish.toLocalDateTime(TimeZone.UTC).date)
+        val startDate = begin.toLocalDateTime(TimeZone.UTC).date
+        val endExclusive = finish.toLocalDateTime(TimeZone.UTC).date
+        val endDate = maxOf(startDate, LocalDate.fromEpochDays(endExclusive.toEpochDays() - 1))
+        FormTime(LocalDateTime(startDate, LocalTime(9, 0))) to FormTime(LocalDateTime(endDate, LocalTime(10, 0)))
     } else {
         begin.toFormTime(formZone) to finish.toFormTime(formZone)
     }
@@ -181,8 +180,7 @@ fun EventDetail.toEditForm(beginMillis: Long, endMillis: Long, zone: TimeZone):
         reminders = reminders.map { it.minutes }.distinct().sorted(),
         availability = availability,
         accessLevel = accessLevel,
-        status = status,
-        rrule = rrule.normalizedRrule(),
+        rrule = rrule?.removePrefix("RRULE:")?.takeIf { it.isNotBlank() },
         // The provider fills EVENT_COLOR from the key, so [color] is the
         // swatch either way; a null colour means the event inherits its
         // calendar's colour.
@@ -217,7 +215,7 @@ fun EventDetail.toEditForm(beginMillis: Long, endMillis: Long, zone: TimeZone):
  * re-deriving with the same occurrence would mask an externally moved
  * event. Guests are covered (the form writes editable attendees), so an
  * external attendee change now also trips the conflict check. Still not
- * covered: the user's own response, reminder methods, the
+ * covered: status, the user's own response, reminder methods, the
  * organizer/resource rows, and a recurring event's duration.
  */
 data class EditSnapshot(
@@ -234,26 +232,6 @@ fun EventDetail.toEditSnapshot(beginMillis: Long, endMillis: Long, zone: TimeZon
         rowEnd = instance.end,
     )
 
-/**
- * Form times for an all-day span stored as UTC midnights with an exclusive
- * end: the last covered day (never before [start]), with placeholder
- * wall-clock times kept in case the user switches the event to timed.
- */
-internal fun allDayFormTimes(start: LocalDate, endExclusive: LocalDate?): Pair<FormTime, FormTime> {
-    val end = endExclusive?.let { maxOf(start, LocalDate.fromEpochDays(it.toEpochDays() - 1)) } ?: start
-    return FormTime(LocalDateTime(start, LocalTime(9, 0))) to FormTime(LocalDateTime(end, LocalTime(10, 0)))
-}
-
-/** The bare RRULE value the form edits; blank means none. */
-internal fun String?.normalizedRrule(): String? = this?.removePrefix("RRULE:")?.takeIf { it.isNotBlank() }
-
-/**
- * Whether this form may be saved as a single modified occurrence. A cancelled
- * exception row is how Android records a deleted occurrence, so a cancelled one
- * would vanish rather than show struck through (#388).
- */
-fun EventForm.canSaveAsOccurrence(): Boolean = status != EventStatus.Cancelled
-
 /**
  * Whether this form's times mean something else in [target] — a timed event
  * pinned to another zone. False when there's nothing to disambiguate: an
@@ -265,7 +243,8 @@ fun EventForm.canSaveAsOccurrence(): Boolean = status != EventStatus.Cancelled
  */
 fun EventForm.isPinnedAwayFrom(target: TimeZone): Boolean {
     if (isAllDay) return false
-    return resolvedZone(target).id != target.id
+    val pinned = timezone?.let { runCatching { TimeZone.of(it) }.getOrNull() } ?: return false
+    return pinned.id != target.id
 }
 
 /**
@@ -280,7 +259,6 @@ fun EventForm.populatedFields(): Set<EventFormField> = buildSet {
     if (reminders.isNotEmpty()) add(EventFormField.Reminders)
     if (rrule != null) add(EventFormField.Recurrence)
     if (availability != Availability.Busy) add(EventFormField.Availability)
-    if (status != EventStatus.Confirmed) add(EventFormField.Status)
     if (accessLevel != AccessLevel.Default) add(EventFormField.Visibility)
     if (colorKey != null || color != null) add(EventFormField.Color)
     if (attendees.isNotEmpty()) add(EventFormField.Attendees)

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

@@ -1,8 +1,8 @@
 package de.jeanlucmakiola.calendula.domain
 
 import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
-import kotlinx.datetime.YearMonth
 import kotlinx.datetime.atStartOfDayIn
 import kotlinx.datetime.number
 import kotlinx.datetime.plus
@@ -101,13 +101,19 @@ object EventSearch {
 
         val today = todayStart.toLocalDateTime(zone).date
         val matched = candidates.mapNotNull { candidate -> match(candidate, tokens, now, zone) }
-        val (upcoming, past) = matched.partition { it.event.spanLastDay(zone) >= today }
-        // What is left reads forwards; what is behind us reads backwards from
-        // today, nearest first.
-        val ordered = upcoming.sortedBy { it.event.dayStart(zone) } +
-            past.sortedByDescending { it.event.dayStart(zone) }
+        val upcoming = { m: Matched -> m.event.spanLastDay(zone) >= today }
+        val order = compareBy<Matched> { if (upcoming(it)) 0 else 1 }
+            .thenComparator { a, b ->
+                // What is left reads forwards; what is behind us reads backwards
+                // from today, nearest first.
+                if (upcoming(a)) {
+                    a.event.dayStart(zone).compareTo(b.event.dayStart(zone))
+                } else {
+                    b.event.dayStart(zone).compareTo(a.event.dayStart(zone))
+                }
+            }
 
-        val (inDescriptions, dated) = ordered.partition { it.descriptionOnly }
+        val (inDescriptions, dated) = matched.sortedWith(order).partition { it.descriptionOnly }
         return SearchResults(
             months = groupByMonth(dated, zone, todayStart),
             inDescriptions = inDescriptions.map { it.hit },
@@ -120,18 +126,33 @@ object EventSearch {
         zone: TimeZone,
         todayStart: Instant,
     ): List<SearchMonth> {
-        val current = todayStart.toLocalDateTime(zone).date.let { YearMonth(it.year, it.month) }
-        val groups = dated.groupBy { m -> m.event.spanFirstDay(zone).let { YearMonth(it.year, it.month) } }
-        val (behind, ahead) = groups.keys.partition { it < current }
-        return (ahead.sorted() + behind.sortedDescending()).map { month ->
-            SearchMonth(
-                year = month.year,
-                monthNumber = month.month.number,
-                hits = groups.getValue(month).map { it.hit },
+        val currentKey = monthKey(todayStart.toLocalDateTime(zone).date)
+        return dated
+            .groupBy { monthKey(it.event.spanFirstDay(zone)) }
+            .entries
+            .sortedWith(
+                compareBy<Map.Entry<Int, List<Matched>>> {
+                    when {
+                        it.key == currentKey -> 0
+                        it.key > currentKey -> 1
+                        else -> 2
+                    }
+                }.thenComparator { a, b ->
+                    if (a.key > currentKey) a.key.compareTo(b.key) else b.key.compareTo(a.key)
+                },
             )
-        }
+            .map { (key, entries) ->
+                SearchMonth(
+                    year = key / 12,
+                    monthNumber = key % 12 + 1,
+                    hits = entries.map { it.hit },
+                )
+            }
     }
 
+    /** Year and month as one comparable number. */
+    private fun monthKey(date: LocalDate): Int = date.year * 12 + (date.month.number - 1)
+
     private fun match(
         candidate: SearchCandidate,
         tokens: List<String>,

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

@@ -17,15 +17,12 @@ import kotlin.time.Instant
 import kotlin.time.toJavaInstant
 import kotlin.time.toKotlinInstant
 
-/** [id] as a zone, or null when the tz database doesn't know it. */
-internal fun zoneOrNull(id: String): TimeZone? = runCatching { TimeZone.of(id) }.getOrNull()
-
 /**
  * The zone this form's wall-clock times mean, matching what the data layer
  * resolves them in at write time: the form's own pinned zone, else [deviceZone].
  */
 fun EventForm.resolvedZone(deviceZone: TimeZone): TimeZone =
-    timezone?.let(::zoneOrNull) ?: deviceZone
+    timezone?.let { runCatching { TimeZone.of(it) }.getOrNull() } ?: deviceZone
 
 /**
  * This wall-clock time in [zone], at [preferred] when the fall-back hour repeats

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

@@ -131,10 +131,6 @@ private class HtmlRenderer(private val html: String) {
             text("<")
             return lt + 1
         }
-        if (!closing && isAutolink(html.substring(nameStart, end))) {
-            text(html.substring(lt, end + 1))
-            return end + 1
-        }
         var nameEnd = nameStart
         while (nameEnd < end && (html[nameEnd].isLetterOrDigit() || html[nameEnd] == ':')) nameEnd++
         val name = html.substring(nameStart, nameEnd).lowercase()
@@ -153,11 +149,6 @@ private class HtmlRenderer(private val html: String) {
         return end + 1
     }
 
-    /** An angle-bracketed URL or address (`<https://…>`, `<a@b.c>`), kept as text. */
-    private fun isAutolink(inner: String): Boolean =
-        LINK_SCHEMES.any { inner.startsWith(it, ignoreCase = true) } ||
-            ('@' in inner && inner.none { it.isWhitespace() || it == '=' })
-
     /** The `>` closing the tag at [lt], skipping any inside quoted attributes. */
     private fun tagEnd(lt: Int): Int {
         var quote: Char? = null

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

@@ -1,5 +1,8 @@
 package de.jeanlucmakiola.calendula.domain
 
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Duration.Companion.hours
@@ -32,11 +35,17 @@ fun buildInsertEventForm(
     now: Instant,
 ): EventForm {
     val (start, end) = if (isAllDay) {
+        // All-day provider times are UTC midnights with an exclusive end; show
+        // the last covered day and keep placeholder wall-clock times in case the
+        // user switches the event to timed (mirrors EventDetail.toEditForm).
         val startDate = beginMillis
             ?.let { Instant.fromEpochMilliseconds(it).toLocalDateTime(TimeZone.UTC).date }
             ?: now.toLocalDateTime(zone).date
-        val endExclusive = endMillis?.let { Instant.fromEpochMilliseconds(it).toLocalDateTime(TimeZone.UTC).date }
-        allDayFormTimes(startDate, endExclusive)
+        val endDate = endMillis
+            ?.let { Instant.fromEpochMilliseconds(it).toLocalDateTime(TimeZone.UTC).date }
+            ?.let { exclusive -> maxOf(startDate, LocalDate.fromEpochDays(exclusive.toEpochDays() - 1)) }
+            ?: startDate
+        FormTime(LocalDateTime(startDate, LocalTime(9, 0))) to FormTime(LocalDateTime(endDate, LocalTime(10, 0)))
     } else {
         val startAt = beginMillis?.let(Instant::fromEpochMilliseconds) ?: nextFullHour(now)
         val endAt = endMillis?.let(Instant::fromEpochMilliseconds)?.takeIf { it >= startAt }
@@ -53,7 +62,7 @@ fun buildInsertEventForm(
         description = description.orEmpty(),
         // Bare RRULE value (Events.RRULE convention); tolerate a leading "RRULE:"
         // some callers include.
-        rrule = rrule.normalizedRrule(),
+        rrule = rrule?.removePrefix("RRULE:")?.takeIf { it.isNotBlank() },
     )
 }
 

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

@@ -2,7 +2,6 @@ package de.jeanlucmakiola.calendula.domain
 
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
-import kotlinx.datetime.atStartOfDayIn
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.Instant
@@ -73,8 +72,6 @@ data class EventInstance(
      * (#180, #230).
      */
     val response: EventResponse = EventResponse.Going,
-    /** The event's own Confirmed / Tentative / Cancelled (`Events.STATUS`, #388). */
-    val status: EventStatus = EventStatus.Confirmed,
 )
 
 /**
@@ -97,33 +94,16 @@ enum class EventResponse {
     Declined,
 }
 
-/**
- * Struck through on every surface and sorted last: an invitation you declined
- * (#180), or an event its organizer cancelled (#388). Neither plans reminders.
- */
-val EventInstance.isCrossedOut: Boolean
-    get() = response == EventResponse.Declined || status == EventStatus.Cancelled
-
-/**
- * Drawn as an outline, still undecided: an invitation you have not answered
- * (#230), or a tentative event (#388).
- */
-val EventInstance.isOutlined: Boolean
-    get() = !isCrossedOut && (response == EventResponse.Invited || status == EventStatus.Tentative)
+/** Shorthand for the declined case, which most surfaces test on its own (#180). */
+val EventInstance.isDeclined: Boolean get() = response == EventResponse.Declined
 
 /**
  * Whether this event has finished relative to [now] — its end is at or before
  * the current instant. An in-progress event (already started but not yet ended)
- * is *not* considered ended. All-day events end at the exclusive next-midnight
- * in [zone] rather than the UTC midnight they are stored on, so they only count
- * as ended once their local day is fully over.
+ * is *not* considered ended. All-day events end at the exclusive next-midnight,
+ * so they only count as ended once their day is fully over.
  */
-fun EventInstance.hasEnded(now: Instant, zone: TimeZone = TimeZone.currentSystemDefault()): Boolean =
-    localEnd(zone) <= now
-
-/** [EventInstance.end], with an all-day event's UTC midnight moved to local midnight in [zone]. */
-fun EventInstance.localEnd(zone: TimeZone): Instant =
-    if (isAllDay) end.toLocalDateTime(TimeZone.UTC).date.atStartOfDayIn(zone) else end
+fun EventInstance.hasEnded(now: Instant): Boolean = end <= now
 
 /**
  * The zone this event's calendar dates live in: the device [zone] for timed

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

@@ -1,8 +1,5 @@
 package de.jeanlucmakiola.calendula.domain
 
-import de.jeanlucmakiola.calendula.domain.ics.parseBasicDate
-import de.jeanlucmakiola.calendula.domain.ics.parseBasicDateTime
-import de.jeanlucmakiola.calendula.domain.ics.toUtcBasic
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
@@ -60,13 +57,24 @@ fun parseSimpleRecurrence(
     rrule: String,
     zone: TimeZone = TimeZone.currentSystemDefault(),
 ): SimpleRecurrence? {
-    val parts = rruleParts(rrule).associate { part -> (part.key ?: return null) to part.value }
+    val parts = rrule.removePrefix("RRULE:").split(';')
+        .filter { it.isNotBlank() }
+        .associate { token ->
+            val eq = token.indexOf('=')
+            if (eq <= 0) return null
+            token.substring(0, eq).uppercase() to token.substring(eq + 1)
+        }
     if (parts.keys.any { it !in setOf("FREQ", "INTERVAL", "UNTIL", "COUNT", "WKST", "BYDAY") }) {
         return null
     }
 
-    val freq = RecurrenceFreq.entries.firstOrNull { it.name.equals(parts["FREQ"], ignoreCase = true) }
-        ?: return null
+    val freq = when (parts["FREQ"]?.uppercase()) {
+        "DAILY" -> RecurrenceFreq.Daily
+        "WEEKLY" -> RecurrenceFreq.Weekly
+        "MONTHLY" -> RecurrenceFreq.Monthly
+        "YEARLY" -> RecurrenceFreq.Yearly
+        else -> return null
+    }
     val interval = parts["INTERVAL"]?.let { it.toIntOrNull()?.takeIf { n -> n >= 1 } ?: return null } ?: 1
 
     // BYDAY is simple only as plain weekday picks on a weekly rule; ordinal
@@ -116,27 +124,20 @@ fun SimpleRecurrence.toRRule(zone: TimeZone = TimeZone.currentSystemDefault()):
     when (val e = end) {
         RecurrenceEnd.Never -> Unit
         is RecurrenceEnd.Until -> {
-            append(";UNTIL=")
-            append(LocalDateTime(e.date, LocalTime(23, 59, 59)).toInstant(zone).toUtcBasic())
+            val utc = LocalDateTime(e.date, LocalTime(23, 59, 59))
+                .toInstant(zone)
+                .toLocalDateTime(TimeZone.UTC)
+            append(
+                ";UNTIL=%04d%02d%02dT%02d%02d%02dZ".format(
+                    utc.year, utc.month.number, utc.day,
+                    utc.hour, utc.minute, utc.second,
+                ),
+            )
         }
         is RecurrenceEnd.Count -> append(";COUNT=${e.times}")
     }
 }
 
-/** One `;`-separated part of an RRULE as written; [key] is null when it has no `KEY=`. */
-internal class RrulePart(val raw: String) {
-    private val eq = raw.indexOf('=')
-    val key: String? = if (eq > 0) raw.substring(0, eq).uppercase() else null
-    val value: String = if (eq > 0) raw.substring(eq + 1) else ""
-}
-
-/**
- * [rule]'s non-blank parts, after an optional leading "RRULE:". What to do
- * with a malformed one (reject, repair or skip) is the caller's call.
- */
-internal fun rruleParts(rule: String): List<RrulePart> =
-    rule.removePrefix("RRULE:").split(';').filter { it.isNotBlank() }.map(::RrulePart)
-
 internal val RRULE_DAY_CODES: Map<DayOfWeek, String> = mapOf(
     DayOfWeek.MONDAY to "MO",
     DayOfWeek.TUESDAY to "TU",
@@ -164,7 +165,11 @@ fun rruleTruncatedAt(rrule: String, untilUtcMillis: Long): String {
             val key = part.substringBefore('=').trim().uppercase()
             key == "UNTIL" || key == "COUNT"
         }
-    val untilPart = "UNTIL=" + Instant.fromEpochMilliseconds(untilUtcMillis).toUtcBasic()
+    val until = Instant.fromEpochMilliseconds(untilUtcMillis).toLocalDateTime(TimeZone.UTC)
+    val untilPart = "UNTIL=%04d%02d%02dT%02d%02d%02dZ".format(
+        until.year, until.month.number, until.day,
+        until.hour, until.minute, until.second,
+    )
     return (kept + untilPart).joinToString(";")
 }
 
@@ -173,8 +178,20 @@ fun rruleTruncatedAt(rrule: String, untilUtcMillis: Long): String {
  * forms are UTC (RFC 5545); the date is taken after converting into [zone] so
  * a [toRRule]-rendered value round-trips to the day the user picked.
  */
-private fun parseUntilDate(raw: String, zone: TimeZone): LocalDate? {
-    val date = parseBasicDate(raw) ?: return null
-    if (raw.length < 15 || raw[8] != 'T') return date
-    return parseBasicDateTime(raw)?.toInstant(TimeZone.UTC)?.toLocalDateTime(zone)?.date
-}
+private fun parseUntilDate(raw: String, zone: TimeZone): LocalDate? = runCatching {
+    val date = LocalDate(
+        raw.substring(0, 4).toInt(),
+        raw.substring(4, 6).toInt(),
+        raw.substring(6, 8).toInt(),
+    )
+    if (raw.length >= 15 && raw[8] == 'T') {
+        val time = LocalTime(
+            raw.substring(9, 11).toInt(),
+            raw.substring(11, 13).toInt(),
+            raw.substring(13, 15).toInt(),
+        )
+        LocalDateTime(date, time).toInstant(TimeZone.UTC).toLocalDateTime(zone).date
+    } else {
+        date
+    }
+}.getOrNull()

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

@@ -19,30 +19,30 @@ import kotlinx.datetime.LocalDate
 fun realignRecurrence(rrule: String, oldStart: LocalDate, newStart: LocalDate): String? {
     if (oldStart == newStart) return rrule
     val prefix = if (rrule.startsWith("RRULE:")) "RRULE:" else ""
-    val parts = rruleParts(rrule)
+    val parts = rrule.removePrefix("RRULE:").split(';').filter { it.isNotBlank() }
     if (parts.isEmpty()) return null
-    var freq = false
     var weekly = false
-    var byDay = false
     val rebuilt = parts.map { part ->
-        val value = part.value.trim()
-        when (part.key) {
+        val eq = part.indexOf('=')
+        if (eq <= 0) return null
+        val key = part.substring(0, eq).uppercase()
+        val value = part.substring(eq + 1).trim()
+        when (key) {
             "FREQ" -> {
-                freq = true
                 weekly = value.equals("WEEKLY", ignoreCase = true)
-                part.raw
+                part
             }
             "BYDAY" -> {
-                byDay = true
                 val old = RRULE_DAY_CODES[oldStart.dayOfWeek] ?: return null
                 if (!value.equals(old, ignoreCase = true)) return null
                 "BYDAY=${RRULE_DAY_CODES.getValue(newStart.dayOfWeek)}"
             }
-            "INTERVAL", "COUNT", "UNTIL", "WKST" -> part.raw
+            "INTERVAL", "COUNT", "UNTIL", "WKST" -> part
             else -> return null
         }
     }
     // BYDAY is only simple on a weekly rule, matching parseSimpleRecurrence.
-    if (!freq || (byDay && !weekly)) return null
+    if (!weekly && parts.any { it.substringBefore('=').trim().uppercase() == "BYDAY" }) return null
+    if (parts.none { it.substringBefore('=').trim().uppercase() == "FREQ" }) return null
     return prefix + rebuilt.joinToString(";")
 }

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

@@ -1,47 +0,0 @@
-package de.jeanlucmakiola.calendula.domain.ics
-
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.LocalDateTime
-import kotlinx.datetime.LocalTime
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.format
-import kotlinx.datetime.format.char
-import kotlinx.datetime.toLocalDateTime
-import kotlin.time.Instant
-
-/** RFC 5545 basic format, `yyyyMMddTHHmmss`. */
-private val BASIC_DATE_TIME = LocalDateTime.Format {
-    date(LocalDate.Formats.ISO_BASIC)
-    char('T')
-    hour()
-    minute()
-    second()
-}
-
-/** `yyyyMMdd`. */
-internal fun LocalDate.toBasic(): String = format(LocalDate.Formats.ISO_BASIC)
-
-/** `yyyyMMddTHHmmss`, floating. */
-internal fun LocalDateTime.toBasic(): String = format(BASIC_DATE_TIME)
-
-/** `yyyyMMddTHHmmssZ`, the instant in UTC. */
-internal fun Instant.toUtcBasic(): String = toLocalDateTime(TimeZone.UTC).toBasic() + "Z"
-
-/**
- * The date in the first eight characters of a basic-format value; whatever
- * follows (a time, a `Z`) is ignored. Null when those aren't a valid date.
- */
-internal fun parseBasicDate(s: String): LocalDate? = runCatching {
-    LocalDate(s.substring(0, 4).toInt(), s.substring(4, 6).toInt(), s.substring(6, 8).toInt())
-}.getOrNull()
-
-/** `yyyyMMddTHHmm[ss]`; the separator isn't checked and missing seconds read as zero. */
-internal fun parseBasicDateTime(s: String): LocalDateTime? = runCatching {
-    val date = parseBasicDate(s) ?: return null
-    val time = LocalTime(
-        s.substring(9, 11).toInt(),
-        s.substring(11, 13).toInt(),
-        if (s.length >= 15) s.substring(13, 15).toInt() else 0,
-    )
-    LocalDateTime(date, time)
-}.getOrNull()

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

@@ -2,17 +2,19 @@ package de.jeanlucmakiola.calendula.domain.ics
 
 import de.jeanlucmakiola.calendula.domain.Availability
 import de.jeanlucmakiola.calendula.domain.EventStatus
-import de.jeanlucmakiola.calendula.domain.zoneOrNull
+import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.number
 import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
 import kotlin.math.ceil
-import kotlin.time.Duration.Companion.days
-import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.Instant
 
+/** Milliseconds in a calendar day; all-day times are UTC midnights, so this is exact. */
+private const val DAY_MILLIS = 86_400_000L
 private const val MINUTES_PER_DAY = 1_440
 
 /**
@@ -316,9 +318,13 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
         dtEnd: IcsDateTime?,
         duration: String?,
     ): Instant {
-        val explicit = dtEnd?.instant ?: duration?.let { start.instant + parseRfc2445DurationMillis(it).milliseconds }
+        val explicit = dtEnd?.instant ?: duration?.let {
+            Instant.fromEpochMilliseconds(
+                start.instant.toEpochMilliseconds() + parseRfc2445DurationMillis(it),
+            )
+        }
         if (!start.isAllDay) return explicit ?: start.instant
-        return explicit?.takeIf { it > start.instant } ?: (start.instant + 1.days)
+        return explicit?.takeIf { it > start.instant } ?: start.instant.plusDays(1)
     }
 
     /**
@@ -337,17 +343,17 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
      */
     private fun normalizeExDates(lines: List<IcsContentLine>, start: IcsDateTime): List<String> {
         if (lines.isEmpty()) return emptyList()
-        val startZone = zoneOrNull(start.zoneId) ?: deviceZone
+        val startZone = runCatching { TimeZone.of(start.zoneId) }.getOrNull() ?: deviceZone
         val startTime = start.instant.toLocalDateTime(startZone).time
         return lines
             .flatMap { line -> line.value.split(',').map { line to it.trim() } }
             .mapNotNull { (line, token) ->
                 when {
                     token.isEmpty() -> null
-                    start.isAllDay -> parseBasicDate(token.substringBefore('T'))?.toBasic()
-                    token.contains('T') -> parseExDateTime(token, line, startZone)?.toUtcBasic()
+                    start.isAllDay -> parseBasicDate(token.substringBefore('T'))?.let(::dayCode)
+                    token.contains('T') -> parseExDateTime(token, line, startZone)?.let(::utcStamp)
                     else -> parseBasicDate(token)
-                        ?.let { LocalDateTime(it, startTime).toInstant(startZone).toUtcBasic() }
+                        ?.let { utcStamp(LocalDateTime(it, startTime).toInstant(startZone)) }
                 }
             }
             .distinct()
@@ -367,7 +373,7 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
         val ldt = parseBasicDateTime(token.removeSuffix("Z")) ?: return null
         val zone = when {
             token.endsWith("Z") -> TimeZone.UTC
-            else -> line.params["TZID"]?.let(::zoneOrNull)
+            else -> line.params["TZID"]?.let { runCatching { TimeZone.of(it) }.getOrNull() }
                 ?: startZone
         }
         return ldt.toInstant(zone)
@@ -403,7 +409,7 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
         if (isUtc) return IcsDateTime(ldt.toInstant(TimeZone.UTC), isAllDay = false, zoneId = "UTC")
 
         val tzid = line.params["TZID"]
-        val resolved = tzid?.let { id -> zoneOrNull(id)?.let { id to it } }
+        val resolved = tzid?.let { id -> runCatching { TimeZone.of(id) }.getOrNull()?.let { id to it } }
         if (tzid != null && resolved == null) warnings.add(IcsParseWarning.UnknownTimezone)
         val (zoneId, zone) = resolved ?: (deviceZone.id to deviceZone)
         return IcsDateTime(ldt.toInstant(zone), isAllDay = false, zoneId = zoneId)
@@ -415,6 +421,16 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
         fun IcsContentLine.isBegin(component: String) =
             name == "BEGIN" && value.trim().equals(component, true)
 
+        fun Instant.plusDays(days: Int): Instant =
+            Instant.fromEpochMilliseconds(toEpochMilliseconds() + days * DAY_MILLIS)
+
+        fun dayCode(date: LocalDate): String =
+            "%04d%02d%02d".format(date.year, date.month.number, date.day)
+
+        fun utcStamp(instant: Instant): String = with(instant.toLocalDateTime(TimeZone.UTC)) {
+            "%04d%02d%02dT%02d%02d%02dZ".format(year, month.number, day, hour, minute, second)
+        }
+
         /**
          * A single-valued `CATEGORIES`, which is what the Fossify family writes
          * for the source calendar's name. A multi-item list is a tag list and
@@ -433,26 +449,59 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
                 .takeIf { it.isNotEmpty() && !it.equals("null", true) }
         }
 
+        /** 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 =
-            (from until end).firstOrNull { i ->
+        fun indexOfNextComponent(lines: List<String>, from: Int, end: Int): Int {
+            var i = from
+            while (i < end) {
                 val line = parseContentLine(lines[i])
-                line != null && (line.isBegin("VEVENT") || line.isBegin("VTODO"))
-            } ?: end
+                if (line != null && (line.isBegin("VEVENT") || line.isBegin("VTODO"))) {
+                    return i
+                }
+                i++
+            }
+            return end
+        }
 
-        /** Index of the matching `END:<component>` at/after [from], or list end. */
-        fun indexOfEnd(lines: List<String>, from: Int, component: String): Int =
-            (from until lines.size).firstOrNull { i ->
+        fun indexOfEnd(lines: List<String>, from: Int, component: String): Int {
+            var i = from
+            while (i < lines.size) {
                 val line = parseContentLine(lines[i])
-                line != null && line.name == "END" && line.value.trim().equals(component, true)
-            } ?: lines.size
+                if (line != null && line.name == "END" &&
+                    line.value.trim().equals(component, true)
+                ) {
+                    return i
+                }
+                i++
+            }
+            return lines.size
+        }
 
-        fun mapIcsStatus(value: String): EventStatus =
-            EventStatus.entries.firstOrNull { it.name.equals(value.trim(), ignoreCase = true) }
-                ?: EventStatus.Confirmed
+        fun mapIcsStatus(value: String): EventStatus = when (value.trim().uppercase()) {
+            "TENTATIVE" -> EventStatus.Tentative
+            "CANCELLED" -> EventStatus.Cancelled
+            else -> EventStatus.Confirmed
+        }
+
+        fun parseBasicDate(s: String): LocalDate? = runCatching {
+            LocalDate(s.substring(0, 4).toInt(), s.substring(4, 6).toInt(), s.substring(6, 8).toInt())
+        }.getOrNull()
+
+        fun parseBasicDateTime(s: String): LocalDateTime? = runCatching {
+            val date = LocalDate(
+                s.substring(0, 4).toInt(), s.substring(4, 6).toInt(), s.substring(6, 8).toInt(),
+            )
+            // Format is YYYYMMDD 'T' HHMMSS; seconds optional.
+            val time = LocalTime(
+                s.substring(9, 11).toInt(),
+                s.substring(11, 13).toInt(),
+                if (s.length >= 15) s.substring(13, 15).toInt() else 0,
+            )
+            LocalDateTime(date, time)
+        }.getOrNull()
     }
 }

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

@@ -1,7 +1,5 @@
 package de.jeanlucmakiola.calendula.domain.ics
 
-import de.jeanlucmakiola.calendula.domain.rruleParts
-
 private val VALID_FREQ = setOf(
     "SECONDLY", "MINUTELY", "HOURLY", "DAILY", "WEEKLY", "MONTHLY", "YEARLY",
 )
@@ -66,9 +64,7 @@ data class SanitizedRrule(val rule: String?, val repaired: Boolean)
  * rule at all — gives up entirely.
  */
 fun sanitizeRrule(raw: String?): SanitizedRrule {
-    val rule = raw?.trim()
-        ?.let { if (it.startsWith("RRULE:", ignoreCase = true)) it.drop("RRULE:".length) else it }
-        ?.trim().orEmpty()
+    val rule = raw?.trim()?.removePrefix("RRULE:")?.trim().orEmpty()
     if (rule.isEmpty()) return SanitizedRrule(rule = null, repaired = false)
 
     var freqSeen = false
@@ -83,12 +79,13 @@ fun sanitizeRrule(raw: String?): SanitizedRrule {
         return kept.takeIf { it.isNotEmpty() }?.joinToString(",")
     }
 
-    // A stray separator ("FREQ=DAILY;") normalises away; nothing was lost.
-    // A part that carries text but no '=' ("FREQ=WEEKLY;BYDAY") is a part
-    // being dropped, so it falls through and marks the rule repaired.
-    for (part in rruleParts(rule)) {
-        val key = part.key?.trim()?.uppercase().orEmpty()
-        val value = part.value.trim()
+    for (part in rule.split(';')) {
+        // A stray separator ("FREQ=DAILY;") normalises away; nothing was lost.
+        // A part that carries text but no '=' ("FREQ=WEEKLY;BYDAY") is a part
+        // being dropped, so it falls through and marks the rule repaired.
+        if (part.isBlank()) continue
+        val key = part.substringBefore('=', "").trim().uppercase()
+        val value = if ('=' in part) part.substringAfter('=').trim() else ""
         val kept = when {
             key.isEmpty() || value.isEmpty() -> null
             key == "FREQ" ->

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

@@ -2,8 +2,9 @@ package de.jeanlucmakiola.calendula.domain.ics
 
 import de.jeanlucmakiola.calendula.domain.Availability
 import de.jeanlucmakiola.calendula.domain.EventStatus
-import de.jeanlucmakiola.calendula.domain.zoneOrNull
+import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.TimeZone
+import kotlinx.datetime.number
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Instant
 
@@ -40,7 +41,7 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) {
     private fun MutableList<String>.appendEvent(event: IcsEvent, dtStamp: Instant) {
         add("BEGIN:VEVENT")
         add("UID:${event.uid}")
-        add("DTSTAMP:${dtStamp.toUtcBasic()}")
+        add("DTSTAMP:${utcStamp(dtStamp)}")
         add("SUMMARY:${escapeText(event.summary)}")
         appendTimes(event)
         event.recurrenceRule?.takeIf { it.isNotBlank() }
@@ -62,24 +63,24 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) {
 
     private fun MutableList<String>.appendTimes(event: IcsEvent) = when {
         event.isAllDay -> {
-            add("DTSTART;VALUE=DATE:${event.start.toLocalDateTime(TimeZone.UTC).date.toBasic()}")
-            add("DTEND;VALUE=DATE:${event.end.toLocalDateTime(TimeZone.UTC).date.toBasic()}")
+            add("DTSTART;VALUE=DATE:${utcDate(event.start)}")
+            add("DTEND;VALUE=DATE:${utcDate(event.end)}")
         }
         // Recurring: anchor to wall-clock in the event's own zone.
         event.recurrenceRule?.isNotBlank() == true -> {
-            val zone = zoneOrNull(event.zoneId)
+            val zone = runCatching { TimeZone.of(event.zoneId) }.getOrNull()
             if (zone != null) {
-                add("DTSTART;TZID=${event.zoneId}:${event.start.toLocalDateTime(zone).toBasic()}")
-                add("DTEND;TZID=${event.zoneId}:${event.end.toLocalDateTime(zone).toBasic()}")
+                add("DTSTART;TZID=${event.zoneId}:${localStamp(event.start, zone)}")
+                add("DTEND;TZID=${event.zoneId}:${localStamp(event.end, zone)}")
             } else {
                 // Unknown zone id → fall back to plain UTC instants.
-                add("DTSTART:${event.start.toUtcBasic()}")
-                add("DTEND:${event.end.toUtcBasic()}")
+                add("DTSTART:${utcStamp(event.start)}")
+                add("DTEND:${utcStamp(event.end)}")
             }
         }
         else -> {
-            add("DTSTART:${event.start.toUtcBasic()}")
-            add("DTEND:${event.end.toUtcBasic()}")
+            add("DTSTART:${utcStamp(event.start)}")
+            add("DTEND:${utcStamp(event.end)}")
         }
     }
 
@@ -119,5 +120,20 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) {
         // A lead time of 0 fires at start (PT0M); anything positive is "before".
         fun triggerValue(minutes: Int): String =
             if (minutes <= 0) "PT0M" else "-PT${minutes}M"
+
+        fun utcStamp(instant: Instant): String =
+            basic(instant.toLocalDateTime(TimeZone.UTC)) + "Z"
+
+        fun localStamp(instant: Instant, zone: TimeZone): String =
+            basic(instant.toLocalDateTime(zone))
+
+        fun utcDate(instant: Instant): String {
+            val dt = instant.toLocalDateTime(TimeZone.UTC)
+            return "%04d%02d%02d".format(dt.year, dt.month.number, dt.day)
+        }
+
+        fun basic(dt: LocalDateTime): String = "%04d%02d%02dT%02d%02d%02d".format(
+            dt.year, dt.month.number, dt.day, dt.hour, dt.minute, dt.second,
+        )
     }
 }

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

@@ -1,9 +1,11 @@
 package de.jeanlucmakiola.calendula.domain.ics
 
 import de.jeanlucmakiola.calendula.domain.EventForm
-import de.jeanlucmakiola.calendula.domain.allDayFormTimes
-import de.jeanlucmakiola.calendula.domain.normalizedRrule
+import de.jeanlucmakiola.calendula.domain.FormTime
 import de.jeanlucmakiola.calendula.domain.toFormTime
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toLocalDateTime
 
@@ -21,7 +23,10 @@ import kotlinx.datetime.toLocalDateTime
  */
 fun ParsedIcsEvent.toEventForm(zone: TimeZone): EventForm {
     val (start, end) = if (isAllDay) {
-        allDayFormTimes(this.start.toLocalDateTime(TimeZone.UTC).date, this.end.toLocalDateTime(TimeZone.UTC).date)
+        val startDate = this.start.toLocalDateTime(TimeZone.UTC).date
+        val endExclusive = this.end.toLocalDateTime(TimeZone.UTC).date
+        val endDate = maxOf(startDate, LocalDate.fromEpochDays(endExclusive.toEpochDays() - 1))
+        FormTime(LocalDateTime(startDate, LocalTime(9, 0))) to FormTime(LocalDateTime(endDate, LocalTime(10, 0)))
     } else {
         this.start.toFormTime(zone) to this.end.toFormTime(zone)
     }
@@ -35,7 +40,6 @@ fun ParsedIcsEvent.toEventForm(zone: TimeZone): EventForm {
         description = description.orEmpty(),
         reminders = semanticReminderMinutes(),
         availability = availability,
-        status = status,
-        rrule = recurrenceRule.normalizedRrule(),
+        rrule = recurrenceRule?.removePrefix("RRULE:")?.takeIf { it.isNotBlank() },
     )
 }

app/src/main/java/de/jeanlucmakiola/calendula/domain/reminders/ReminderPlan.kt

@@ -32,26 +32,19 @@ data class PlannedReminder(
     val minutes: Int,
     val alarmMillis: Long,
 ) {
-    /** The occurrence this reminder belongs to; it shares one notification with its siblings (#463). */
-    val occurrenceKey: Long = occurrenceKey(instance.eventId, instance.beginMillis)
-
     /**
-     * Stable identity of this one reminder, keying the snooze/dismiss
+     * Stable identity, keying the notification tag and the snooze/dismiss
      * `PendingIntent`s. Survives reboot, re-scan and reinstall.
      */
-    val key: Long = mix64(occurrenceKey + minutes)
-}
+    val key: Long = key(instance.eventId, instance.beginMillis, minutes)
 
-/** Stable identity of one occurrence, shared by every reminder on it. */
-fun occurrenceKey(eventId: Long, beginMillis: Long): Long =
-    mix64(mix64(eventId) + beginMillis)
-
-/** SplitMix64's finaliser: spreads close inputs across all 64 bits. */
-private fun mix64(value: Long): Long {
-    var z = value + -0x61c8864680b583ebL
-    z = (z xor (z ushr 30)) * -0x40a7b892e31b1a47L
-    z = (z xor (z ushr 27)) * -0x6b2fb644ecceee15L
-    return z xor (z ushr 31)
+    private companion object {
+        fun key(eventId: Long, beginMillis: Long, minutes: Int): Long {
+            var h = eventId * 1_000_003L
+            h = (h xor beginMillis) * 31L
+            return h + minutes
+        }
+    }
 }
 
 /** What one scan concluded: post these now, and wake up again at [nextAlarmMillis]. */
@@ -153,8 +146,7 @@ private fun allDayAlarmMillis(
  *
  * Due means the fire instant falls in `(lastFiredMillis, nowMillis]`, so a scan
  * running twice cannot post twice while a late one still catches up. Reminders
- * whose event has ended are dropped ([isStillRelevant]), and of several due on
- * one occurrence only the latest is kept — they'd replace each other anyway (#463). [nextAlarmMillis] is
+ * whose event has ended are dropped ([isStillRelevant]). [nextAlarmMillis] is
  * capped at [horizonMillis] so the lookahead window keeps rolling forward.
  */
 fun scheduleReminders(
@@ -166,8 +158,7 @@ fun scheduleReminders(
     val due = planned
         .filter { it.alarmMillis in (lastFiredMillis + 1)..nowMillis }
         .filter { it.instance.isStillRelevant(nowMillis) }
-        .groupBy { it.occurrenceKey }
-        .values.map { siblings -> siblings.maxBy { it.alarmMillis } }
+        .distinctBy { it.key }
         .sortedWith(compareBy({ it.instance.beginMillis }, { it.key }))
     val nextPending = planned
         .filter { it.alarmMillis > nowMillis }

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

@@ -4,10 +4,8 @@ import androidx.activity.compose.BackHandler
 import androidx.activity.compose.PredictiveBackHandler
 import androidx.compose.animation.AnimatedContent
 import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.AnimatedVisibilityScope
 import androidx.compose.animation.ExperimentalSharedTransitionApi
 import androidx.compose.animation.SharedTransitionLayout
-import androidx.compose.animation.core.MutableTransitionState
 import androidx.compose.animation.core.SeekableTransitionState
 import androidx.compose.animation.core.rememberTransition
 import androidx.compose.animation.fadeIn
@@ -30,12 +28,10 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.saveable.Saver
 import androidx.compose.runtime.saveable.listSaver
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.Modifier
-import de.jeanlucmakiola.calendula.ui.common.rememberHeld
 import de.jeanlucmakiola.calendula.ui.common.screen
 import de.jeanlucmakiola.calendula.ui.common.ViewScreen
 import androidx.compose.ui.layout.onGloballyPositioned
@@ -43,7 +39,6 @@ import androidx.compose.ui.layout.positionInWindow
 import androidx.compose.ui.platform.LocalDensity
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import de.jeanlucmakiola.calendula.data.time.currentDate
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.ui.agenda.AgendaScreen
@@ -68,7 +63,7 @@ import de.jeanlucmakiola.calendula.ui.common.EventSelectionHost
 import de.jeanlucmakiola.calendula.ui.common.eventActionFailureMessage
 import de.jeanlucmakiola.calendula.ui.common.rememberFabSelection
 import de.jeanlucmakiola.calendula.ui.common.canWriteCalendar
-import de.jeanlucmakiola.calendula.ui.common.rememberWriteAction
+import de.jeanlucmakiola.calendula.ui.common.rememberWriteGateOr
 import de.jeanlucmakiola.calendula.ui.common.EventMoveScope
 import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
 import de.jeanlucmakiola.calendula.ui.common.LocalManageCalendars
@@ -104,6 +99,7 @@ import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toLocalDateTime
 import kotlin.coroutines.cancellation.CancellationException
+import kotlin.time.Clock
 import kotlin.time.Instant
 
 /**
@@ -120,18 +116,29 @@ import kotlin.time.Instant
  * view remains. So back from a widget-opened screen returns to that widget's
  * view, then home; and back through pill switches walks the views in reverse.
  *
- * [requests] carries what notifications, widgets and other apps asked to
- * open. A tapped reminder's occurrence opens the detail overlay exactly like an
- * event tap; each request is cleared once acted on so a later recomposition
- * can't re-open it. (A widget event tap instead arrives as
- * [WidgetNavRequest.OpenEvent], which also roots the back stack in the widget's
- * view.)
+ * [requestedDetailKey] is an externally requested occurrence (a tapped
+ * reminder notification routed through MainActivity): it opens the detail
+ * overlay exactly like an event tap and is cleared via [onDetailKeyConsumed]
+ * so a later recomposition can't re-open it. (A widget event tap instead arrives
+ * as [WidgetNavRequest.OpenEvent], which also roots the back stack in the
+ * widget's view.)
  */
 @OptIn(ExperimentalSharedTransitionApi::class)
 @Composable
 fun CalendarHost(
-    requests: ExternalRequests,
     modifier: Modifier = Modifier,
+    requestedDetailKey: LongArray? = null,
+    onDetailKeyConsumed: () -> Unit = {},
+    widgetNavRequest: WidgetNavRequest? = null,
+    onWidgetNavConsumed: () -> Unit = {},
+    requestedImportUri: android.net.Uri? = null,
+    onImportConsumed: () -> Unit = {},
+    requestedInsertForm: EventForm? = null,
+    requestedInsertSource: ImportSource = ImportSource.Insert,
+    onInsertConsumed: () -> Unit = {},
+    onExternalFormClosed: () -> Unit = {},
+    requestedEditKey: LongArray? = null,
+    onEditKeyConsumed: () -> Unit = {},
     viewModel: CalendarHostViewModel = hiltViewModel(),
 ) {
     // Wait for the persisted default view before seeding the stack, so the app
@@ -156,7 +163,7 @@ fun CalendarHost(
     val view = viewStack.last()
     // The date every view opens on and carries along (#184); tapping a day
     // anywhere focuses it and opens the day view there.
-    val focus = rememberSaveable(saver = ViewFocusSaver) { ViewFocus(currentDate()) }
+    val focus = rememberSaveable(saver = ViewFocusSaver) { ViewFocus(localToday()) }
     // A focus still on yesterday follows the date over, so the next view opened
     // doesn't land on the old day (#373); one moved elsewhere stays put.
     val today = viewModel.today.collectAsStateWithLifecycle().value
@@ -187,17 +194,27 @@ fun CalendarHost(
     // it overlays whichever calendar view is active. We forward the tapped
     // occurrence's own times (eventId + begin + end, packed as a saveable
     // long[]) so recurring events show the correct date, not the series start.
-    // Like every overlay below, it draws its last key through the slide-out
-    // ([rememberHeld]) rather than a placeholder.
+    // [heldKey] keeps the last shown key alive through the slide-out (when
+    // [detailKey] is cleared); it is set in the tap callback — never a [0,0,0]
+    // placeholder — so the destination never loads a bogus id=0 on first frame.
     var detailKey by rememberSaveable { mutableStateOf<LongArray?>(null) }
-    val onOpenDetail: (EventInstance) -> Unit = { event -> detailKey = event.occurrenceKey() }
+    var heldKey by remember { mutableStateOf<LongArray?>(null) }
+    val onOpenDetail: (EventInstance) -> Unit = { event ->
+        val key = longArrayOf(
+            event.eventId,
+            event.start.toEpochMilliseconds(),
+            event.end.toEpochMilliseconds(),
+        )
+        heldKey = key
+        detailKey = key
+    }
 
     // A tapped reminder notification asks for a specific occurrence.
-    val requestedDetailKey = requests.detailKey
     LaunchedEffect(requestedDetailKey) {
         if (requestedDetailKey != null) {
+            heldKey = requestedDetailKey
             detailKey = requestedDetailKey
-            requests.detailKey = null
+            onDetailKeyConsumed()
         }
     }
 
@@ -221,17 +238,31 @@ fun CalendarHost(
     // calendar list rather than by preferences. Reached from both.
     var showBackup by rememberSaveable { mutableStateOf(false) }
 
-    // Event form (v1.2 create), opened on a date, a tapped slot or a drafted block.
-    var createRequest by rememberSaveable(stateSaver = createRequestSaver) {
-        mutableStateOf<CreateRequest?>(null)
+    // Event form (v1.2 create) — same held-key pattern as the detail screen:
+    // [heldCreateIso] keeps the prefill date alive through the slide-out.
+    // [createStartMinutes] is the tapped slot's start (minutes from midnight)
+    // when the form is opened from a day/week grid tap; null from the FAB.
+    var createDateIso by rememberSaveable { mutableStateOf<String?>(null) }
+    var heldCreateIso by remember { mutableStateOf<String?>(null) }
+    var createStartMinutes by rememberSaveable { mutableStateOf<Int?>(null) }
+    var heldCreateMinutes by remember { mutableStateOf<Int?>(null) }
+    // A drafted block's start and end (#153) as epoch millis. Instants rather than
+    // minutes into a day, so the form opens at the times drawn even across a DST
+    // change (#387).
+    var createDraftMillis by rememberSaveable { mutableStateOf<LongArray?>(null) }
+    var heldCreateDraftMillis by remember { mutableStateOf<LongArray?>(null) }
+    fun openCreate(date: LocalDate, startMinutes: Int?, draftMillis: LongArray?) {
+        heldCreateIso = date.toString()
+        createDateIso = date.toString()
+        heldCreateMinutes = startMinutes
+        createStartMinutes = startMinutes
+        heldCreateDraftMillis = draftMillis
+        createDraftMillis = draftMillis
     }
-    fun openCreate(dateIso: String, startMinutes: Int? = null, draftMillis: LongArray? = null) {
-        createRequest = CreateRequest(dateIso, startMinutes, draftMillis)
-    }
-    val onCreateEvent: (LocalDate, Int?) -> Unit = { date, startMinutes -> openCreate(date.toString(), startMinutes) }
+    val onCreateEvent: (LocalDate, Int?) -> Unit = { date, startMinutes -> openCreate(date, startMinutes, null) }
     val onCreateDraft: (Instant, Instant) -> Unit = { start, end ->
         val date = start.toLocalDateTime(TimeZone.currentSystemDefault()).date
-        openCreate(date.toString(), draftMillis = longArrayOf(start.toEpochMilliseconds(), end.toEpochMilliseconds()))
+        openCreate(date, null, longArrayOf(start.toEpochMilliseconds(), end.toEpochMilliseconds()))
     }
 
     // Edit form (v1.3) — reuses the detail screen's occurrence key; for
@@ -241,33 +272,25 @@ fun CalendarHost(
     // falling back to the auto-refreshing calendar is the only honest
     // destination.
     var editKey by rememberSaveable { mutableStateOf<LongArray?>(null) }
+    var heldEditKey by remember { mutableStateOf<LongArray?>(null) }
 
     // An opened/received .ics file. [ImportScreen] parses it and either opens
     // the prefilled create form (one event → [importForm]) or its own bulk
     // picker (many). A plain conditional overlay (no slide) — it's transient.
-    var importUri by rememberSaveable { mutableStateOf<android.net.Uri?>(null) }
-    val importViewModel: EventEditViewModel = hiltViewModel(key = "import")
-    // Saved as "open"; a recreation takes the form back from the ViewModel, which
-    // still holds the user's edits.
-    var importForm by rememberSaveable(
-        stateSaver = Saver<EventForm?, Boolean>(
-            save = { it != null },
-            restore = { open -> if (open) importViewModel.currentForm() else null },
-        ),
-    ) { mutableStateOf<EventForm?>(null) }
+    var importUri by remember { mutableStateOf<android.net.Uri?>(null) }
+    var importForm by remember { mutableStateOf<EventForm?>(null) }
     // Which channel filled [importForm]: an .ics file (prompt to apply the default
     // reminder) or an ACTION_INSERT intent (apply it automatically) — #49.
-    var importFormSource by rememberSaveable { mutableStateOf(ImportSource.File) }
+    var importFormSource by remember { mutableStateOf(ImportSource.File) }
     // Bumped per open, so even an equal prefill starts a fresh form.
-    var importFormId by rememberSaveable { mutableIntStateOf(0) }
+    var importFormId by remember { mutableIntStateOf(0) }
     // Whether [importForm] came from an external create request (#30, #306);
     // closing it then hands control back to whoever asked.
     var importFromRequest by rememberSaveable { mutableStateOf(false) }
     // A second external request that arrived while a prefilled form was open:
     // it waits behind that form's unsaved-changes prompt, then opens.
     var pendingInsert by remember { mutableStateOf<Pair<EventForm, ImportSource>?>(null) }
-    val createViewModel: EventEditViewModel = hiltViewModel(key = "create")
-    val editViewModel: EventEditViewModel = hiltViewModel(key = "edit")
+    val importViewModel: EventEditViewModel = hiltViewModel(key = "import")
     fun openImportForm(form: EventForm, source: ImportSource, fromRequest: Boolean = false) {
         importFormSource = source
         importForm = form
@@ -283,7 +306,7 @@ fun CalendarHost(
             importForm = null
             if (importFromRequest) {
                 importFromRequest = false
-                requests.onExternalFormClosed()
+                onExternalFormClosed()
             }
         }
     }
@@ -291,7 +314,7 @@ fun CalendarHost(
     // flow — picker + summary — even for a single-event file, because the intent
     // 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 rememberSaveable { mutableStateOf(false) }
+    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
@@ -302,64 +325,41 @@ fun CalendarHost(
     // 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) }
-    // A recreation re-reads the launch intent; when the import it carries came
-    // back with the saved state, that replay is the same work, not a new one.
-    fun isReplayOfRestoredImport(): Boolean {
-        val replay = requests.replayed && (importUri != null || importForm != null)
-        requests.replayed = false
-        return replay
-    }
-    val requestedImportUri = requests.importUri
     LaunchedEffect(requestedImportUri) {
         if (requestedImportUri != null) {
-            if (isReplayOfRestoredImport()) {
-                requests.importUri = null
-                return@LaunchedEffect
-            }
             importUri = requestedImportUri
             importForceMany = false
             importSession++
-            requests.importUri = null
+            onImportConsumed()
         }
     }
     // An external ACTION_INSERT launch (another app/widget creating an event,
     // issue #30) arrives already prefilled — open it in the same create form the
     // single-event .ics path uses. [importForm] is the topmost overlay, so it
     // reveals on top of whatever was open without extra dismissal.
-    val requestedInsert = requests.insert
-    LaunchedEffect(requestedInsert) {
-        if (requestedInsert != null) {
-            if (isReplayOfRestoredImport()) {
-                requests.insert = null
-                return@LaunchedEffect
-            }
+    LaunchedEffect(requestedInsertForm) {
+        if (requestedInsertForm != null) {
             if (importForm == null) {
-                openImportForm(requestedInsert.form, requestedInsert.source, fromRequest = true)
+                openImportForm(requestedInsertForm, requestedInsertSource, fromRequest = true)
             } else {
-                pendingInsert = requestedInsert.form to requestedInsert.source
+                pendingInsert = requestedInsertForm to requestedInsertSource
             }
-            requests.insert = null
+            onInsertConsumed()
         }
     }
 
     // Close every overlay that can sit over the calendar, so an externally
     // requested destination (a widget/shortcut/QS-tile launch) is revealed on
-    // top instead of underneath whatever the user had open. The create form,
-    // declared under the edit form, can stay for an edit to open over it.
-    fun dismissCoveringOverlays(keepCreate: Boolean = false) {
+    // top instead of underneath whatever the user had open.
+    fun dismissCoveringOverlays() {
         showSettings = false
-        showSearch = false
         showCalendars = false
         showBackup = false
         detailKey = null
         editKey = null
-        if (!keepCreate) createRequest = null
         importUri = null
         importForm = null
-        if (importFromRequest) {
-            importFromRequest = false
-            requests.onExternalFormClosed()
-        }
+        importFromRequest = false
         pendingInsert = null
         importViewModel.reset()
     }
@@ -367,25 +367,21 @@ fun CalendarHost(
     // An external "edit this event" (ACTION_EDIT, e.g. an assistant/task app or
     // widget) opens the occurrence straight in the edit form. Drop any covering
     // overlay first — the edit overlay sits below Settings/import in the Box, so
-    // without this it would open hidden underneath them. A saved edit just
-    // returns to the calendar.
-    val requestedEditKey = requests.editKey
+    // without this it would open hidden underneath them. Same held-key pattern as
+    // a detail-screen "Edit" tap; a saved edit just returns to the calendar.
     LaunchedEffect(requestedEditKey) {
         if (requestedEditKey != null) {
-            // An open edit form stays on screen, so it starts over here rather
-            // than once it has slid away.
-            if (editKey != null) editViewModel.reset()
-            dismissCoveringOverlays(keepCreate = true)
+            dismissCoveringOverlays()
+            heldEditKey = requestedEditKey
             editKey = requestedEditKey
-            requests.editKey = null
+            onEditKeyConsumed()
         }
     }
 
     // A home-screen widget launch asks to open a date (→ day view), open an
     // event's detail, or start a create. Handled once and cleared, mirroring
-    // the detail request. Date/event opens root the stack in the widget's own
+    // [requestedDetailKey]. Date/event opens root the stack in the widget's own
     // view so backing out returns there (then home), not to the default.
-    val widgetNavRequest = requests.nav
     LaunchedEffect(widgetNavRequest) {
         if (widgetNavRequest != null) {
             navigationVersion++
@@ -396,19 +392,23 @@ fun CalendarHost(
                 // Drill the day view in over the widget's view: drop any overlay
                 // that would cover it, so the open doesn't land under Settings/form.
                 dismissCoveringOverlays()
+                createDateIso = null
                 focus.navigateTo(LocalDate.parse(req.dateIso))
                 // No widget source (an external date tap) roots over the default
                 // home view, so backing out of the day returns home then exits.
                 viewStack = viewBaseStack(defaultView, req.source ?: defaultView).drillToDay()
-                requests.nav = null
+                onWidgetNavConsumed()
             }
             is WidgetNavRequest.OpenEvent -> {
                 // Root the stack in the widget's view, then open the occurrence
                 // detail over it (same key shape as a tapped event / reminder).
                 dismissCoveringOverlays()
+                createDateIso = null
                 viewStack = viewBaseStack(defaultView, req.source)
-                detailKey = longArrayOf(req.eventId, req.beginMillis, req.endMillis)
-                requests.nav = null
+                val key = longArrayOf(req.eventId, req.beginMillis, req.endMillis)
+                heldKey = key
+                detailKey = key
+                onWidgetNavConsumed()
             }
             is WidgetNavRequest.OpenView -> {
                 // A widget header tap: land on a top-level view with no date
@@ -416,19 +416,26 @@ fun CalendarHost(
                 // the stack on the target (null → the default home) over the
                 // default home — so backing out returns to the default, then exits.
                 dismissCoveringOverlays()
-                focus.navigateTo(currentDate())
+                createDateIso = null
+                focus.navigateTo(localToday())
                 viewStack = viewBaseStack(defaultView, req.view ?: defaultView)
-                requests.nav = null
+                onWidgetNavConsumed()
             }
             is WidgetNavRequest.Create -> {
                 // External "new event" entries (QS tile / launcher shortcut /
                 // widget) must land on top of whatever is open — the form overlay
                 // sits below Settings/calendars in the Box, so without this it
                 // would open hidden underneath them.
-                if (createRequest != null) createViewModel.reset()
                 dismissCoveringOverlays()
-                openCreate(req.dateIso ?: currentDate().toString())
-                requests.nav = null
+                val iso = req.dateIso ?: Clock.System.now()
+                    .toLocalDateTime(TimeZone.currentSystemDefault()).date.toString()
+                heldCreateIso = iso
+                createDateIso = iso
+                heldCreateMinutes = null
+                createStartMinutes = null
+                heldCreateDraftMillis = null
+                createDraftMillis = null
+                onWidgetNavConsumed()
             }
             null -> {}
         }
@@ -441,28 +448,23 @@ fun CalendarHost(
     val eventActions: EventActionsViewModel = hiltViewModel()
     val moveOutcome by reschedule.outcome.collectAsStateWithLifecycle()
     val selectionFailure by eventActions.failure.collectAsStateWithLifecycle()
-    val onEditEvent: (EventInstance) -> Unit = { event -> editKey = event.occurrenceKey() }
+    val onEditEvent: (EventInstance) -> Unit = { event ->
+        val key = longArrayOf(
+            event.eventId,
+            event.start.toEpochMilliseconds(),
+            event.end.toEpochMilliseconds(),
+        )
+        heldEditKey = key
+        editKey = key
+    }
     // A tap opens the edit form instead of the detail screen when the user chose
     // so (#178) — only for events whose calendar takes writes. Both are read at
     // tap time, so a tap before they've loaded still routes right.
     val tapScope = rememberCoroutineScope()
     val tapContext = LocalContext.current
+    val requireWriteOr = rememberWriteGateOr()
     // A refused write upgrade is asked once; later taps just open the details.
     var tapWriteRefused by rememberSaveable { mutableStateOf(false) }
-    // The tap waiting on the WRITE_CALENDAR prompt, saved so a rotation keeps it.
-    var tapAwaitingWrite by rememberSaveable { mutableStateOf<LongArray?>(null) }
-    val editAwaitingTap = rememberWriteAction(
-        onDenied = {
-            tapAwaitingWrite?.let { key ->
-                tapWriteRefused = true
-                detailKey = key
-            }
-            tapAwaitingWrite = null
-        },
-    ) {
-        tapAwaitingWrite?.let { editKey = it }
-        tapAwaitingWrite = null
-    }
     val onEventClick: (EventInstance) -> Unit = { event ->
         tapScope.launch {
             val toEditor = viewModel.tapOpensEditor() && eventActions.canModify(event.calendarId)
@@ -470,9 +472,9 @@ fun CalendarHost(
                 !toEditor -> onOpenDetail(event)
                 tapContext.canWriteCalendar() -> onEditEvent(event)
                 tapWriteRefused -> onOpenDetail(event)
-                else -> {
-                    tapAwaitingWrite = event.occurrenceKey()
-                    editAwaitingTap()
+                else -> requireWriteOr({ onEditEvent(event) }) {
+                    tapWriteRefused = true
+                    onOpenDetail(event)
                 }
             }
         }
@@ -492,10 +494,15 @@ fun CalendarHost(
         )
     }
 
+    val slideSpec = rememberCalendarSlideSpec()
+    // Overlays leave from the predictive-back preview (#184): shrinking on from
+    // where the gesture let go instead of snapping back and sliding off.
+    val overlayExit = predictiveBackExit()
+
     // Base-level back: pop the view stack while no overlay covers it (each overlay
     // owns its own BackHandler and takes precedence). Disabled at the home view,
     // so back there falls through to the system and exits the app.
-    val anyOverlayVisible = showSearch || detailKey != null || createRequest != null ||
+    val anyOverlayVisible = showSearch || detailKey != null || createDateIso != null ||
         editKey != null || showSettings || showCalendars || showBackup ||
         importUri != null || importForm != null
     // The view switch runs on a seekable transition, so a back gesture can scrub
@@ -689,7 +696,11 @@ fun CalendarHost(
 
         // Search overlay — below detail/edit in the Box so a tapped result's
         // detail screen draws on top, and closing it returns to the results.
-        SlideOverlay(visible = showSearch) {
+        AnimatedVisibility(
+            visible = showSearch,
+            enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
+            exit = overlayExit,
+        ) {
             SearchScreen(
                 onBack = { showSearch = false },
                 onEventClick = onEventClick,
@@ -697,15 +708,23 @@ fun CalendarHost(
             )
         }
 
-        val shownDetailKey = rememberHeld(detailKey)
-        SlideOverlay(visible = detailKey != null) {
-            shownDetailKey?.let { key ->
+        // Prefer the live key; fall back to the held one only while sliding out.
+        val activeKey = detailKey ?: heldKey
+        AnimatedVisibility(
+            visible = detailKey != null,
+            enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
+            exit = overlayExit,
+        ) {
+            activeKey?.let { key ->
                 EventDetailScreen(
                     eventId = key[0],
                     beginMillis = key[1],
                     endMillis = key[2],
                     onBack = { detailKey = null },
-                    onEdit = { editKey = key },
+                    onEdit = {
+                        heldEditKey = key
+                        editKey = key
+                    },
                     onDuplicate = { form ->
                         // Reuse the prefilled-create overlay: a duplicate is a
                         // fresh event, so it applies the default reminder like an
@@ -719,28 +738,32 @@ fun CalendarHost(
         }
 
         // Event form (v1.2) — full-screen destination, slides over the calendar.
-        val shownCreate = rememberHeld(createRequest)
-        SlideOverlay(visible = createRequest != null, onHidden = createViewModel::reset) {
-            shownCreate?.let { create ->
-                key(create) {
-                    EventEditScreen(
-                        initialDateIso = create.dateIso,
-                        initialStartMinutes = create.startMinutes,
-                        initialDraft = create.draftMillis,
-                        onClose = { createRequest = null },
-                        onSaved = { createRequest = null },
-                        onManageCalendars = { showCalendars = true },
-                        visible = createRequest != null,
-                        viewModel = createViewModel,
-                    )
-                }
+        AnimatedVisibility(
+            visible = createDateIso != null,
+            enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
+            exit = overlayExit,
+        ) {
+            (createDateIso ?: heldCreateIso)?.let { iso ->
+                EventEditScreen(
+                    initialDateIso = iso,
+                    initialStartMinutes = createStartMinutes ?: heldCreateMinutes,
+                    initialDraft = createDraftMillis ?: heldCreateDraftMillis,
+                    onClose = { createDateIso = null },
+                    onSaved = { createDateIso = null },
+                    onManageCalendars = { showCalendars = true },
+                    visible = createDateIso != null,
+                    viewModel = hiltViewModel(key = "create"),
+                )
             }
         }
 
         // Edit form (v1.3) — slides over the detail screen.
-        val shownEditKey = rememberHeld(editKey)
-        SlideOverlay(visible = editKey != null, onHidden = editViewModel::reset) {
-            shownEditKey?.let { key ->
+        AnimatedVisibility(
+            visible = editKey != null,
+            enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
+            exit = overlayExit,
+        ) {
+            (editKey ?: heldEditKey)?.let { key ->
                 EventEditScreen(
                     initialDateIso = null,
                     editKey = key,
@@ -757,16 +780,23 @@ fun CalendarHost(
                     // below to show why, so open it.
                     onLoadFailed = {
                         editKey = null
-                        if (detailKey == null) detailKey = key
+                        if (detailKey == null) {
+                            heldKey = key
+                            detailKey = key
+                        }
                     },
                     visible = editKey != null,
-                    viewModel = editViewModel,
+                    viewModel = hiltViewModel(key = "edit"),
                 )
             }
         }
 
         // Settings (M4) — full-screen destination, slides over the calendar.
-        SlideOverlay(visible = showSettings) {
+        AnimatedVisibility(
+            visible = showSettings,
+            enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
+            exit = overlayExit,
+        ) {
             SettingsScreen(
                 onBack = { showSettings = false },
                 onManageCalendars = { showCalendars = true },
@@ -824,7 +854,11 @@ fun CalendarHost(
 
         // Declared last so it covers every overlay that can open it: Settings,
         // both event forms, and the .ics import picker (#76).
-        SlideOverlay(visible = showCalendars) {
+        AnimatedVisibility(
+            visible = showCalendars,
+            enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
+            exit = overlayExit,
+        ) {
             CalendarsScreen(
                 onBack = { showCalendars = false },
                 onOpenBackup = { showBackup = true },
@@ -833,7 +867,11 @@ fun CalendarHost(
         }
 
         // Backup & restore — over the manager, since the manager links into it.
-        SlideOverlay(visible = showBackup) {
+        AnimatedVisibility(
+            visible = showBackup,
+            enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
+            exit = overlayExit,
+        ) {
             // 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
@@ -872,48 +910,5 @@ private val viewStackSaver = listSaver<List<CalendarView>, Int>(
     restore = { ordinals -> ordinals.map { CalendarView.entries[it] } },
 )
 
-/**
- * An overlay's slide-in from the end edge, leaving from the predictive-back
- * preview (#184): shrinking on from where the gesture let go instead of
- * snapping back and sliding off.
- */
-@Composable
-private fun SlideOverlay(
-    visible: Boolean,
-    onHidden: () -> Unit = {},
-    content: @Composable AnimatedVisibilityScope.() -> Unit,
-) {
-    val state = remember { MutableTransitionState(visible) }
-    state.targetState = visible
-    val hidden = state.isIdle && !state.currentState
-    LaunchedEffect(hidden) {
-        if (hidden) onHidden()
-    }
-    AnimatedVisibility(
-        visibleState = state,
-        enter = slideInHorizontally(rememberCalendarSlideSpec()) { it } + fadeIn(),
-        exit = predictiveBackExit(),
-        content = content,
-    )
-}
-
-/** The detail and edit overlays' key for one occurrence: eventId, begin, end. */
-private fun EventInstance.occurrenceKey(): LongArray =
-    longArrayOf(eventId, start.toEpochMilliseconds(), end.toEpochMilliseconds())
-
-/**
- * A create-form open: its date, plus the tapped slot's start (minutes from
- * midnight) from a day/week grid tap, or a drafted block's start and end (#153)
- * as epoch millis. Instants rather than minutes into a day, so the form opens at
- * the times drawn even across a DST change (#387).
- */
-private class CreateRequest(
-    val dateIso: String,
-    val startMinutes: Int?,
-    val draftMillis: LongArray?,
-)
-
-private val createRequestSaver = Saver<CreateRequest?, List<Any?>>(
-    save = { request -> request?.let { listOf(it.dateIso, it.startMinutes, it.draftMillis) } },
-    restore = { CreateRequest(it[0] as String, it[1] as Int?, it[2] as LongArray?) },
-)
+private fun localToday(): LocalDate =
+    Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()).date

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

@@ -8,10 +8,11 @@ import de.jeanlucmakiola.calendula.data.time.TodaySource
 import de.jeanlucmakiola.calendula.data.time.currentDate
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
-import de.jeanlucmakiola.floret.android.stateWhileSubscribed
+import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.datetime.LocalDate
 import javax.inject.Inject
 
@@ -28,35 +29,40 @@ class CalendarHostViewModel @Inject constructor(
 ) : ViewModel() {
 
     /** Today, kept current across midnight so the shared focus can follow it (#373). */
-    val today: StateFlow<LocalDate> = todaySource.today.stateWhileSubscribed(
+    val today: StateFlow<LocalDate> = todaySource.today.stateIn(
         scope = viewModelScope,
+        started = SharingStarted.WhileSubscribed(5_000L),
         initialValue = currentDate(),
     )
 
-    val defaultView: StateFlow<CalendarView?> = prefs.defaultView.stateWhileSubscribed(
+    val defaultView: StateFlow<CalendarView?> = prefs.defaultView.stateIn(
         scope = viewModelScope,
+        started = SharingStarted.WhileSubscribed(5_000L),
         initialValue = null,
     )
 
     /** Views the top-bar quick-switch pill cycles through, in the user's order (#24). */
     val quickSwitchViews: StateFlow<List<CalendarView>> = prefs.quickSwitchConfig
         .map { it.cycle }
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = IMPLEMENTED_VIEWS,
         )
 
     /** Order of the views in the navigation drawer (#24); every view always shown. */
     val drawerViewOrder: StateFlow<List<CalendarView>> = prefs.drawerViewOrder
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = IMPLEMENTED_VIEWS,
         )
 
     /** Whether each view's jump-to-today control lives in the top bar, not the FAB (#60). */
     val todayButtonInToolbar: StateFlow<Boolean> = prefs.todayButtonInToolbar
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = false,
         )
 
@@ -68,8 +74,9 @@ class CalendarHostViewModel @Inject constructor(
      * switched off to be rid of.
      */
     val dragToReschedule: StateFlow<Boolean> = prefs.dragToReschedule
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = false,
         )
 

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

@@ -1,45 +0,0 @@
-package de.jeanlucmakiola.calendula.ui
-
-import android.net.Uri
-import androidx.compose.runtime.Stable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.setValue
-import de.jeanlucmakiola.calendula.domain.EventForm
-import de.jeanlucmakiola.calendula.ui.edit.ImportSource
-
-/**
- * What a notification, widget, shortcut or another app asked the running app to
- * open. MainActivity fills it from each intent (singleTop + onNewIntent route a
- * new one into the running activity); CalendarHost acts on a request and clears
- * it, so a later recomposition can't act on it twice.
- *
- * [onExternalFormClosed] runs when a form opened for [insert] closes, so the
- * activity can hand control back to the app that asked.
- */
-@Stable
-class ExternalRequests(val onExternalFormClosed: () -> Unit = {}) {
-    /** A tapped reminder notification's occurrence (eventId, begin, end), for the detail screen. */
-    var detailKey by mutableStateOf<LongArray?>(null)
-
-    /** A home-screen widget, shortcut or tile navigation (open a date, an event, a view, or create). */
-    var nav by mutableStateOf<WidgetNavRequest?>(null)
-
-    /** An .ics file opened or shared into the app (ACTION_VIEW/SEND). */
-    var importUri by mutableStateOf<Uri?>(null)
-
-    /**
-     * A prefilled new-event form from an external ACTION_INSERT launch (#30) or
-     * shared text (#306), opened in the create form for review.
-     */
-    var insert by mutableStateOf<InsertRequest?>(null)
-
-    /** An external "edit this event" (ACTION_EDIT), in the detail key's shape. */
-    var editKey by mutableStateOf<LongArray?>(null)
-
-    /** Whether these came from re-reading the launch intent on a recreation. */
-    var replayed = false
-}
-
-/** A prefilled create form from an external launch, with the source it came from. */
-data class InsertRequest(val form: EventForm, val source: ImportSource)

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

@@ -1,5 +1,7 @@
 package de.jeanlucmakiola.calendula.ui
 
+import android.Manifest
+import android.content.pm.PackageManager
 import androidx.compose.animation.AnimatedContent
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
@@ -18,11 +20,11 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.LocalLifecycleOwner
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.core.content.ContextCompat
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
 import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesScheduler
 import de.jeanlucmakiola.calendula.data.contacts.hasContactsPermission
-import de.jeanlucmakiola.calendula.ui.common.canReadCalendar
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
 import de.jeanlucmakiola.calendula.ui.onboarding.OnboardingStep
 import de.jeanlucmakiola.calendula.ui.onboarding.OnboardingSteps
@@ -41,12 +43,27 @@ private sealed interface RootTarget {
 
 @Composable
 fun RootScreen(
-    requests: ExternalRequests,
     modifier: Modifier = Modifier,
+    requestedDetailKey: LongArray? = null,
+    onDetailKeyConsumed: () -> Unit = {},
+    widgetNavRequest: WidgetNavRequest? = null,
+    onWidgetNavConsumed: () -> Unit = {},
+    requestedImportUri: android.net.Uri? = null,
+    onImportConsumed: () -> Unit = {},
+    requestedInsertForm: de.jeanlucmakiola.calendula.domain.EventForm? = null,
+    requestedInsertSource: de.jeanlucmakiola.calendula.ui.edit.ImportSource =
+        de.jeanlucmakiola.calendula.ui.edit.ImportSource.Insert,
+    onInsertConsumed: () -> Unit = {},
+    onExternalFormClosed: () -> Unit = {},
+    requestedEditKey: LongArray? = null,
+    onEditKeyConsumed: () -> Unit = {},
 ) {
     val context = LocalContext.current
     var hasPermission by remember {
-        mutableStateOf(context.canReadCalendar())
+        mutableStateOf(
+            ContextCompat.checkSelfPermission(context, Manifest.permission.READ_CALENDAR)
+                == PackageManager.PERMISSION_GRANTED
+        )
     }
 
     // A launch scan already covers the app coming up with the permission, so
@@ -57,7 +74,9 @@ fun RootScreen(
     DisposableEffect(lifecycle) {
         val obs = LifecycleEventObserver { _, event ->
             if (event == Lifecycle.Event.ON_RESUME) {
-                hasPermission = context.canReadCalendar()
+                hasPermission = ContextCompat.checkSelfPermission(
+                    context, Manifest.permission.READ_CALENDAR
+                ) == PackageManager.PERMISSION_GRANTED
                 // Refresh the contact special-dates mirror on foreground (the
                 // worker is debounced and no-ops when the feature is off). Gated
                 // on the permission so users without the opt-in never enqueue it.
@@ -127,8 +146,19 @@ fun RootScreen(
         when (shown) {
             RootTarget.Loading -> Unit
             RootTarget.App -> CalendarHost(
-                requests = requests,
                 modifier = modifier,
+                requestedDetailKey = requestedDetailKey,
+                onDetailKeyConsumed = onDetailKeyConsumed,
+                widgetNavRequest = widgetNavRequest,
+                onWidgetNavConsumed = onWidgetNavConsumed,
+                requestedImportUri = requestedImportUri,
+                onImportConsumed = onImportConsumed,
+                requestedInsertForm = requestedInsertForm,
+                requestedInsertSource = requestedInsertSource,
+                onInsertConsumed = onInsertConsumed,
+                onExternalFormClosed = onExternalFormClosed,
+                requestedEditKey = requestedEditKey,
+                onEditKeyConsumed = onEditKeyConsumed,
             )
             // Both halves of a transition read their position out of the live
             // plan; the one the outgoing step was drawn with is already gone.

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaRange.kt

@@ -3,9 +3,8 @@ package de.jeanlucmakiola.calendula.ui.agenda
 import de.jeanlucmakiola.floret.locale.localizedDateFormatter
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
+import java.time.YearMonth
 import java.util.Locale
-import kotlinx.datetime.toJavaLocalDate
-import kotlinx.datetime.yearMonth
 
 /**
  * How far ahead the agenda (screen or widget) shows events, starting at today.
@@ -51,7 +50,7 @@ fun AgendaRange.dayCount(anchor: LocalDate, weekStart: DayOfWeek): Int = when (t
         DAYS_PER_WEEK - sinceWeekStart
     }
     AgendaRange.ThisMonth -> {
-        val daysInMonth = anchor.yearMonth.numberOfDays
+        val daysInMonth = YearMonth.of(anchor.year, anchor.month.ordinal + 1).lengthOfMonth()
         daysInMonth - anchor.day + 1
     }
     is AgendaRange.Custom -> days.coerceIn(AgendaRange.MIN_CUSTOM_DAYS, AgendaRange.MAX_CUSTOM_DAYS)
@@ -106,8 +105,8 @@ fun agendaRangeWindowSummary(
     locale: Locale,
     monthAsSpan: Boolean = false,
 ): String {
-    val javaStart = start.toJavaLocalDate()
-    val javaEnd = end.toJavaLocalDate()
+    val javaStart = java.time.LocalDate.of(start.year, start.month.ordinal + 1, start.day)
+    val javaEnd = java.time.LocalDate.of(end.year, end.month.ordinal + 1, end.day)
     val dayMonth = localizedDateFormatter(locale, "dMMM")
     val dayMonthYear = localizedDateFormatter(locale, "dMMMy")
     return when {

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaRows.kt

@@ -1,7 +1,5 @@
 package de.jeanlucmakiola.calendula.ui.agenda
 
-import androidx.annotation.StringRes
-import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Box
@@ -11,8 +9,6 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.lazy.LazyListScope
-import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Coffee
@@ -32,27 +28,25 @@ import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.domain.isCrossedOut
+import de.jeanlucmakiola.calendula.domain.isDeclined
 import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
-import de.jeanlucmakiola.calendula.ui.common.ViewMorphKey
 import de.jeanlucmakiola.calendula.ui.common.declinedTitle
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.eventAccent
+import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.ui.common.formatTimeOfDay
-import de.jeanlucmakiola.calendula.ui.common.morphEvent
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.Position
-import de.jeanlucmakiola.floret.components.positionOf
 import de.jeanlucmakiola.floret.identity.LocalFloretDarkTheme
-import de.jeanlucmakiola.floret.identity.animateItemMotion
 import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.floret.locale.localizedDateFormatter
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.plus
-import kotlinx.datetime.toJavaLocalDate
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Instant
 import java.util.Locale
 
 // The agenda's row vocabulary, split out of AgendaScreen so the month view's
@@ -138,7 +132,7 @@ internal fun AgendaEventRow(
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
     GroupedRow(
         modifier = if (dimmed) modifier.alpha(EventDimAlpha) else modifier,
-        title = declinedTitle(title, event.isCrossedOut),
+        title = declinedTitle(title, event.isDeclined),
         summary = AnnotatedString(agendaTimeSummary(event, day, zone)),
         position = position,
         minHeight = 64.dp,
@@ -183,74 +177,34 @@ internal fun agendaTimeSummary(event: EventInstance, day: LocalDate, zone: TimeZ
         AgendaTimeLabel.AllDay -> stringResource(R.string.event_detail_all_day)
         is AgendaTimeLabel.Starts -> stringResource(
             R.string.agenda_span_starts,
-            formatTimeOfDay(label.start, zone, is24Hour, locale),
+            formatTime(label.start, zone, is24Hour, locale),
         )
         is AgendaTimeLabel.Ends -> stringResource(
             R.string.agenda_span_ends,
-            formatTimeOfDay(label.end, zone, is24Hour, locale),
+            formatTime(label.end, zone, is24Hour, locale),
         )
-        is AgendaTimeLabel.Range -> "${formatTimeOfDay(label.start, zone, is24Hour, locale)} – " +
-            formatTimeOfDay(label.end, zone, is24Hour, locale)
+        is AgendaTimeLabel.Range -> "${formatTime(label.start, zone, is24Hour, locale)} – " +
+            formatTime(label.end, zone, is24Hour, locale)
     }
 
     val location = event.location?.takeIf { it.isNotBlank() }
     return if (location != null) "$time · $location" else time
 }
 
+private fun formatTime(
+    instant: Instant,
+    zone: TimeZone,
+    is24Hour: Boolean,
+    locale: Locale,
+): String {
+    val t = instant.toLocalDateTime(zone).time
+    return formatTimeOfDay(t.hour, t.minute, is24Hour, locale)
+}
+
 private fun formatAgendaDate(date: LocalDate): String {
     val locale = Locale.getDefault()
-    val java = date.toJavaLocalDate()
+    val java = java.time.LocalDate.of(date.year, date.month.ordinal + 1, date.day)
     // Weekday + date in the locale's own field order (e.g. "Wed, Jun 17, 2026"
     // vs "Mi., 17. Juni 2026") rather than a hardcoded day-month-year layout.
     return localizedDateFormatter(locale, "EEEdMMMy").format(java)
 }
-
-/**
- * The agenda's day-by-day list body: a sticky header per day, its events or a
- * placeholder row for an event-less day, then a gap. Shared by the Agenda screen
- * and the month view's split pane so both lists read the same.
- */
-@OptIn(ExperimentalFoundationApi::class)
-internal fun LazyListScope.agendaDays(
-    days: List<AgendaDay>,
-    today: LocalDate,
-    zone: TimeZone,
-    @StringRes emptyText: Int,
-    onEmptyClick: (LocalDate) -> Unit,
-    dimmed: (EventInstance, LocalDate) -> Boolean,
-    onOpenDay: (LocalDate) -> Unit,
-    onEventClick: (EventInstance) -> Unit,
-) {
-    days.forEach { day ->
-        stickyHeader(key = "header-${day.date}") {
-            AgendaDayHeader(date = day.date, today = today, onOpenDay = onOpenDay)
-        }
-        if (day.events.isEmpty()) {
-            item(key = "placeholder-${day.date}") {
-                AgendaEmptyDayRow(
-                    text = stringResource(emptyText),
-                    onClick = { onEmptyClick(day.date) },
-                )
-            }
-        } else {
-            itemsIndexed(
-                items = day.events,
-                // Scope the key by day: a multi-day event appears under every
-                // day it spans, so its instanceId alone is not unique across
-                // the list (LazyColumn requires unique keys).
-                key = { _, event -> "${day.date}-${event.instanceId}" },
-            ) { index, event ->
-                AgendaEventRow(
-                    event = event,
-                    day = day.date,
-                    zone = zone,
-                    position = positionOf(index, day.events.size),
-                    dimmed = dimmed(event, day.date),
-                    modifier = animateItemMotion().morphEvent(ViewMorphKey.event(event, day.date)),
-                    onClick = { onEventClick(event) },
-                )
-            }
-        }
-        item(key = "gap-${day.date}") { Spacer(Modifier.height(8.dp)) }
-    }
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaScreen.kt

@@ -10,6 +10,9 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.setValue
 import androidx.compose.runtime.snapshotFlow
 import androidx.compose.runtime.rememberUpdatedState
+import de.jeanlucmakiola.calendula.ui.common.ViewMorphKey
+import de.jeanlucmakiola.calendula.ui.common.morphEvent
+import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -23,6 +26,7 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.LazyListState
+import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Coffee
@@ -62,9 +66,11 @@ import de.jeanlucmakiola.calendula.ui.common.AgendaRangePicker
 import de.jeanlucmakiola.calendula.ui.common.AppBarSpacing
 import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
 import de.jeanlucmakiola.calendula.ui.common.agendaRangeLabel
+import de.jeanlucmakiola.floret.identity.animateItemMotion
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
+import de.jeanlucmakiola.floret.components.positionOf
 import de.jeanlucmakiola.calendula.ui.common.rememberCurrentMinute
 import de.jeanlucmakiola.floret.locale.currentLocale
 import kotlinx.coroutines.launch
@@ -373,6 +379,7 @@ internal fun AgendaContent(
     }
 }
 
+@OptIn(ExperimentalFoundationApi::class)
 @Composable
 private fun AgendaList(
     days: List<AgendaDay>,
@@ -393,8 +400,11 @@ private fun AgendaList(
     val itemDates = agendaItemDates(days)
     val anchorRow = itemDates.indexOfFirst { it >= anchor }.coerceAtLeast(0)
     SideEffect { anchorIndex.intValue = anchorRow }
-    // A new anchor opens on its row from the first frame; keyed on the anchor
-    // the days arrived with, not the one requested. The first run may restore.
+    // A new anchor opens the list on its row from the first frame, with past
+    // days above. Keyed on the anchor the days arrived with, not the one just
+    // requested: scrolling before the new rows compose leaves the list keyed to
+    // a row that reappears further down, and it follows it there. The first run
+    // may restore a remembered day instead.
     val pendingRestore = remember { arrayOf(initialTopDate) }
     DisposableEffect(anchor) {
         val target = pendingRestore[0]
@@ -434,17 +444,39 @@ private fun AgendaList(
         // Bottom inset clears the FAB stack so the last row stays tappable.
         contentPadding = PaddingValues(top = 8.dp, bottom = 96.dp),
     ) {
-        agendaDays(
-            days = days,
-            today = today,
-            zone = zone,
-            // An anchored, event-less today (#35) — "nothing left today".
-            emptyText = R.string.agenda_no_more_today,
-            onEmptyClick = onOpenDay,
-            dimmed = { event, day -> dimPast && event.isPastOn(day, now, zone) },
-            onOpenDay = onOpenDay,
-            onEventClick = onEventClick,
-        )
+        days.forEach { day ->
+            stickyHeader(key = "header-${day.date}") {
+                AgendaDayHeader(date = day.date, today = today, onOpenDay = onOpenDay)
+            }
+            if (day.events.isEmpty()) {
+                // An anchored, event-less today (#35) — "nothing left today".
+                item(key = "placeholder-${day.date}") {
+                    AgendaEmptyDayRow(
+                        text = stringResource(R.string.agenda_no_more_today),
+                        onClick = { onOpenDay(day.date) },
+                    )
+                }
+            } else {
+                itemsIndexed(
+                    items = day.events,
+                    // Scope the key by day: a multi-day event appears under every
+                    // day it spans, so its instanceId alone is not unique across
+                    // the list (LazyColumn requires unique keys).
+                    key = { _, event -> "${day.date}-${event.instanceId}" },
+                ) { index, event ->
+                    AgendaEventRow(
+                        event = event,
+                        day = day.date,
+                        zone = zone,
+                        position = positionOf(index, day.events.size),
+                        dimmed = dimPast && event.isPastOn(day.date, now, zone),
+                        modifier = animateItemMotion().morphEvent(ViewMorphKey.event(event, day.date)),
+                        onClick = { onEventClick(event) },
+                    )
+                }
+            }
+            item(key = "gap-${day.date}") { Spacer(Modifier.height(8.dp)) }
+        }
     }
 }
 

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaViewModel.kt

@@ -1,22 +1,19 @@
 package de.jeanlucmakiola.calendula.ui.agenda
 
-import de.jeanlucmakiola.calendula.ui.common.dayRange
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.firstDayOfWeek
 import de.jeanlucmakiola.calendula.data.time.TodaySource
 import de.jeanlucmakiola.calendula.data.time.currentDate
-import de.jeanlucmakiola.calendula.data.time.stateFollowingDays
 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.floret.android.stateWhileSubscribed
-import de.jeanlucmakiola.floret.di.IoDispatcher
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -27,13 +24,17 @@ import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.atTime
 import kotlinx.datetime.minus
 import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
 import kotlin.time.Instant
 import javax.inject.Inject
 
@@ -65,8 +66,9 @@ class AgendaViewModel @Inject constructor(
      * the screen combines it with a per-minute "now" to fade or drop past rows.
      */
     val pastEventDisplay: StateFlow<PastEventDisplay> = settingsPrefs.pastEventDisplay
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = PastEventDisplay.SHOW,
         )
 
@@ -77,8 +79,9 @@ class AgendaViewModel @Inject constructor(
      * alongside the data state like [pastEventDisplay] rather than re-querying.
      */
     val showToday: StateFlow<Boolean> = settingsPrefs.agendaShowToday
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = true,
         )
 
@@ -98,14 +101,21 @@ class AgendaViewModel @Inject constructor(
     var lastTopDate: LocalDate? = null
         private set
 
+    private var lastToday = todayDate
+
     /**
      * Today, kept current across midnight (#373). An agenda still starting on
      * yesterday moves on to the new day; one jumped elsewhere stays put.
      */
-    private val today: StateFlow<LocalDate> =
-        todaySource.today.stateFollowingDays(viewModelScope, todayDate) { old, date ->
-            if (_window.value.anchor == old) _window.value = _window.value.copy(anchor = date)
+    private val today: StateFlow<LocalDate> = todaySource.today
+        .onEach { date ->
+            val old = lastToday
+            lastToday = date
+            if (old != date && _window.value.anchor == old) {
+                _window.value = _window.value.copy(anchor = date)
+            }
         }
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000L), todayDate)
 
     // A transient, in-view override of the saved agenda range. Held in memory
     // (not persisted), so it survives view switches and rotation within the
@@ -146,8 +156,9 @@ class AgendaViewModel @Inject constructor(
         }
         .catch { emit(AgendaUiState.Failure(FailureReason.ProviderUnavailable)) }
         .flowOn(io)
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = AgendaUiState.Loading,
         )
 
@@ -163,17 +174,15 @@ class AgendaViewModel @Inject constructor(
     }
 
     /**
-     * Extend the window further back (#367), doubling what's loaded (at least
-     * [PAST_CHUNK_DAYS], at most [MAX_PAST_STEP_DAYS]) so a long scroll back
-     * re-queries only a few times. Ignored while the previous extension is
-     * still loading.
+     * Extend the window [PAST_CHUNK_DAYS] further back (#367). Ignored while the
+     * previous extension is still loading, so a scroll that keeps asking only
+     * moves one chunk at a time.
      */
     fun loadEarlier() {
         val loaded = (state.value as? AgendaUiState.Success)?.windowStart ?: return
         val window = _window.value
         if (loaded != window.start) return
-        val step = window.pastDays.coerceIn(PAST_CHUNK_DAYS, MAX_PAST_STEP_DAYS)
-        _window.value = window.copy(pastDays = window.pastDays + step)
+        _window.value = window.copy(pastDays = window.pastDays + PAST_CHUNK_DAYS)
     }
 
     fun rememberTopDay(date: LocalDate) {
@@ -235,9 +244,9 @@ class AgendaViewModel @Inject constructor(
 /** How many days each scroll back into the past loads (#367). */
 internal const val PAST_CHUNK_DAYS = 30
 
-/** The most one scroll back adds, so an empty past grows the window by years, not exponentially. */
-internal const val MAX_PAST_STEP_DAYS = 365
-
 /** Inclusive instant range from the start of [anchor] through [days] days ahead. */
-internal fun agendaRange(anchor: LocalDate, days: Int, zone: TimeZone): ClosedRange<Instant> =
-    dayRange(anchor, anchor.plus(days, DateTimeUnit.DAY), zone)
+internal fun agendaRange(anchor: LocalDate, days: Int, zone: TimeZone): ClosedRange<Instant> {
+    val from = anchor.atStartOfDayIn(zone)
+    val to = anchor.plus(days, DateTimeUnit.DAY).atTime(23, 59, 59).toInstant(zone)
+    return from..to
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/agenda/AgendaViewPreview.kt

@@ -6,8 +6,8 @@ import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.Dp
 import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
+import de.jeanlucmakiola.calendula.ui.common.ScaledViewPreview
 import de.jeanlucmakiola.calendula.ui.common.sampleAgendaEvents
-import de.jeanlucmakiola.floret.components.ScaledViewPreview
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone

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

@@ -1,6 +1,7 @@
 package de.jeanlucmakiola.calendula.ui.calendars
 
 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
@@ -53,17 +54,13 @@ 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.calendula.ui.common.orUnnamed
 import de.jeanlucmakiola.floret.components.CollapsingScaffold
 import de.jeanlucmakiola.floret.components.DialogAmountField
 import de.jeanlucmakiola.floret.components.DialogUnitDropdown
 import de.jeanlucmakiola.floret.components.FullScreenPicker
-import de.jeanlucmakiola.floret.components.GroupedHint
 import de.jeanlucmakiola.floret.components.GroupedRow
-import de.jeanlucmakiola.floret.components.GroupedSectionHeader
 import de.jeanlucmakiola.floret.components.Position
 import de.jeanlucmakiola.floret.components.positionOf
-import de.jeanlucmakiola.floret.locale.relativeTimeAgo
 import java.time.LocalDate
 
 // SAF mime filter for the restore picker. Source apps hand `.ics` files out
@@ -225,8 +222,8 @@ private fun BackupContent(
     val onRestoreClick = if (canImport) onRestore else (manageCalendars ?: onRestore)
 
     if (exportable.isEmpty()) {
-        GroupedSectionHeader(stringResource(R.string.calendars_restore_header))
-        GroupedHint(restoreSummary, style = MaterialTheme.typography.bodySmall)
+        SectionHeader(stringResource(R.string.calendars_restore_header))
+        HintText(restoreSummary)
         GroupedRow(
             title = stringResource(R.string.calendars_restore_action),
             position = Position.Alone,
@@ -236,7 +233,7 @@ private fun BackupContent(
         return
     }
 
-    GroupedHint(stringResource(R.string.calendars_backup_hint), style = MaterialTheme.typography.bodySmall)
+    HintText(stringResource(R.string.calendars_backup_hint))
     GroupedRow(
         title = stringResource(R.string.calendars_backup_action),
         position = Position.Top,
@@ -275,7 +272,7 @@ private fun BackupContent(
             position = Position.Bottom,
             onClick = onEditInterval,
         )
-        GroupedHint(backupStatusText(autoBackup.status), style = MaterialTheme.typography.bodySmall)
+        HintText(backupStatusText(autoBackup.status))
     }
 }
 
@@ -312,13 +309,12 @@ private fun ExportCalendarPicker(
     FullScreenPicker(
         title = stringResource(R.string.calendars_export_title),
         onDismiss = onDismiss,
-        predictiveBack = true,
     ) {
-        GroupedHint(stringResource(R.string.calendars_export_hint), style = MaterialTheme.typography.bodySmall)
+        HintText(stringResource(R.string.calendars_export_hint))
         calendars.forEachIndexed { index, calendar ->
             val isSelected = calendar.id in selected
             GroupedRow(
-                title = calendar.displayName.orUnnamed(),
+                title = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
                 summary = calendar.description,
                 position = positionOf(index, calendars.size),
                 leading = { CalendarColorChip(calendar.color) },
@@ -380,7 +376,9 @@ private fun backupIntervalLabel(minutes: Long): String {
 @Composable
 private fun backupStatusText(status: BackupStatus): String {
     if (status.lastRun == 0L) return stringResource(R.string.calendars_auto_backup_status_never)
-    val relative = relativeTimeAgo(status.lastRun)
+    val relative = DateUtils.getRelativeTimeSpanString(
+        status.lastRun, System.currentTimeMillis(), DateUtils.MINUTE_IN_MILLIS,
+    ).toString()
     return if (status.lastSuccess) {
         stringResource(R.string.calendars_auto_backup_status_ok, relative)
     } else {

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

@@ -12,21 +12,27 @@ import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ColumnScope
 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
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
+import androidx.compose.material.icons.automirrored.filled.Notes
 import androidx.compose.material.icons.automirrored.filled.OpenInNew
 import androidx.compose.material.icons.filled.Add
 import androidx.compose.material.icons.filled.Backup
 import androidx.compose.material.icons.filled.CalendarMonth
+import androidx.compose.material.icons.filled.Close
 import androidx.compose.material.icons.filled.Delete
 import androidx.compose.material.icons.filled.Info
 import androidx.compose.material.icons.filled.MoreVert
+import androidx.compose.material.icons.filled.Palette
 import androidx.compose.material.icons.filled.PhoneAndroid
 import androidx.compose.material.icons.filled.Visibility
 import androidx.compose.material.icons.filled.VisibilityOff
@@ -34,14 +40,20 @@ import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Button
 import androidx.compose.material3.DropdownMenu
 import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -72,7 +84,6 @@ import de.jeanlucmakiola.calendula.domain.stateLabels
 import de.jeanlucmakiola.calendula.data.calendar.CalendarColorPalette
 import de.jeanlucmakiola.calendula.ui.common.AccountKey
 import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
-import de.jeanlucmakiola.calendula.ui.common.CalendarVisibilitySwitch
 import de.jeanlucmakiola.calendula.ui.common.accountGroupTitle
 import de.jeanlucmakiola.calendula.ui.common.groupByAccount
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
@@ -82,14 +93,12 @@ 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
-import de.jeanlucmakiola.calendula.ui.common.orUnnamed
 import de.jeanlucmakiola.floret.components.CollapsingScaffold
-import de.jeanlucmakiola.floret.components.GroupedHint
-import de.jeanlucmakiola.floret.components.GroupedSectionHeader
 import de.jeanlucmakiola.floret.identity.LocalFloretDarkTheme
 import de.jeanlucmakiola.floret.identity.collapseExit
 import de.jeanlucmakiola.floret.identity.expandEnter
 import de.jeanlucmakiola.floret.identity.predictiveBack
+import de.jeanlucmakiola.floret.components.GroupedListInset
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.InlineTextField
 import de.jeanlucmakiola.floret.components.Position
@@ -215,7 +224,7 @@ private fun CalendarsList(
         visible = visible,
     ) {
         // What the per-calendar / per-account switches below actually do.
-        GroupedHint(stringResource(R.string.calendars_visibility_hint), style = MaterialTheme.typography.bodySmall)
+        HintText(stringResource(R.string.calendars_visibility_hint))
 
         // Local (device-only) calendars — one collapsible group. The header's
         // "+" adds a calendar; the switch enables/disables them all at once;
@@ -236,13 +245,24 @@ private fun CalendarsList(
             onToggleAll = { enabled -> onSetAccountVisible(local.map { it.id }, enabled) },
         ) {
             if (local.isEmpty()) {
-                GroupedHint(stringResource(R.string.calendars_local_empty), style = MaterialTheme.typography.bodySmall)
+                HintText(stringResource(R.string.calendars_local_empty))
             } else {
                 local.forEachIndexed { index, calendar ->
-                    CalendarManagerRow(
-                        calendar = calendar,
-                        last = index == local.lastIndex,
-                        onSetVisible = onSetVisible,
+                    val disabled = !calendar.isVisibleInSystem
+                    GroupedRow(
+                        title = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
+                        summary = calendarRowSummary(calendar),
+                        position = if (index == local.lastIndex) Position.Bottom else Position.Middle,
+                        container = MaterialTheme.colorScheme.surfaceContainerHighest,
+                        dimmed = disabled,
+                        leading = { CalendarColorChip(calendar.color, dimIf(disabled)) },
+                        trailing = {
+                            EnableSwitch(
+                                calendarName = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
+                                enabled = !disabled,
+                                onToggle = { enabled -> onSetVisible(calendar.id, enabled) },
+                            )
+                        },
                         onClick = { onEdit(calendar) },
                     )
                 }
@@ -271,8 +291,8 @@ private fun CalendarsList(
         // Synced calendars — read-only, grouped by account. Each account is a
         // collapsible group whose header opens the source app (icon) and toggles
         // all of its calendars at once (switch).
-        GroupedSectionHeader(stringResource(R.string.calendars_synced_header))
-        GroupedHint(stringResource(R.string.calendars_synced_hint), style = MaterialTheme.typography.bodySmall)
+        SectionHeader(stringResource(R.string.calendars_synced_header))
+        HintText(stringResource(R.string.calendars_synced_hint))
         synced
             .groupByAccount()
             .forEach { group ->
@@ -313,10 +333,27 @@ private fun CalendarsList(
                     // bottom, dimmed and switchless.
                     val ordered = cals.orderedForManager()
                     ordered.forEachIndexed { index, calendar ->
-                        CalendarManagerRow(
-                            calendar = calendar,
-                            last = index == ordered.lastIndex,
-                            onSetVisible = onSetVisible,
+                        val disabled = !calendar.isVisibleInSystem || calendar.isNotSynced
+                        GroupedRow(
+                            title = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
+                            summary = calendarRowSummary(calendar),
+                            position = if (index == ordered.lastIndex) Position.Bottom else Position.Middle,
+                            container = MaterialTheme.colorScheme.surfaceContainerHighest,
+                            dimmed = disabled,
+                            leading = { CalendarColorChip(calendar.color, dimIf(disabled)) },
+                            trailing = if (calendar.hasVisibilitySwitch) {
+                                {
+                                    EnableSwitch(
+                                        calendarName = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
+                                        enabled = calendar.isVisibleInSystem,
+                                        onToggle = { enabled ->
+                                            onSetVisible(calendar.id, enabled)
+                                        },
+                                    )
+                                }
+                            } else {
+                                null
+                            },
                         )
                     }
                 }
@@ -655,37 +692,17 @@ private fun calendarRowSummary(calendar: CalendarSource): String? {
  * `Calendars.VISIBLE`. Unchecked drops the calendar out of every surface and
  * stops its reminders. Carries its own content description.
  */
-/**
- * One calendar in a group: dimmed while switched off or not syncing, with the
- * visibility switch only where it can change anything.
- */
 @Composable
-private fun CalendarManagerRow(
-    calendar: CalendarSource,
-    last: Boolean,
-    onSetVisible: (Long, Boolean) -> Unit,
-    onClick: (() -> Unit)? = null,
+private fun EnableSwitch(
+    calendarName: String,
+    enabled: Boolean,
+    onToggle: (Boolean) -> Unit,
 ) {
-    val disabled = !calendar.isVisibleInSystem || calendar.isNotSynced
-    GroupedRow(
-        title = calendar.displayName.orUnnamed(),
-        summary = calendarRowSummary(calendar),
-        position = if (last) Position.Bottom else Position.Middle,
-        container = MaterialTheme.colorScheme.surfaceContainerHighest,
-        dimmed = disabled,
-        leading = { CalendarColorChip(calendar.color, dimIf(disabled)) },
-        trailing = if (calendar.hasVisibilitySwitch) {
-            {
-                CalendarVisibilitySwitch(
-                    calendarName = calendar.displayName.orUnnamed(),
-                    enabled = calendar.isVisibleInSystem,
-                    onToggle = { enabled -> onSetVisible(calendar.id, enabled) },
-                )
-            }
-        } else {
-            null
-        },
-        onClick = onClick,
+    val label = stringResource(R.string.calendars_visibility_a11y, calendarName)
+    Switch(
+        checked = enabled,
+        onCheckedChange = onToggle,
+        modifier = Modifier.semantics { contentDescription = label },
     )
 }
 
@@ -824,6 +841,33 @@ private fun CalendarGroupMenu(
 }
 
 
+@Composable
+internal fun SectionHeader(text: String) {
+    Text(
+        text = text,
+        style = MaterialTheme.typography.labelLarge,
+        color = MaterialTheme.colorScheme.primary,
+        // The cards' own edge, so header and group share a left margin.
+        modifier = Modifier.padding(
+            start = GroupedListInset,
+            end = GroupedListInset,
+            top = 16.dp,
+            bottom = 4.dp,
+        ),
+    )
+}
+
+@Composable
+internal fun HintText(text: String) {
+    Text(
+        text = text,
+        style = MaterialTheme.typography.bodySmall,
+        color = MaterialTheme.colorScheme.onSurfaceVariant,
+        modifier = Modifier.padding(horizontal = GroupedListInset, vertical = 4.dp),
+    )
+}
+
+
 /**
  * Pick the app to open for managing a synced calendar's account. The account's
  * own authenticator package (resolved from [AccountManager], no permission

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

@@ -9,16 +9,16 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.data.backup.BackupScheduler
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 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 de.jeanlucmakiola.floret.android.stateWhileSubscribed
-import de.jeanlucmakiola.floret.di.IoDispatcher
 import kotlinx.coroutines.CoroutineDispatcher
 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
@@ -26,6 +26,7 @@ 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
 import kotlin.coroutines.cancellation.CancellationException
@@ -51,8 +52,9 @@ class CalendarsViewModel @Inject constructor(
         repository.calendars()
             .catch { emit(emptyList()) }
             .flowOn(io)
-            .stateWhileSubscribed(
+            .stateIn(
                 scope = viewModelScope,
+                started = SharingStarted.WhileSubscribed(5_000L),
                 initialValue = emptyList(),
             )
 
@@ -66,8 +68,9 @@ class CalendarsViewModel @Inject constructor(
             .map { backupUiState(it) }
             .catch { emit(BackupUiState.Failure(FailureReason.ProviderUnavailable)) }
             .flowOn(io)
-            .stateWhileSubscribed(
+            .stateIn(
                 scope = viewModelScope,
+                started = SharingStarted.WhileSubscribed(5_000L),
                 initialValue = BackupUiState.Loading,
             )
 
@@ -81,8 +84,9 @@ class CalendarsViewModel @Inject constructor(
         AutoBackupUiState(enabled, interval, folder, status)
     }
         .flowOn(io)
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = AutoBackupUiState(),
         )
 
@@ -99,8 +103,9 @@ class CalendarsViewModel @Inject constructor(
         if (!enabled) emptySet() else sources.filter { it.isManaged }.map { it.id }.toSet()
     }
         .flowOn(io)
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = emptySet(),
         )
 

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

@@ -57,7 +57,7 @@ fun List<CalendarSource>.groupByAccount(): List<CalendarAccountGroup> {
  */
 @Composable
 fun accountGroupTitle(group: CalendarAccountGroup): String {
-    val label = group.label.orUnnamed()
+    val label = group.label.ifBlank { stringResource(R.string.calendar_unnamed) }
     return if (!group.ambiguous) {
         label
     } else {

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

@@ -77,8 +77,6 @@ class EventSelection(
     val event: EventInstance,
     val dismiss: () -> Unit,
     val create: (() -> Unit)? = null,
-    /** The event at the times an ongoing move or resize would give it, else null. */
-    val preview: () -> EventInstance? = { null },
 )
 
 /** The screen on show's [ScreenChrome] and [ScreenActions], for the host to draw. */
@@ -128,12 +126,10 @@ fun PublishSelection(
     compact: Boolean,
     onDismiss: () -> Unit,
     onCreate: (() -> Unit)? = null,
-    preview: () -> EventInstance? = { null },
 ) {
     val slot = LocalChromeSlot.current ?: return
     val currentDismiss by rememberUpdatedState(onDismiss)
     val currentCreate by rememberUpdatedState(onCreate)
-    val currentPreview by rememberUpdatedState(preview)
     val drafted = onCreate != null
     val selection = remember(event, drafted) {
         event?.let {
@@ -141,7 +137,6 @@ fun PublishSelection(
                 event = it,
                 dismiss = { currentDismiss() },
                 create = if (drafted) ({ currentCreate?.invoke() }) else null,
-                preview = { currentPreview() },
             )
         }
     }

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

@@ -30,9 +30,7 @@ fun CalendarDatePickerDialog(
     onDismiss: () -> Unit,
 ) {
     val state = rememberDatePickerState(
-        initialSelectedDateMillis = initial.coerceIn(CalendarSpan.FIRST_DAY, CalendarSpan.LAST_DAY)
-            .toEpochDays() * MILLIS_PER_DAY,
-        yearRange = CalendarSpan.years,
+        initialSelectedDateMillis = initial.toEpochDays() * MILLIS_PER_DAY,
     )
     DatePickerDialog(
         onDismissRequest = onDismiss,

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

@@ -26,6 +26,8 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.Stable
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.graphicsLayer
@@ -80,7 +82,8 @@ fun CalendarFabColumn(
             )
         }
         // Held past the selection clearing, so the bar has something to fold away.
-        val heldBar = rememberHeld(selection?.bar)
+        val heldBar = remember { mutableStateOf<(@Composable () -> Unit)?>(null) }
+        if (selection != null && heldBar.value !== selection.bar) heldBar.value = selection.bar
         // Held at the FAB's height so the taller bar can't shift the FAB.
         Row(
             modifier = Modifier.height(FabSize),
@@ -98,7 +101,7 @@ fun CalendarFabColumn(
                     shrinkTowards = Alignment.End,
                 ) + fadeOut(),
             ) {
-                heldBar?.invoke()
+                heldBar.value?.invoke()
             }
             val label = stringResource(
                 when {

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

@@ -34,6 +34,7 @@ import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.Position
+import de.jeanlucmakiola.floret.components.SelectedCheck
 
 /**
  * The app's single "which calendar" selection list, shared by the event editor
@@ -113,11 +114,17 @@ private fun CalendarPickerGroup(
         leading = leading,
     )
     calendars.forEachIndexed { index, calendar ->
+        val isSelected = calendar.id == selectedId
         GroupedRow(
-            title = calendar.displayName.orUnnamed(),
+            title = calendar.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
             position = if (index == calendars.lastIndex) Position.Bottom else Position.Middle,
-            checked = calendar.id == selectedId,
+            selected = isSelected,
             leading = { CalendarColorChip(calendar.color) },
+            trailing = if (isSelected) {
+                { SelectedCheck() }
+            } else {
+                null
+            },
             onClick = { onSelect(calendar.id) },
         )
     }

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

@@ -1,14 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import kotlinx.datetime.LocalDate
-
-/**
- * The dates every view can show and every date picker offers. One span for all
- * of them, so no view can hand another a date it has no page for (#457).
- */
-object CalendarSpan {
-    val FIRST_DAY: LocalDate = LocalDate(1600, 1, 1)
-    val LAST_DAY: LocalDate = LocalDate(2399, 12, 31)
-
-    val years: IntRange get() = FIRST_DAY.year..LAST_DAY.year
-}

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

@@ -3,12 +3,10 @@ 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.res.stringResource
 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
-import de.jeanlucmakiola.calendula.R
 
 /**
  * The calendar surfaces' line-height treatment. Material wraps an 11sp glyph in
@@ -57,7 +55,3 @@ fun rememberTrimmedLineHeight(style: TextStyle): Dp {
         with(density) { measurer.measure(LINE_SAMPLE, style.trimmedLines()).size.height.toDp() }
     }
 }
-
-/** A calendar or account name, or the "unnamed" label when it is blank. */
-@Composable
-fun String.orUnnamed(): String = ifBlank { stringResource(R.string.calendar_unnamed) }

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

@@ -1,24 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.material3.Switch
-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 de.jeanlucmakiola.calendula.R
-
-/** The per-row switch writing the device's own `Calendars.VISIBLE`, as Settings does (#75). */
-@Composable
-fun CalendarVisibilitySwitch(
-    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/common/DayRange.kt

@@ -1,22 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import kotlinx.datetime.DateTimeUnit
-import kotlinx.datetime.DayOfWeek
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.atStartOfDayIn
-import kotlinx.datetime.atTime
-import kotlinx.datetime.minus
-import kotlinx.datetime.toInstant
-import kotlin.time.Instant
-
-/** Instant range from the start of [first] through the last second of [last] in [zone]. */
-internal fun dayRange(first: LocalDate, last: LocalDate, zone: TimeZone): ClosedRange<Instant> =
-    first.atStartOfDayIn(zone)..last.atTime(23, 59, 59).toInstant(zone)
-
-/** Beginning of the week (at [weekStart]) that contains this date. */
-internal fun LocalDate.startOfWeek(weekStart: DayOfWeek): LocalDate {
-    // DayOfWeek.ordinal: MONDAY=0..SUNDAY=6 → identical to ISO ordering.
-    val offset = ((dayOfWeek.ordinal - weekStart.ordinal) + 7) % 7
-    return minus(offset, DateTimeUnit.DAY)
-}

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

@@ -3,6 +3,7 @@ package de.jeanlucmakiola.calendula.ui.common
 import android.Manifest
 import android.content.Context
 import android.content.Intent
+import android.content.pm.PackageManager
 import android.net.Uri
 import android.util.Log
 import androidx.activity.compose.rememberLauncherForActivityResult
@@ -17,12 +18,12 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
+import androidx.core.content.ContextCompat
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.calendar.NoSuchEventException
@@ -31,7 +32,6 @@ import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
 import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
 import de.jeanlucmakiola.calendula.domain.ics.toShareIcsEvent
-import de.jeanlucmakiola.floret.android.hasPermission
 import de.jeanlucmakiola.floret.components.OptionCard
 import kotlin.coroutines.cancellation.CancellationException
 import kotlin.time.Clock
@@ -73,13 +73,10 @@ suspend fun CalendarRepository.deleteEvent(
 /** How a [tryDeleteEvent] ended. */
 enum class DeleteOutcome { Deleted, Gone, NeedsPermission, Failed }
 
-/** Whether this install may read the calendar at all. */
-fun Context.canReadCalendar(): Boolean =
-    hasPermission(Manifest.permission.READ_CALENDAR)
-
 /** Whether this install may write to the calendar; v1.0 installs only hold read access. */
 fun Context.canWriteCalendar(): Boolean =
-    hasPermission(Manifest.permission.WRITE_CALENDAR)
+    ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_CALENDAR) ==
+        PackageManager.PERMISSION_GRANTED
 
 /** [deleteEvent], with the provider's failures mapped to a [DeleteOutcome]. */
 suspend fun CalendarRepository.tryDeleteEvent(
@@ -101,28 +98,33 @@ suspend fun CalendarRepository.tryDeleteEvent(
 }
 
 /**
- * [action], which writes to the calendar, as a handler that asks for
- * `WRITE_CALENDAR` first where the install only holds read access (v1.0
- * installs). A grant continues into [action], also when it returns after a
- * rotation; a refusal runs [onDenied].
+ * Runs an action that writes to the calendar, asking for `WRITE_CALENDAR` first
+ * where the install only holds read access (v1.0 installs). A grant continues
+ * straight into the action that asked for it.
  */
 @Composable
-fun rememberWriteAction(onDenied: () -> Unit = {}, action: () -> Unit): () -> Unit {
+fun rememberWriteGate(): (() -> Unit) -> Unit {
+    val gate = rememberWriteGateOr()
+    return { action -> gate(action) {} }
+}
+
+/** [rememberWriteGate], running the fallback instead when the user refuses. */
+@Composable
+fun rememberWriteGateOr(): (action: () -> Unit, fallback: () -> Unit) -> Unit {
     val context = LocalContext.current
-    val currentAction by rememberUpdatedState(action)
-    val currentDenied by rememberUpdatedState(onDenied)
+    var pending by remember { mutableStateOf<Pair<() -> Unit, () -> Unit>?>(null) }
     val launcher = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.RequestPermission(),
     ) { granted ->
-        if (granted) currentAction() else currentDenied()
+        pending?.let { (action, fallback) -> if (granted) action() else fallback() }
+        pending = null
     }
-    return remember(context, launcher) {
-        {
-            if (context.canWriteCalendar()) {
-                currentAction()
-            } else {
-                launcher.launch(Manifest.permission.WRITE_CALENDAR)
-            }
+    return { action, fallback ->
+        if (context.canWriteCalendar()) {
+            action()
+        } else {
+            pending = action to fallback
+            launcher.launch(Manifest.permission.WRITE_CALENDAR)
         }
     }
 }

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

@@ -6,8 +6,8 @@ import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.calendar.NoSuchEventException
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.ics.IcsExporter
-import de.jeanlucmakiola.calendula.data.time.ZoneSource
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.EventForm
@@ -15,18 +15,19 @@ import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
 import de.jeanlucmakiola.calendula.domain.atOccurrence
 import de.jeanlucmakiola.calendula.domain.toDuplicateForm
-import de.jeanlucmakiola.floret.android.stateWhileSubscribed
-import de.jeanlucmakiola.floret.di.IoDispatcher
 import kotlinx.coroutines.CoroutineDispatcher
 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.first
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import kotlinx.datetime.TimeZone
 import kotlin.coroutines.cancellation.CancellationException
 import javax.inject.Inject
 
@@ -42,7 +43,6 @@ class EventActionsViewModel @Inject constructor(
     private val repository: CalendarRepository,
     private val icsExporter: IcsExporter,
     @IoDispatcher private val io: CoroutineDispatcher,
-    private val zoneSource: ZoneSource,
 ) : ViewModel() {
 
     /** Every calendar by id, for what a selected event's bar may offer. */
@@ -50,8 +50,9 @@ class EventActionsViewModel @Inject constructor(
         .map { list -> list.associateBy { it.id } }
         .catch { emit(emptyMap()) }
         .flowOn(io)
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = emptyMap(),
         )
 
@@ -65,7 +66,7 @@ class EventActionsViewModel @Inject constructor(
     suspend fun duplicateForm(event: EventInstance): EventForm? {
         val detail = load(event) ?: return null
         val canModify = calendars.value[event.calendarId]?.canModifyContents == true
-        return detail.toDuplicateForm(canModify, zoneSource.current())
+        return detail.toDuplicateForm(canModify, TimeZone.currentSystemDefault())
     }
 
     /** A staged `.ics` for [event], or null — reported — when it can't be built. */

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

@@ -212,21 +212,11 @@ private fun rememberPickUpSurface(
         }
 }
 
-/**
- * A lift on pickup, a tick every time the drop target snaps to a new slot, and a
- * confirm each time [drops] counts a real drop.
- */
+/** A lift on pickup, then a tick every time the drop target snaps to a new slot. */
 @Composable
-fun DragSnapHaptics(slot: Any?, drops: Int) {
+fun DragSnapHaptics(slot: Any?) {
     val haptics = LocalHapticFeedback.current
     val previous = remember { arrayOfNulls<Any>(1) }
-    val dropsSeen = remember { intArrayOf(drops) }
-    LaunchedEffect(drops) {
-        if (drops != dropsSeen[0]) {
-            dropsSeen[0] = drops
-            haptics.performHapticFeedback(HapticFeedbackType.Confirm)
-        }
-    }
     LaunchedEffect(slot) {
         val had = previous[0]
         previous[0] = slot

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

@@ -11,7 +11,6 @@ import androidx.compose.material.icons.filled.People
 import androidx.compose.material.icons.filled.Place
 import androidx.compose.material.icons.filled.Public
 import androidx.compose.material.icons.filled.Repeat
-import androidx.compose.material.icons.filled.TaskAlt
 import androidx.compose.ui.graphics.vector.ImageVector
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventFormField
@@ -30,7 +29,6 @@ fun eventFormFieldLabel(field: EventFormField): Int = when (field) {
     EventFormField.Reminders -> R.string.event_detail_reminders
     EventFormField.Recurrence -> R.string.event_detail_recurrence
     EventFormField.Availability -> R.string.event_edit_availability
-    EventFormField.Status -> R.string.event_edit_status
     EventFormField.Visibility -> R.string.event_edit_visibility
     EventFormField.Color -> R.string.event_edit_color
     EventFormField.Attendees -> R.string.event_edit_attendees
@@ -43,7 +41,6 @@ fun eventFormFieldIcon(field: EventFormField): ImageVector = when (field) {
     EventFormField.Reminders -> Icons.Default.Notifications
     EventFormField.Recurrence -> Icons.Default.Repeat
     EventFormField.Availability -> Icons.Default.EventAvailable
-    EventFormField.Status -> Icons.Default.TaskAlt
     EventFormField.Visibility -> Icons.Default.Lock
     EventFormField.Color -> Icons.Default.Palette
     EventFormField.Attendees -> Icons.Default.People

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

@@ -68,7 +68,6 @@ fun EventMoveHost(
             ),
             onSelect = viewModel::moveWithScope,
             onDismiss = viewModel::cancelScope,
-            allowOccurrence = !pending.seriesOnly,
             allowSeries = !pending.occurrenceOnly,
             reason = stringResource(R.string.event_move_occurrence_only)
                 .takeIf { pending.occurrenceOnly },

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

@@ -21,8 +21,8 @@ import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.domain.isCrossedOut
-import de.jeanlucmakiola.calendula.domain.isOutlined
+import de.jeanlucmakiola.calendula.domain.EventResponse
+import de.jeanlucmakiola.calendula.domain.isDeclined
 
 /** Stroke an invitation you have not answered is outlined with. */
 val EVENT_OUTLINE_WIDTH = 1.dp
@@ -60,13 +60,13 @@ fun timedBlockCuts(continuesBefore: Boolean, continuesAfter: Boolean): ChipCuts
 
 /**
  * How one event's chip or block is painted, which turns on your answer to its
- * invitation (#180, #230) and on the event's own status (#388).
+ * invitation (#180, #230).
  *
- * An invitation you have not answered, or a tentative event, is drawn as an
- * outline: its calendar's colour on the border and on the title, over the
- * surface the chip sits on. So it holds a chip's shape and a chip's weight
- * without claiming the filled container an event you are going to gets. A
- * declined or cancelled one keeps the fill and its strike-through.
+ * An invitation you have not answered is drawn as an outline: its calendar's
+ * colour on the border and on the title, over the surface the chip sits on. So
+ * it holds a chip's shape and a chip's weight without claiming the filled
+ * container an event you are going to gets. A declined one keeps the fill and
+ * its strike-through.
  */
 @Immutable
 data class EventPaint(
@@ -87,7 +87,7 @@ data class EventPaint(
 @Composable
 fun eventPaint(event: EventInstance, dark: Boolean): EventPaint {
     val soften = LocalSoftenColors.current
-    if (event.isOutlined) {
+    if (event.response == EventResponse.Invited) {
         // Harmonised even when the setting is off. Raw mode exists so a filled
         // container matches what the sync source paints, and an outlined chip
         // has no container — what it has is coloured *text*, which needs the
@@ -117,7 +117,7 @@ fun eventPaint(event: EventInstance, dark: Boolean): EventPaint {
         outline = null,
         titleInk = eventInk(fill, alpha = TITLE_INK_ALPHA),
         secondaryInk = eventInk(fill, alpha = SECONDARY_INK_ALPHA),
-        decoration = declinedDecoration(event.isCrossedOut),
+        decoration = declinedDecoration(event.isDeclined),
         titleWeight = null,
     )
 }

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

@@ -9,6 +9,7 @@ import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventForm
@@ -32,6 +33,7 @@ fun rememberFabSelection(
     val calendars by viewModel.calendars.collectAsStateWithLifecycle()
     val context = LocalContext.current
     val scope = rememberCoroutineScope()
+    val requireWrite = rememberWriteGate()
     val chooserTitle = stringResource(R.string.event_share_chooser_title)
 
     // What the FAB has been told for this selection, over what the coverage says.
@@ -42,28 +44,10 @@ fun rememberFabSelection(
     val currentEdit by rememberUpdatedState(onEdit)
     val currentDuplicate by rememberUpdatedState(onDuplicate)
     val currentDismissChip by rememberUpdatedState(onDismissChip)
-    // Each reads the selection at grant time, which may come after a rotation.
-    val onCreate = rememberWriteAction { host.selection?.create?.invoke() }
-    val onEditSelected = rememberWriteAction {
-        host.selection?.takeIf { it.create == null }?.let { selected ->
-            selected.dismiss()
-            currentEdit(selected.event)
-        }
-    }
-    val onDuplicateSelected = rememberWriteAction {
-        val selected = host.selection?.takeIf { it.create == null } ?: return@rememberWriteAction
-        scope.launch {
-            val form = viewModel.duplicateForm(selected.event) ?: return@launch
-            selected.dismiss()
-            currentDuplicate(form)
-        }
-    }
-    val onDeleteSelected = rememberWriteAction {
-        host.selection?.takeIf { it.create == null }?.let { viewModel.requestDelete(it.event) }
-    }
+    val currentWrite by rememberUpdatedState(requireWrite)
 
     val selection = host.selection ?: return null
-    if (selection.create != null) {
+    selection.create?.let { create ->
         return remember(selection, expanded, chipShown) {
             FabSelection(
                 expanded = expanded,
@@ -73,7 +57,7 @@ fun rememberFabSelection(
                 },
                 bar = {
                     DraftSelectionBar(
-                        onCreate = onCreate,
+                        onCreate = { currentWrite { create() } },
                         onDiscard = selection.dismiss,
                     )
                 },
@@ -95,15 +79,28 @@ fun rememberFabSelection(
                 EventSelectionBar(
                     canEdit = canEdit,
                     canDelete = canDelete,
-                    onEdit = onEditSelected,
-                    onDuplicate = onDuplicateSelected,
+                    onEdit = {
+                        currentWrite {
+                            selection.dismiss()
+                            currentEdit(event)
+                        }
+                    },
+                    onDuplicate = {
+                        currentWrite {
+                            scope.launch {
+                                val form = viewModel.duplicateForm(event) ?: return@launch
+                                selection.dismiss()
+                                currentDuplicate(form)
+                            }
+                        }
+                    },
                     onShare = {
                         scope.launch {
                             val uri = viewModel.shareUri(event) ?: return@launch
                             if (!context.sendEventShare(uri, chooserTitle)) viewModel.reportShareFailed()
                         }
                     },
-                    onDelete = onDeleteSelected,
+                    onDelete = { currentWrite { viewModel.requestDelete(event) } },
                 )
             },
         )

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

@@ -20,6 +20,7 @@ import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalDensity
@@ -110,13 +111,14 @@ fun HourGutter(
             }
         }
         // Held while it fades, so it goes out where it was rather than blinking off.
-        val badgeMin = rememberHeld(dragStartMin)
+        val badgeMin = remember { mutableStateOf<Int?>(null) }
+        dragStartMin?.let { badgeMin.value = it }
         val badgeIn by animateFloatAsState(
             targetValue = if (dragStartMin != null) 1f else 0f,
             animationSpec = MaterialTheme.motionScheme.fastEffectsSpec(),
             label = "gutterBadge",
         )
-        badgeMin?.takeIf { badgeIn > 0f }?.let { startMin ->
+        badgeMin.value?.takeIf { badgeIn > 0f }?.let { startMin ->
             val top = (hourHeight * (startMin / 60f) - BADGE_HEIGHT / 2).coerceAtLeast(0.dp)
             Box(
                 modifier = Modifier

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

@@ -1,26 +1,22 @@
 package de.jeanlucmakiola.calendula.ui.common
 
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.ExperimentalForInheritanceCoroutinesApi
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
+import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.FlowCollector
-import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.launch
+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.
  *
- * An entry queries only while something collects it, stopping [STOP_TIMEOUT_MILLIS]
- * after the last collector leaves, and starts again when one comes back. Letting
- * an entry go only forgets it: a page still holding it keeps a working state
- * however far the pager composes or prefetches, and however long the screen sat
- * stopped (#440, #454). A forgotten entry nobody collects holds no coroutine, so
- * paging through a year doesn't keep a year of queries around. Main thread only.
+ * 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.
  */
@@ -30,54 +26,28 @@ class PageStateCache<K, S>(
     private val keep: (cached: K, requested: K) -> Boolean,
     private val load: (K) -> Flow<S>,
 ) {
-    private val entries = HashMap<K, Entry>()
+    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> {
-        // One still collected stays, so the anchor asking for it again shares its query.
-        entries.entries.removeAll { (cached, entry) ->
-            cached != key && !keep(cached, key) && !entry.isCollected
-        }
-        return entries.getOrPut(key) { Entry(key) }
-    }
-
-    @OptIn(ExperimentalForInheritanceCoroutinesApi::class)
-    private inner class Entry(private val key: K) : StateFlow<S> {
-        private val state = MutableStateFlow(initial)
-        private var collectors = 0
-        private var loading: Job? = null
-        private var stopping: Job? = null
-
-        val isCollected: Boolean get() = collectors > 0
-
-        override val value: S get() = state.value
-        override val replayCache: List<S> get() = state.replayCache
-
-        override suspend fun collect(collector: FlowCollector<S>): Nothing {
-            collectors++
-            stopping?.cancel()
-            stopping = null
-            if (loading?.isActive != true) {
-                loading = scope.launch { load(key).collect { state.value = it } }
-            }
-            try {
-                state.collect(collector)
-            } finally {
-                if (--collectors == 0) {
-                    stopping = scope.launch {
-                        delay(STOP_TIMEOUT_MILLIS)
-                        loading?.cancel()
-                        loading = null
-                    }
-                }
+        val iterator = entries.iterator()
+        while (iterator.hasNext()) {
+            val (cached, entry) = iterator.next()
+            if (cached != key && !keep(cached, key)) {
+                entry.job.cancel()
+                iterator.remove()
             }
         }
-    }
-
-    private companion object {
-        /** Long enough to ride out a configuration change, as `stateWhileSubscribed` does. */
-        const val STOP_TIMEOUT_MILLIS = 5_000L
+        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/PastEvents.kt

@@ -30,7 +30,7 @@ fun EventInstance.isPastOn(
     day: LocalDate,
     now: Instant,
     zone: TimeZone = TimeZone.currentSystemDefault(),
-): Boolean = hasEnded(now, zone) || day < now.toLocalDateTime(zone).date
+): Boolean = hasEnded(now) || day < now.toLocalDateTime(zone).date
 
 /** Opacity applied to a completed/past event chip when it is dimmed. */
 const val EventDimAlpha = 0.4f
@@ -41,19 +41,19 @@ const val EventDimAlpha = 0.4f
  * is still something the organiser expects you at. Null for everything else, so
  * it drops straight into a `Text`'s `textDecoration`.
  */
-fun declinedDecoration(isCrossedOut: Boolean): TextDecoration? =
-    if (isCrossedOut) TextDecoration.LineThrough else null
+fun declinedDecoration(isDeclined: Boolean): TextDecoration? =
+    if (isDeclined) TextDecoration.LineThrough else null
 
 /** [declinedDecoration] for the rows that take styled text rather than a `String`. */
-fun declinedTitle(title: String, isCrossedOut: Boolean): AnnotatedString = if (isCrossedOut) {
+fun declinedTitle(title: String, isDeclined: Boolean): AnnotatedString = if (isDeclined) {
     AnnotatedString(title, SpanStyle(textDecoration = TextDecoration.LineThrough))
 } else {
     AnnotatedString(title)
 }
 
 /** [declinedTitle] over already-styled text, e.g. a search hit's marked runs. */
-fun declinedTitle(title: AnnotatedString, isCrossedOut: Boolean): AnnotatedString =
-    if (!isCrossedOut) {
+fun declinedTitle(title: AnnotatedString, isDeclined: Boolean): AnnotatedString =
+    if (!isDeclined) {
         title
     } else {
         buildAnnotatedString {

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

@@ -1,8 +1,14 @@
 package de.jeanlucmakiola.calendula.ui.common
 
+import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
 import androidx.compose.material3.Checkbox
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -16,16 +22,17 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.floret.components.CustomAmountEditor
-import de.jeanlucmakiola.floret.components.CustomExpandRow
 import de.jeanlucmakiola.floret.components.FullScreenPicker
-import de.jeanlucmakiola.floret.components.GroupedHint
+import de.jeanlucmakiola.floret.components.GroupedListInset
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.Position
+import de.jeanlucmakiola.floret.components.SelectedCheck
 import de.jeanlucmakiola.floret.components.positionOf
+import de.jeanlucmakiola.floret.identity.collapseExit
+import de.jeanlucmakiola.floret.identity.expandEnter
 import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.floret.reminders.ReminderOverride
 import de.jeanlucmakiola.floret.reminders.ReminderUnit
-import de.jeanlucmakiola.floret.reminders.minutesOrEmpty
 import de.jeanlucmakiola.floret.reminders.reminderOverrideForMinutes
 import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.agenda.agendaRangeWindowSummary
@@ -83,7 +90,7 @@ fun ReminderDefaultPicker(
     }
     val inherits = current is ReminderOverride.Inherit
     val isNone = current is ReminderOverride.None
-    val selectedMinutes = current.minutesOrEmpty()
+    val selectedMinutes = (current as? ReminderOverride.Minutes)?.minutes.orEmpty()
     // Custom (non-preset) lead times seen this session, so unchecking one keeps
     // its row (unchecked) until the picker closes instead of vanishing mid-tap,
     // which would strand a hand-entered value with no way to re-check it.
@@ -114,14 +121,24 @@ fun ReminderDefaultPicker(
             GroupedRow(
                 title = stringResource(R.string.reminder_use_default),
                 position = Position.Top,
-                checked = inherits,
+                selected = inherits,
+                trailing = if (inherits) {
+                    { SelectedCheck() }
+                } else {
+                    null
+                },
                 onClick = { apply(ReminderOverride.Inherit) },
             )
         }
         GroupedRow(
             title = stringResource(R.string.reminder_none),
             position = if (allowInherit) Position.Bottom else Position.Alone,
-            checked = isNone,
+            selected = isNone,
+            trailing = if (isNone) {
+                { SelectedCheck() }
+            } else {
+                null
+            },
             onClick = { apply(ReminderOverride.None) },
         )
         Spacer(Modifier.height(24.dp))
@@ -137,11 +154,17 @@ fun ReminderDefaultPicker(
                 onClick = { toggle(minute) },
             )
         }
-        CustomExpandRow(
+        // When expanded, the Custom row connects downward into the editor card
+        // so the two read as one grouped container (the per-calendar pattern).
+        GroupedRow(
             title = stringResource(R.string.event_edit_reminder_custom),
-            position = positionOf(rows.size, rowCount),
-            expanded = customExpanded,
-            onExpandedChange = { customExpanded = it },
+            position = if (customExpanded) Position.Top else positionOf(rows.size, rowCount),
+            onClick = { customExpanded = !customExpanded },
+        )
+        AnimatedVisibility(
+            visible = customExpanded,
+            enter = expandEnter(),
+            exit = collapseExit(),
         ) {
             CustomReminderEditor(
                 amountText = amountText,
@@ -189,6 +212,19 @@ private fun CustomReminderEditor(
     )
 }
 
+/** A short explanatory paragraph shown under a picker's title, above the rows,
+ *  on the same left margin as the rows themselves. */
+@Composable
+internal fun PickerDescription(text: String) {
+    Text(
+        text = text,
+        style = MaterialTheme.typography.bodyMedium,
+        color = MaterialTheme.colorScheme.onSurfaceVariant,
+        modifier = Modifier.padding(horizontal = GroupedListInset, vertical = 8.dp),
+    )
+}
+
+
 /**
  * Agenda-range picker, full-screen. Two grouped lists — the calendar-aligned
  * options (today / this week / this month) and the rolling windows (next 7 / 30
@@ -229,11 +265,17 @@ fun AgendaRangePicker(
     }
 
     val rangeRow: @Composable (AgendaRange, Position) -> Unit = { option, position ->
+        val isSelected = option == selected
         GroupedRow(
             title = agendaRangeLabel(option),
             summary = windowSummary(option),
             position = position,
-            checked = option == selected,
+            selected = isSelected,
+            trailing = if (isSelected) {
+                { SelectedCheck() }
+            } else {
+                null
+            },
             onClick = {
                 onSelect(option)
                 onDismiss()
@@ -242,7 +284,7 @@ fun AgendaRangePicker(
     }
 
     FullScreenPicker(title = title, onDismiss = onDismiss) {
-        GroupedHint(description, verticalPadding = 8.dp)
+        PickerDescription(description)
 
         // Calendar-aligned windows.
         calendarAligned.forEachIndexed { index, option ->
@@ -255,7 +297,7 @@ fun AgendaRangePicker(
         rolling.forEachIndexed { index, option ->
             rangeRow(option, positionOf(index, rollingRowCount))
         }
-        CustomExpandRow(
+        GroupedRow(
             title = if (customSelected) {
                 agendaRangeLabel(selected)
             } else {
@@ -264,10 +306,19 @@ fun AgendaRangePicker(
             // An unset custom window has no day count yet, so the row stays
             // single-line until it does.
             summary = if (customSelected) windowSummary(selected) else null,
-            position = positionOf(rolling.size, rollingRowCount),
-            expanded = customExpanded,
-            onExpandedChange = { customExpanded = it },
-            checked = customSelected,
+            position = if (customExpanded) Position.Top else positionOf(rolling.size, rollingRowCount),
+            selected = customSelected,
+            trailing = if (customSelected) {
+                { SelectedCheck() }
+            } else {
+                null
+            },
+            onClick = { customExpanded = !customExpanded },
+        )
+        AnimatedVisibility(
+            visible = customExpanded,
+            enter = expandEnter(),
+            exit = collapseExit(),
         ) {
             CustomDaysEditor(
                 amountText = amountText,
@@ -345,12 +396,17 @@ fun DurationPicker(
     }
 
     FullScreenPicker(title = title, onDismiss = onDismiss, predictiveBack = true) {
-        if (description != null) GroupedHint(description, verticalPadding = 8.dp)
+        if (description != null) PickerDescription(description)
         if (inheritLabel != null) {
             GroupedRow(
                 title = inheritLabel,
                 position = Position.Alone,
-                checked = inherits,
+                selected = inherits,
+                trailing = if (inherits) {
+                    { SelectedCheck() }
+                } else {
+                    null
+                },
                 onClick = {
                     onSelect(null)
                     onDismiss()
@@ -359,22 +415,39 @@ fun DurationPicker(
             Spacer(Modifier.height(24.dp))
         }
         presets.forEachIndexed { index, minute ->
+            val isSelected = minute == selected
             GroupedRow(
                 title = label(minute),
                 position = positionOf(index, rowCount),
-                checked = minute == selected,
+                selected = isSelected,
+                trailing = if (isSelected) {
+                    { SelectedCheck() }
+                } else {
+                    null
+                },
                 onClick = {
                     onSelect(minute)
                     onDismiss()
                 },
             )
         }
-        CustomExpandRow(
+        // The Custom row connects downward into the editor card when expanded, so
+        // the two read as one grouped container (the shared custom-expand pattern).
+        GroupedRow(
             title = custom?.let { label(it) } ?: stringResource(R.string.event_edit_reminder_custom),
-            position = positionOf(presets.size, rowCount),
-            expanded = customExpanded,
-            onExpandedChange = { customExpanded = it },
-            checked = custom != null,
+            position = if (customExpanded) Position.Top else positionOf(presets.size, rowCount),
+            selected = custom != null,
+            trailing = if (custom != null) {
+                { SelectedCheck() }
+            } else {
+                null
+            },
+            onClick = { customExpanded = !customExpanded },
+        )
+        AnimatedVisibility(
+            visible = customExpanded,
+            enter = expandEnter(),
+            exit = collapseExit(),
         ) {
             CustomDurationEditor(
                 amountText = amountText,

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

@@ -10,8 +10,6 @@ import androidx.compose.ui.text.font.FontStyle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.SimpleRecurrence
 import de.jeanlucmakiola.calendula.domain.occurrencesSpanYears
-import de.jeanlucmakiola.calendula.domain.rruleParts
-import de.jeanlucmakiola.calendula.domain.ics.parseBasicDate
 import de.jeanlucmakiola.calendula.domain.upcomingOccurrences
 import de.jeanlucmakiola.floret.locale.localizedDateFormatter
 import kotlinx.datetime.toJavaLocalDate
@@ -34,7 +32,10 @@ import java.util.Locale
  */
 @Composable
 fun recurrenceText(rrule: String, locale: Locale): AnnotatedString {
-    val parts = rruleParts(rrule).mapNotNull { part -> part.key?.let { it to part.value } }.toMap()
+    val parts = rrule.removePrefix("RRULE:").split(';').mapNotNull { token ->
+        val eq = token.indexOf('=')
+        if (eq <= 0) null else token.substring(0, eq).uppercase() to token.substring(eq + 1)
+    }.toMap()
 
     val freq = parts["FREQ"]?.uppercase()
     val interval = parts["INTERVAL"]?.toIntOrNull() ?: 1
@@ -170,5 +171,12 @@ internal fun untilLocalDate(raw: String, zone: ZoneId = ZoneId.systemDefault()):
             .atOffset(ZoneOffset.UTC)
             .atZoneSameInstant(zone)
             .toLocalDate()
-    }.getOrNull() ?: parseBasicDate(value.takeWhile { it.isDigit() })?.toJavaLocalDate()
+    }.recoverCatching {
+        val digits = value.takeWhile { it.isDigit() }
+        LocalDate.of(
+            digits.substring(0, 4).toInt(),
+            digits.substring(4, 6).toInt(),
+            digits.substring(6, 8).toInt(),
+        )
+    }.getOrNull()
 }

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

@@ -1,22 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-
-/**
- * [live], or after it goes null the last value it had, so an overlay keeps
- * drawing what it showed through its slide-out instead of flashing empty. Never
- * a placeholder: until [live] is first set this is null, so a destination never
- * loads a bogus key on its first frame. Not saved — after a recreation the
- * saveable [live] is the value again.
- */
-@Composable
-fun <T : Any> rememberHeld(live: T?): T? {
-    val held = remember { HeldValue<T>() }
-    if (live != null) held.value = live
-    return live ?: held.value
-}
-
-private class HeldValue<T : Any> {
-    var value: T? = null
-}

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

@@ -6,7 +6,7 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.time.ZoneSource
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.calendar.NoSuchEventException
-import de.jeanlucmakiola.calendula.domain.canSaveAsOccurrence
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventFormProblem
@@ -23,21 +23,22 @@ import de.jeanlucmakiola.calendula.domain.resolvedZone
 import de.jeanlucmakiola.calendula.domain.shiftedByDays
 import de.jeanlucmakiola.calendula.domain.shiftedTo
 import de.jeanlucmakiola.calendula.domain.toEditForm
-import de.jeanlucmakiola.floret.android.stateWhileSubscribed
-import de.jeanlucmakiola.floret.di.IoDispatcher
 import kotlinx.coroutines.CoroutineDispatcher
 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.flowOn
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.atStartOfDayIn
 import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
 import kotlin.coroutines.cancellation.CancellationException
 import kotlin.time.Instant
@@ -80,12 +81,7 @@ data class MoveRequest(
  * re-derive (`BYDAY=MO,WE`, `2TH`, …), or the shift wouldn't carry the anchor
  * across the same midnights the occurrence crossed.
  */
-data class MoveScopePrompt(
-    val occurrenceOnly: Boolean,
-    val resize: Boolean = false,
-    /** A cancelled series, whose occurrences can't move on their own (#388). */
-    val seriesOnly: Boolean = false,
-)
+data class MoveScopePrompt(val occurrenceOnly: Boolean, val resize: Boolean = false)
 
 /** The inverse of a completed move, for the undo action. */
 data class MoveUndo(
@@ -193,8 +189,9 @@ class RescheduleViewModel @Inject constructor(
         .map { calendars -> calendars.filter { it.allowsEventMove }.map { it.id }.toSet() }
         .catch { emit(emptySet<Long>()) }
         .flowOn(io)
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = emptySet(),
         )
 
@@ -233,21 +230,15 @@ class RescheduleViewModel @Inject constructor(
                 busy = false
                 return@launch
             }
-            val seriesOnly = !prepared.original.canSaveAsOccurrence()
             if (!prepared.isRecurring) {
                 write(prepared, RecurringWriteScope.AllEvents)
                 busy = false
-            } else if (seriesOnly && !prepared.canRealign) {
-                // Neither the occurrence nor the series can take this move.
-                _abandoned.value += 1
-                busy = false
             } else {
                 // Still busy: the scope dialog is now the thing in flight.
                 pending = prepared
                 _scopePrompt.value = MoveScopePrompt(
                     occurrenceOnly = !prepared.canRealign,
                     resize = request.target is MoveTarget.Span,
-                    seriesOnly = seriesOnly,
                 )
             }
         }
@@ -259,7 +250,6 @@ class RescheduleViewModel @Inject constructor(
         val prepared = pending ?: return
         // Guard against the dialog ever offering a scope the rule can't carry.
         if (!prepared.canRealign && scope != RecurringWriteScope.ThisEvent) return
-        if (scope == RecurringWriteScope.ThisEvent && !prepared.original.canSaveAsOccurrence()) return
         pending = null
         _scopePrompt.value = null
         viewModelScope.launch {

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

@@ -11,8 +11,6 @@ import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextOverflow
@@ -32,13 +30,10 @@ import kotlin.time.toJavaInstant
 @Composable
 fun SelectionTopBar(selection: EventSelection) {
     val event = selection.event
-    // Follows a move or resize, so the times stay readable under the finger.
-    val preview by remember(selection) { derivedStateOf { selection.preview() } }
-    val shown = preview ?: event
     val use24Hour = LocalUse24HourFormat.current
     val locale = currentLocale()
-    val whenText = remember(shown.start, shown.end, use24Hour, locale) {
-        formatSelectionWhen(shown, use24Hour, locale)
+    val whenText = remember(event.start, event.end, use24Hour, locale) {
+        formatSelectionWhen(event, use24Hour, locale)
     }
     TopAppBar(
         navigationIcon = {

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

@@ -9,7 +9,6 @@ import kotlin.time.Instant
 import kotlin.time.toJavaInstant
 import java.time.format.DateTimeFormatter
 import java.util.Locale
-import kotlinx.datetime.toLocalDateTime
 
 /**
  * The resolved clock convention for the whole UI: `true` = 24-hour ("14:00"),
@@ -38,12 +37,6 @@ fun formatTimeOfDay(hour: Int, minute: Int, is24Hour: Boolean, locale: Locale):
     LocalTime.of(hour.coerceIn(0, 23), minute.coerceIn(0, 59))
         .format(timeOfDayFormatter(is24Hour, locale))
 
-/** [instant]'s wall-clock time in [zone], as [formatTimeOfDay] renders it. */
-fun formatTimeOfDay(instant: Instant, zone: TimeZone, is24Hour: Boolean, locale: Locale): String {
-    val time = instant.toLocalDateTime(zone).time
-    return formatTimeOfDay(time.hour, time.minute, is24Hour, locale)
-}
-
 /**
  * Format minutes-from-midnight (0..1440) as a time label. The end-of-day value
  * 1440 renders as "24:00" in 24h (its established reading) and as midnight

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

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.ui.common
 
+import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
@@ -38,10 +39,11 @@ import de.jeanlucmakiola.calendula.domain.timeZoneOptionOf
 import de.jeanlucmakiola.calendula.domain.timeZoneOptions
 import de.jeanlucmakiola.calendula.domain.zoneDescriptor
 import de.jeanlucmakiola.floret.components.FullScreenPicker
+import de.jeanlucmakiola.floret.components.GroupedListInset
 import de.jeanlucmakiola.floret.components.GroupedRow
-import de.jeanlucmakiola.floret.components.GroupedSectionHeader
 import de.jeanlucmakiola.floret.components.InlineTextField
 import de.jeanlucmakiola.floret.components.Position
+import de.jeanlucmakiola.floret.components.SelectedCheck
 import de.jeanlucmakiola.floret.components.positionOf
 import de.jeanlucmakiola.floret.locale.currentLocale
 import kotlinx.coroutines.Dispatchers
@@ -101,10 +103,9 @@ fun TimeZonePickerDialog(
         onDismiss = onDismiss,
         scrollable = false,
     ) {
-        PickerSearchField(
+        SearchField(
             query = query,
             onQueryChange = { query = it },
-            placeholder = stringResource(R.string.event_edit_timezone_search),
             modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
         )
         LazyColumn(contentPadding = PaddingValues(top = 8.dp, bottom = 24.dp)) {
@@ -117,14 +118,19 @@ fun TimeZonePickerDialog(
                         title = stringResource(R.string.event_edit_timezone_device),
                         summary = deviceSummary,
                         position = Position.Alone,
-                        checked = selected == null,
+                        selected = selected == null,
                         leading = { Icon(Icons.Default.Public, contentDescription = null) },
+                        trailing = if (selected == null) {
+                            { SelectedCheck() }
+                        } else {
+                            null
+                        },
                         onClick = { choose(null) },
                     )
                 }
                 if (recentZones.isNotEmpty()) {
                     item(key = "recent_header") {
-                        GroupedSectionHeader(stringResource(R.string.event_edit_timezone_recent))
+                        SectionHeader(stringResource(R.string.event_edit_timezone_recent))
                     }
                     itemsIndexed(
                         items = recentZones,
@@ -139,7 +145,7 @@ fun TimeZonePickerDialog(
                     }
                 }
                 item(key = "all_header") {
-                    GroupedSectionHeader(stringResource(R.string.event_edit_timezone_all))
+                    SectionHeader(stringResource(R.string.event_edit_timezone_all))
                 }
             }
 
@@ -182,10 +188,9 @@ fun TimeZonePickerDialog(
  * which has a top bar to put it in) because the picker's bar is the title.
  */
 @Composable
-internal fun PickerSearchField(
+private fun SearchField(
     query: String,
     onQueryChange: (String) -> Unit,
-    placeholder: String,
     modifier: Modifier = Modifier,
 ) {
     val keyboard = LocalSoftwareKeyboardController.current
@@ -208,7 +213,7 @@ internal fun PickerSearchField(
             InlineTextField(
                 value = query,
                 onValueChange = onQueryChange,
-                placeholder = placeholder,
+                placeholder = stringResource(R.string.event_edit_timezone_search),
                 capitalization = KeyboardCapitalization.None,
                 imeAction = ImeAction.Search,
                 onImeAction = { keyboard?.hide() },
@@ -229,6 +234,23 @@ internal fun PickerSearchField(
     }
 }
 
+/** A small primary-coloured group label, matching the settings screens. */
+@Composable
+private fun SectionHeader(text: String) {
+    Text(
+        text = text,
+        style = MaterialTheme.typography.labelLarge,
+        color = MaterialTheme.colorScheme.primary,
+        modifier = Modifier.padding(
+            start = GroupedListInset,
+            end = GroupedListInset,
+            top = 16.dp,
+            bottom = 4.dp,
+        ),
+    )
+}
+
+
 @Composable
 private fun ZoneRow(
     zone: TimeZoneOption,
@@ -240,7 +262,12 @@ private fun ZoneRow(
         title = zone.label,
         summary = zoneDescriptor(zone),
         position = position,
-        checked = selected,
+        selected = selected,
+        trailing = if (selected) {
+            { SelectedCheck() }
+        } else {
+            null
+        },
         onClick = onClick,
     )
 }

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

@@ -5,6 +5,7 @@ import androidx.compose.animation.core.Animatable
 import androidx.compose.animation.core.tween
 import androidx.compose.foundation.ScrollState
 import androidx.compose.foundation.MutatePriority
+import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
@@ -18,10 +19,8 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.Stable
-import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateListOf
-import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
@@ -390,20 +389,17 @@ internal fun resizedSpan(
         }
         if (wrongWay) return startMin to endMin
     }
-    val snapped = snapToSlot(edgeMin)
+    val snapped = (edgeMin / DRAG_SNAP_MINUTES).roundToInt() * DRAG_SNAP_MINUTES
     return when (edge) {
         ResizeEdge.Top -> minOf(snapped, endMin - DRAG_SNAP_MINUTES) to endMin
         ResizeEdge.Bottom -> startMin to maxOf(snapped, startMin + DRAG_SNAP_MINUTES)
     }
 }
 
-/** [minutes] rounded to the nearest [DRAG_SNAP_MINUTES] slot. */
-internal fun snapToSlot(minutes: Float): Int = (minutes / DRAG_SNAP_MINUTES).roundToInt() * DRAG_SNAP_MINUTES
-
 /** [minutes] snapped, kept at [held] until three quarters of a step away. */
 internal fun stickySnap(minutes: Float, held: Int?): Int {
     if (held != null && kotlin.math.abs(minutes - held) < DRAG_SNAP_MINUTES * 0.75f) return held
-    return snapToSlot(minutes)
+    return (minutes / DRAG_SNAP_MINUTES).roundToInt() * DRAG_SNAP_MINUTES
 }
 
 /** How far past its column's side the finger has to go before a resize changes day. */
@@ -471,10 +467,6 @@ class TimelineDragController {
     var settling: TimelineDrag? by mutableStateOf(null)
         private set
 
-    /** How many real drops this controller has handed back. */
-    var drops by mutableIntStateOf(0)
-        private set
-
     /**
      * Which block is lifted, and whether anything is. Separate snapshot state
      * from [drag], which changes every frame, so blocks that only need "am I the
@@ -626,8 +618,25 @@ class TimelineDragController {
      */
     private var originSlot: Triple<LocalDate, Int, Int>? = null
 
-    /** The resize in progress, or null for a plain drag (#141). */
-    private var resize: ResizeSession? = null
+    /** The edge a resize is dragging, or null for a plain drag (#141). */
+    private var resizeEdge: ResizeEdge? = null
+
+    /** The day the resized event starts on; its edges are minutes from that midnight. */
+    private var resizeDay: LocalDate? = null
+    private var resizeStartMin = 0
+    private var resizeEndMin = 0
+
+    /** How far the finger sits past the edge it grabbed, so the edge doesn't jump to it. */
+    private var resizeGrabMin = 0f
+
+    /** The column the resized edge is in, held until the finger is well into another. */
+    private var resizeColumn: Int? = null
+
+    /** The slot the resized edge sits on, held against a finger trembling between two. */
+    private var resizeSlot: Int? = null
+
+    /** The day, counted from the event's start day, the finger is resizing in. */
+    private var resizeEdgeDay = 0
 
     fun begin(
         block: TimedBlock,
@@ -674,7 +683,10 @@ class TimelineDragController {
     }
 
     fun cancel() {
-        resize = null
+        resizeEdge = null
+        resizeDay = null
+        resizeColumn = null
+        resizeSlot = null
         source = null
         clipOffsetMin = 0
         dragZone = null
@@ -749,12 +761,6 @@ class TimelineDragController {
         if (landed == null || landed.slot == origin) return null
         // A draft dropped on a day off screen would vanish, so it stays where it was (#153).
         if (landed.edgeOnly && landed.event.isDraft) return null
-        settle(landed)
-        return TimelineDrop(landed.event, landed.date, landed.startMin, clipOffset)
-    }
-
-    /** Keep [landed]'s copy on the target as [settling] until [release]; [end] is a resize's. */
-    private fun settle(landed: TimelineDrag, end: Instant? = null) {
         settlingSelected = selection?.event?.instanceId == landed.event.instanceId
         // An edge piece is a hint for the finger, not a preview of the landing
         // slot: the event belongs to a day this timeline has no column for, so
@@ -764,8 +770,7 @@ class TimelineDragController {
         liftedInstanceId = landed.event.instanceId
         settledOrigin = landed.event.eventId to landed.event.start
         settledAbandonedMark = abandonedTicks?.value ?: 0
-        settledEnd = end
-        drops++
+        return TimelineDrop(landed.event, landed.date, landed.startMin, clipOffset)
     }
 
     /**
@@ -780,9 +785,11 @@ class TimelineDragController {
         pointerInRoot: Offset,
     ) {
         val span = wallClockSpan(block.event, zone)
-        val session = ResizeSession(edge, span.day, span.startMin, span.endMin)
         source = block
-        resize = session
+        resizeEdge = edge
+        resizeDay = span.day
+        resizeStartMin = span.startMin
+        resizeEndMin = span.endMin
         clipOffsetMin = 0
         this.titleLines = titleLines
         settling = null
@@ -791,36 +798,17 @@ class TimelineDragController {
         liftedInstanceId = block.event.instanceId
         pointer = pointerInRoot
         // Measured from the edge's own column: the handle overhangs into the next.
-        val edgeDay = if (edge == ResizeEdge.Top) 0 else (session.endMin - 1).floorDiv(MINUTES_PER_DAY).coerceAtLeast(0)
+        val edgeDay = if (edge == ResizeEdge.Top) 0 else (resizeEndMin - 1).floorDiv(MINUTES_PER_DAY).coerceAtLeast(0)
         val edgeIndex = geometry.days.indexOf(span.day.plus(edgeDay, DateTimeUnit.DAY))
-        session.column = edgeIndex.takeIf { it >= 0 }
-            ?.let { column(it) }
-        session.grabMin = (pointerResizeMinutes(session) ?: 0f) -
-            if (edge == ResizeEdge.Top) session.startMin else session.endMin
+        resizeColumn = edgeIndex.takeIf { it >= 0 }
+            ?.let { if (geometry.isRtl) geometry.days.lastIndex - it else it }
+        resizeGrabMin = (pointerResizeMinutes() ?: 0f) -
+            if (edge == ResizeEdge.Top) resizeStartMin else resizeEndMin
         originSlot = null
         recompute()
         originSlot = drag?.slot
     }
 
-    /** The slot the gesture would land on, changing once per snap rather than per frame. */
-    private val landingSlot by derivedStateOf { drag?.slot }
-
-    /**
-     * The dragged event at the times letting go now would give it, worked out as
-     * [finish] and [finishResize] do. Null while it is still on its own slot (#141).
-     */
-    fun preview(zone: TimeZone): EventInstance? {
-        val (date, startMin, spanMin) = landingSlot?.takeIf { it != originSlot } ?: return null
-        val event = source?.event ?: return null
-        val edge = resize?.edge
-        if (edge != null) {
-            val drop = resizedDrop(event, edge, date, startMin, spanMin, zone)
-            return event.copy(start = drop.start, end = drop.end)
-        }
-        val start = TimelineDrop(event, date, startMin, clipOffsetMin).startInstant(zone)
-        return event.copy(start = start, end = start + dragDuration)
-    }
-
     /**
      * End a resize, handing back the event's new span — null when it never
      * resolved or came back to the length it started at. Settles as [finish] does.
@@ -828,11 +816,16 @@ class TimelineDragController {
     fun finishResize(zone: TimeZone): TimelineResizeDrop? {
         val landed = drag
         val origin = originSlot
-        val edge = resize?.edge
+        val edge = resizeEdge
         cancel()
         if (landed == null || landed.slot == origin) return null
         val drop = resizedDrop(landed.event, edge, landed.date, landed.eventStartMin, landed.eventSpanMin, zone)
-        settle(landed, end = drop.end)
+        settlingSelected = selection?.event?.instanceId == landed.event.instanceId
+        settling = if (landed.edgeOnly) landed.copy(pieces = emptyList()) else landed
+        liftedInstanceId = landed.event.instanceId
+        settledOrigin = landed.event.eventId to landed.event.start
+        settledAbandonedMark = abandonedTicks?.value ?: 0
+        settledEnd = drop.end
         return drop
     }
 
@@ -840,33 +833,36 @@ class TimelineDragController {
      * Where the finger is, in minutes from the resized event's start day —
      * past 1440 in a later column, negative in an earlier one.
      */
-    private fun pointerResizeMinutes(session: ResizeSession): Float? {
+    private fun pointerResizeMinutes(): Float? {
         val grid = geometry.grid?.takeIf { it.isAttached } ?: return null
+        val day = resizeDay ?: return null
         val hourPx = geometry.hourPx
         val columnPx = geometry.columnWidthPx
         val days = geometry.days
         if (hourPx <= 0f || columnPx <= 0f || days.isEmpty()) return null
         val origin = grid.positionInRoot()
-        val held = stickyColumn(
+        val column = stickyColumn(
             position = (pointer.x - origin.x) / columnPx,
-            held = session.column,
+            held = resizeColumn,
             lastIndex = days.lastIndex,
         )
-        session.column = held
-        val dayOffset = (days[column(held)].toEpochDays() - session.day.toEpochDays()).toInt()
-        session.edgeDay = dayOffset
+        resizeColumn = column
+        val dayIndex = if (geometry.isRtl) days.lastIndex - column else column
+        val dayOffset = (days[dayIndex].toEpochDays() - day.toEpochDays()).toInt()
+        resizeEdgeDay = dayOffset
         return dayOffset * MINUTES_PER_DAY + (pointer.y - origin.y) / hourPx * 60f
     }
 
-    private fun recomputeResize(session: ResizeSession) {
+    private fun recomputeResize(edge: ResizeEdge) {
         val block = source ?: return
-        val edge = session.edge
-        val day = session.day
-        val raw = pointerResizeMinutes(session) ?: return
-        val slot = stickySnap(raw - session.grabMin, session.slot)
-        session.slot = slot
-        val (start, end) = resizedSpan(edge, session.startMin, session.endMin, slot.toFloat(), session.edgeDay)
+        val day = resizeDay ?: return
+        val raw = pointerResizeMinutes() ?: return
+        val slot = stickySnap(raw - resizeGrabMin, resizeSlot)
+        resizeSlot = slot
+        val (start, end) = resizedSpan(edge, resizeStartMin, resizeEndMin, slot.toFloat(), resizeEdgeDay)
         val days = geometry.days
+        val hourPx = geometry.hourPx
+        val columnPx = geometry.columnWidthPx
         val origin = geometry.grid?.takeIf { it.isAttached }?.positionInRoot() ?: return
         // Which column the start day sits in, possibly off either end of the view.
         val startIndex = (day.toEpochDays() - days.first().toEpochDays()).toInt()
@@ -879,7 +875,20 @@ class TimelineDragController {
             eventStartMin = start,
             eventSpanMin = end - start,
             titleLines = titleLines,
-            pieces = pieces(slices, startIndex, origin),
+            pieces = slices.map { slice ->
+                val dayIndex = startIndex + slice.dayOffset
+                val col = if (geometry.isRtl) days.lastIndex - dayIndex else dayIndex
+                val bounds = dragPieceBounds(slice, hourPx, geometry.blockInsetPx)
+                TimelineDragPiece(
+                    topLeftInRoot = Offset(x = origin.x + col * columnPx, y = origin.y + bounds.top),
+                    sizePx = IntSize(
+                        (columnPx - geometry.columnGapPx).roundToInt(),
+                        bounds.height.roundToInt(),
+                    ),
+                    continuesBefore = slice.continuesBefore,
+                    continuesAfter = slice.continuesAfter,
+                )
+            },
             edgeOnly = slices.isEmpty(),
             markerMin = if (edge == ResizeEdge.Top) {
                 start.mod(MINUTES_PER_DAY)
@@ -924,7 +933,7 @@ class TimelineDragController {
      * no move events while auto-scroll walks the content underneath it.
      */
     fun recompute() {
-        resize?.let {
+        resizeEdge?.let {
             recomputeResize(it)
             return
         }
@@ -937,9 +946,10 @@ class TimelineDragController {
 
         val origin = grid.positionInRoot()
         val rawMinutes = (pointer.y - grab.y - origin.y) / hourPx * 60f
-        val snapped = snapToSlot(rawMinutes)
+        val snapped = (rawMinutes / DRAG_SNAP_MINUTES).roundToInt() * DRAG_SNAP_MINUTES
         val zone = dragZone ?: return
-        val dayIndex = column(((pointer.x - origin.x) / columnPx).toInt().coerceIn(0, days.lastIndex))
+        val column = ((pointer.x - origin.x) / columnPx).toInt().coerceIn(0, days.lastIndex)
+        val dayIndex = if (geometry.isRtl) days.lastIndex - column else column
         val target = days[dayIndex]
         val keep = dragKept
         // Measured where it would land: the drop keeps the real duration, which in
@@ -967,34 +977,28 @@ class TimelineDragController {
             titleLines = titleLines,
             // Bounded to the columns this timeline actually shows: a day it
             // doesn't has no piece to draw. The write is unaffected.
-            pieces = pieces(slices, dayIndex, origin),
+            pieces = slices
+                .map { slice ->
+                    val day = dayIndex + slice.dayOffset
+                    val col = if (geometry.isRtl) days.lastIndex - day else day
+                    val bounds = dragPieceBounds(slice, hourPx, geometry.blockInsetPx)
+                    TimelineDragPiece(
+                        topLeftInRoot = Offset(
+                            x = origin.x + col * columnPx,
+                            y = origin.y + bounds.top,
+                        ),
+                        sizePx = IntSize(
+                            (columnPx - geometry.columnGapPx).roundToInt(),
+                            bounds.height.roundToInt(),
+                        ),
+                        continuesBefore = slice.continuesBefore,
+                        continuesAfter = slice.continuesAfter,
+                    )
+                },
             edgeOnly = onGrid.isEmpty(),
         )
     }
 
-    /** [slices] as floating pieces, the first slice's day being [dayIndex] in the shown days. */
-    private fun pieces(slices: List<DragSlice>, dayIndex: Int, origin: Offset): List<TimelineDragPiece> {
-        val columnPx = geometry.columnWidthPx
-        return slices.map { slice ->
-            val bounds = dragPieceBounds(slice, geometry.hourPx, geometry.blockInsetPx)
-            TimelineDragPiece(
-                topLeftInRoot = Offset(
-                    x = origin.x + column(dayIndex + slice.dayOffset) * columnPx,
-                    y = origin.y + bounds.top,
-                ),
-                sizePx = IntSize(
-                    (columnPx - geometry.columnGapPx).roundToInt(),
-                    bounds.height.roundToInt(),
-                ),
-                continuesBefore = slice.continuesBefore,
-                continuesAfter = slice.continuesAfter,
-            )
-        }
-    }
-
-    /** The on-screen column of a day index, and back: right-to-left lays the days out mirrored. */
-    private fun column(index: Int): Int = if (geometry.isRtl) geometry.days.lastIndex - index else index
-
     /**
      * Hold the scroll for the whole drag and nudge it once per frame while the
      * finger sits near an edge. One `scroll` call, since a loop of
@@ -1027,27 +1031,6 @@ class TimelineDragController {
     }
 }
 
-/** One resize gesture (#141): the edge it drags, and the edges as minutes from [day]'s midnight. */
-private class ResizeSession(
-    val edge: ResizeEdge,
-    /** The day the resized event starts on. */
-    val day: LocalDate,
-    val startMin: Int,
-    val endMin: Int,
-) {
-    /** How far the finger sits past the edge it grabbed, so the edge doesn't jump to it. */
-    var grabMin = 0f
-
-    /** The column the resized edge is in, held until the finger is well into another. */
-    var column: Int? = null
-
-    /** The slot the resized edge sits on, held against a finger trembling between two. */
-    var slot: Int? = null
-
-    /** The day, counted from the event's start day, the finger is resizing in. */
-    var edgeDay = 0
-}
-
 @Composable
 fun rememberTimelineDragController(): TimelineDragController {
     val controller = remember { TimelineDragController() }
@@ -1177,7 +1160,7 @@ fun TimelineDragOverlay(controller: TimelineDragController, modifier: Modifier =
 
     // Both live here rather than beside the controller: they read [drag], which
     // changes every frame, and this composable is the one that is meant to.
-    DragSnapHaptics(controller.drag?.slot, controller.drops)
+    DragSnapHaptics(controller.drag?.slot)
     // Only once the finger has moved: a long press held near an edge must not
     // scroll the drop target out from under a finger that only means to select.
     LaunchedEffect(controller.isDragging && controller.pointerMoved) {

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

@@ -16,6 +16,8 @@ data class TimelineHours(
     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

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

@@ -0,0 +1,145 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.animation.Crossfade
+import androidx.compose.animation.core.snap
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.clipToBounds
+import androidx.compose.ui.graphics.TransformOrigin
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.layout
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.unit.Constraints
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.floret.components.GroupedListInset
+import de.jeanlucmakiola.floret.identity.rememberReduceMotion
+import kotlin.math.roundToInt
+
+/**
+ * The viewport a view preview pretends to be: a phone's width by the height a
+ * calendar view gets under the top bar. Scaling every preview from one fixed
+ * height keeps them comparable — each shows the same slice of screen.
+ */
+internal val PREVIEW_VIEWPORT_HEIGHT = 440.dp
+
+/**
+ * Renders [content] at a full phone viewport and shrinks the finished layout
+ * into a box [height] tall, for the settings and onboarding choosers. Callers
+ * pass the *real* view composables, so a preview cannot drift from what it
+ * depicts.
+ *
+ * The [layout] below ignores the incoming constraints so the view measures at a
+ * phone viewport, and a [graphicsLayer] scale shrinks the result.
+ * `Modifier.requiredSize` is the obvious alternative but *centres* content that
+ * overflows its constraints, leaving only the bottom-right corner in the clip.
+ */
+@Composable
+internal fun ScaledViewPreview(
+    height: Dp,
+    modifier: Modifier = Modifier,
+    content: @Composable () -> Unit,
+) {
+    val screenWidth = LocalConfiguration.current.screenWidthDp.dp
+    val scale = height.value / PREVIEW_VIEWPORT_HEIGHT.value
+
+    Box(
+        modifier = modifier
+            .clipToBounds()
+            .background(MaterialTheme.colorScheme.surface)
+            // A preview is a picture, not a control: swallow touches before the
+            // view's own clickables see them, and give screen readers one label
+            // instead of six weeks of day cells.
+            .pointerInput(Unit) {
+                awaitPointerEventScope {
+                    while (true) {
+                        awaitPointerEvent(PointerEventPass.Initial).changes
+                            .forEach { it.consume() }
+                    }
+                }
+            }
+            .clearAndSetSemantics { }
+            // Measure at a full phone viewport but report the scaled size, so the
+            // node occupies exactly what it draws.
+            .layout { measurable, _ ->
+                val fullWidth = screenWidth.roundToPx()
+                val fullHeight = PREVIEW_VIEWPORT_HEIGHT.roundToPx()
+                val placeable = measurable.measure(Constraints.fixed(fullWidth, fullHeight))
+                layout((fullWidth * scale).roundToInt(), (fullHeight * scale).roundToInt()) {
+                    placeable.place(0, 0)
+                }
+            }
+            .graphicsLayer {
+                scaleX = scale
+                scaleY = scale
+                transformOrigin = TransformOrigin(0f, 0f)
+            },
+    ) {
+        Column(Modifier.fillMaxSize()) { content() }
+    }
+}
+
+/**
+ * The stage every preview picker sets its preview on, cross-fading as [selected]
+ * changes. A preview draws the app's own surface, so a tonal plate gives it the
+ * edge it would otherwise lack on a chooser screen; the plate takes the width
+ * and outer radius of the grouped rows underneath so the two read as one stack.
+ *
+ * Only vertical spacing is the caller's to pass — the horizontal inset is the
+ * rows' own, and the alignment is the point.
+ */
+@Composable
+internal fun <T> ViewPreviewFrame(
+    selected: T,
+    label: String,
+    modifier: Modifier = Modifier,
+    content: @Composable (T) -> Unit,
+) {
+    val reduceMotion = rememberReduceMotion()
+    Box(
+        modifier = modifier
+            .fillMaxWidth()
+            .padding(horizontal = GroupedListInset)
+            .clip(FRAME_SHAPE)
+            .background(MaterialTheme.colorScheme.surfaceContainerHigh)
+            .padding(FRAME_INSET),
+        contentAlignment = Alignment.Center,
+    ) {
+        Crossfade(
+            targetState = selected,
+            animationSpec = if (reduceMotion) snap() else tween(durationMillis = 250),
+            label = label,
+        ) { shown ->
+            // Each preview renders the real view at phone size and scales it
+            // down, so its own corners are square — the plate rounds them.
+            Box(
+                modifier = Modifier
+                    .clip(PREVIEW_SHAPE)
+                    .background(MaterialTheme.colorScheme.surface)
+                    .clipToBounds(),
+            ) {
+                content(shown)
+            }
+        }
+    }
+}
+
+private val FRAME_INSET = 8.dp
+
+/** The grouped rows' own outer radius, so the stack shares one silhouette. */
+private val FRAME_SHAPE = RoundedCornerShape(22.dp)
+private val PREVIEW_SHAPE = RoundedCornerShape(12.dp)

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

@@ -0,0 +1,22 @@
+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/detail/EventDetailScreen.kt

@@ -8,6 +8,7 @@ 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.ColumnScope
 import androidx.compose.foundation.layout.ExperimentalLayoutApi
 import androidx.compose.foundation.layout.FlowRow
 import androidx.compose.foundation.layout.Row
@@ -16,6 +17,7 @@ import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.RoundedCornerShape
@@ -56,6 +58,7 @@ import androidx.compose.runtime.setValue
 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.AnnotatedString
@@ -84,18 +87,16 @@ import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.InlineStyle
+import de.jeanlucmakiola.calendula.domain.Reminder
 import de.jeanlucmakiola.calendula.domain.RichText
 import de.jeanlucmakiola.calendula.domain.TimeZoneOption
 import de.jeanlucmakiola.calendula.domain.timeZoneOptionOf
 import de.jeanlucmakiola.calendula.domain.zoneDescriptor
-import de.jeanlucmakiola.calendula.domain.zoneOrNull
-import de.jeanlucmakiola.calendula.ui.common.orUnnamed
-import de.jeanlucmakiola.floret.components.IconInfoCard
 import de.jeanlucmakiola.floret.identity.LocalFloretDarkTheme
 import de.jeanlucmakiola.floret.identity.predictiveBack
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.DeleteEventDialog
-import de.jeanlucmakiola.calendula.ui.common.rememberWriteAction
+import de.jeanlucmakiola.calendula.ui.common.rememberWriteGate
 import de.jeanlucmakiola.calendula.ui.common.sendEventShare
 import de.jeanlucmakiola.calendula.ui.common.FieldCopier
 import de.jeanlucmakiola.calendula.ui.common.copyOnLongPress
@@ -103,6 +104,7 @@ import de.jeanlucmakiola.calendula.ui.common.rememberFieldCopier
 import de.jeanlucmakiola.calendula.ui.common.icuTimeZoneRegion
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.eventAccent
+import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
@@ -169,11 +171,14 @@ fun EventDetailScreen(
 
     // v1.0 installs only hold READ_CALENDAR; the first write asks for the
     // upgrade in place and continues straight into the tapped action.
-    val onDeleteClick = rememberWriteAction { showDeleteDialog = true }
-    val onEditClick = rememberWriteAction(action = onEdit)
+    val requireWrite = rememberWriteGate()
+    val onDeleteClick = { requireWrite { showDeleteDialog = true } }
+    val onEditClick = { requireWrite(onEdit) }
     // Duplicate reads the loaded detail into a create form and hands it up; the
     // create still needs WRITE_CALENDAR even when the source is read-only.
-    val onDuplicateClick = rememberWriteAction { viewModel.duplicateForm()?.let(onDuplicate) }
+    val onDuplicateClick = {
+        requireWrite { viewModel.duplicateForm()?.let(onDuplicate) }
+    }
 
     val deleteFailedMessage = stringResource(R.string.event_delete_failed)
     val writeDeniedMessage = stringResource(R.string.event_delete_write_denied)
@@ -299,7 +304,7 @@ private fun EventDetailContent(
     val detail = state.detail
     val instance = detail.instance
     val dark = LocalFloretDarkTheme.current
-    val locale = currentLocale()
+    val locale = currentDetailLocale()
     val accent = eventAccent(instance.color, dark, LocalSoftenColors.current)
 
     Column(
@@ -380,7 +385,7 @@ private fun EventDetailContent(
 
         // "When" — date/all-day plus the time range.
         val (whenPrimary, whenSecondary) = rememberWhen(instance, TimeZone.currentSystemDefault(), locale)
-        IconInfoCard(icon = Icons.Default.Schedule, iconContentDescription = null) {
+        DetailCard(icon = Icons.Default.Schedule, iconContentDescription = null) {
             Text(text = whenPrimary, style = MaterialTheme.typography.titleMedium)
             if (whenSecondary != null) {
                 Spacer(Modifier.height(2.dp))
@@ -405,7 +410,7 @@ private fun EventDetailContent(
         }
         foreignZone?.let { zoneOption ->
             Spacer(Modifier.height(gap))
-            IconInfoCard(
+            DetailCard(
                 icon = Icons.Default.Public,
                 iconContentDescription = stringResource(R.string.event_detail_timezone),
             ) {
@@ -418,7 +423,7 @@ private fun EventDetailContent(
                 // — which a cross-zone event easily does — carries the whole span
                 // in the primary instead, so fall back to it. If the zone can't be
                 // read back at all, drop to just the abbreviation + offset.
-                val originalTime = zoneOrNull(zoneOption.id)
+                val originalTime = runCatching { TimeZone.of(zoneOption.id) }.getOrNull()
                     ?.let { rememberWhen(instance, it, locale) }
                     ?.let { (primary, secondary) -> secondary ?: primary }
                 Spacer(Modifier.height(2.dp))
@@ -437,13 +442,13 @@ private fun EventDetailContent(
         // Calendar — icon tinted in the calendar colour conveys identity, so no
         // separate colour dot is needed.
         Spacer(Modifier.height(gap))
-        IconInfoCard(
+        DetailCard(
             icon = Icons.Default.CalendarMonth,
             iconTint = accent,
             iconContentDescription = stringResource(R.string.event_detail_calendar),
         ) {
             Text(
-                text = state.calendarName?.orUnnamed()
+                text = state.calendarName?.ifBlank { stringResource(R.string.calendar_unnamed) }
                     ?: stringResource(R.string.event_detail_calendar_unknown),
                 style = MaterialTheme.typography.titleMedium,
             )
@@ -455,7 +460,7 @@ private fun EventDetailContent(
             val context = LocalContext.current
             val locationLabel = stringResource(R.string.event_detail_location)
             Spacer(Modifier.height(gap))
-            IconInfoCard(
+            DetailCard(
                 icon = Icons.Default.Place,
                 iconContentDescription = locationLabel,
             ) {
@@ -482,7 +487,7 @@ private fun EventDetailContent(
         state.description?.let { description ->
             val descriptionLabel = stringResource(R.string.event_detail_description)
             Spacer(Modifier.height(gap))
-            IconInfoCard(
+            DetailCard(
                 icon = Icons.AutoMirrored.Filled.Notes,
                 iconContentDescription = descriptionLabel,
                 // The gesture sits on the card so the icon and padding answer
@@ -501,7 +506,7 @@ private fun EventDetailContent(
         // each attendee with their role and reply.
         detail.attendees.takeIf { it.isNotEmpty() }?.let { attendees ->
             Spacer(Modifier.height(gap))
-            IconInfoCard(
+            DetailCard(
                 icon = Icons.Default.People,
                 iconContentDescription = stringResource(R.string.event_detail_attendees),
             ) {
@@ -523,7 +528,7 @@ private fun EventDetailContent(
         // Reminders (conditional) — list each lead time before the event.
         detail.reminders.takeIf { it.isNotEmpty() }?.let { reminders ->
             Spacer(Modifier.height(gap))
-            IconInfoCard(
+            DetailCard(
                 icon = Icons.Default.Notifications,
                 iconContentDescription = stringResource(R.string.event_detail_reminders),
             ) {
@@ -532,7 +537,7 @@ private fun EventDetailContent(
                     .sortedBy { it.minutes }
                     .forEach { reminder ->
                         Text(
-                            text = reminderLeadTimeLabel(reminder.minutes),
+                            text = reminderLeadText(reminder),
                             style = MaterialTheme.typography.titleMedium,
                             modifier = Modifier.padding(vertical = 2.dp),
                         )
@@ -543,7 +548,7 @@ private fun EventDetailContent(
         // Recurrence (conditional) — humanised from the RRULE.
         detail.rrule?.takeIf { it.isNotBlank() }?.let { rrule ->
             Spacer(Modifier.height(gap))
-            IconInfoCard(
+            DetailCard(
                 icon = Icons.Default.Repeat,
                 iconContentDescription = stringResource(R.string.event_detail_recurrence),
             ) {
@@ -556,6 +561,36 @@ private fun EventDetailContent(
     }
 }
 
+/** One info card: tonal container, leading icon in the gutter, value to the right. */
+@Composable
+private fun DetailCard(
+    icon: ImageVector,
+    iconContentDescription: String?,
+    modifier: Modifier = Modifier,
+    iconTint: Color = MaterialTheme.colorScheme.onSurfaceVariant,
+    content: @Composable ColumnScope.() -> Unit,
+) {
+    Surface(
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
+        shape = RoundedCornerShape(16.dp),
+        modifier = modifier.fillMaxWidth(),
+    ) {
+        Row(
+            modifier = Modifier.padding(16.dp),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            Icon(
+                imageVector = icon,
+                contentDescription = iconContentDescription,
+                tint = iconTint,
+                modifier = Modifier.size(24.dp),
+            )
+            Spacer(Modifier.width(16.dp))
+            Column(modifier = Modifier.weight(1f), content = content)
+        }
+    }
+}
+
 @Composable
 private fun AttendeeRow(attendee: Attendee) {
     Row(
@@ -679,6 +714,11 @@ private fun SkeletonBar(widthFraction: Float, height: Dp) {
 
 // --- helpers -------------------------------------------------------------
 
+// Observable locale read (shared helper) — avoids NonObservableLocale /
+// LocalContextConfigurationRead lint by going through LocalConfiguration.
+@Composable
+private fun currentDetailLocale(): Locale = currentLocale()
+
 private fun attendeeStatusLabel(status: AttendeeStatus): Int = when (status) {
     AttendeeStatus.Accepted -> R.string.event_attendee_accepted
     AttendeeStatus.Declined -> R.string.event_attendee_declined
@@ -698,6 +738,10 @@ private fun attendeeRoleLabel(attendee: Attendee): Int? = when {
     else -> null
 }
 
+/** Humanise a reminder's lead time, e.g. "10 minutes before" / "At time of event". */
+@Composable
+private fun reminderLeadText(reminder: Reminder): String = reminderLeadTimeLabel(reminder.minutes)
+
 /**
  * [tz] resolved as a [TimeZoneOption], but only when the event is timed and
  * pinned to a zone different from the device's — the cases where showing it

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

@@ -6,8 +6,8 @@ import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.calendar.NoSuchEventException
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.ics.IcsExporter
-import de.jeanlucmakiola.calendula.data.time.ZoneSource
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
@@ -17,12 +17,11 @@ import de.jeanlucmakiola.calendula.domain.toDuplicateForm
 import de.jeanlucmakiola.calendula.ui.common.DeleteOutcome
 import de.jeanlucmakiola.calendula.ui.common.tryDeleteEvent
 import de.jeanlucmakiola.calendula.ui.common.stageEventShare
-import de.jeanlucmakiola.floret.android.stateWhileSubscribed
-import de.jeanlucmakiola.floret.di.IoDispatcher
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.combine
@@ -31,7 +30,9 @@ import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
+import kotlinx.datetime.TimeZone
 import kotlin.coroutines.cancellation.CancellationException
 import javax.inject.Inject
 
@@ -45,7 +46,6 @@ class EventDetailViewModel @Inject constructor(
     private val repository: CalendarRepository,
     private val icsExporter: IcsExporter,
     @IoDispatcher private val io: CoroutineDispatcher,
-    private val zoneSource: ZoneSource,
 ) : ViewModel() {
 
     private val _target = MutableStateFlow<Target?>(null)
@@ -76,8 +76,9 @@ class EventDetailViewModel @Inject constructor(
                 }
             }
             .flowOn(io)
-            .stateWhileSubscribed(
+            .stateIn(
                 scope = viewModelScope,
+                started = SharingStarted.WhileSubscribed(5_000L),
                 initialValue = EventDetailUiState.Loading,
             )
 
@@ -142,7 +143,7 @@ class EventDetailViewModel @Inject constructor(
      */
     fun duplicateForm(): EventForm? {
         val loaded = state.value as? EventDetailUiState.Success ?: return null
-        return loaded.detail.toDuplicateForm(loaded.canModify, zoneSource.current())
+        return loaded.detail.toDuplicateForm(loaded.canModify, TimeZone.currentSystemDefault())
     }
 
     private suspend fun loadDetail(target: Target): EventDetailUiState = try {

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

@@ -48,12 +48,6 @@ data class EventEditUiState(
      * then drops "only this event" (an exception row can't carry a rule).
      */
     val recurrenceChanged: Boolean = false,
-    /**
-     * Whether the Status field offers Cancelled: only for an event that already
-     * is. Google reads a cancelled event as deleted, so picking it is no safe
-     * way to strike an event through (#388).
-     */
-    val offerCancelled: Boolean = false,
     /**
      * The event-colour palette the resolved target calendar publishes; empty
      * when it exposes none. Non-empty → the colour picker offers these swatches

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

@@ -7,6 +7,7 @@ import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.calendar.NoSuchEventException
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.ics.IcsExporter
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
@@ -14,16 +15,15 @@ import de.jeanlucmakiola.calendula.data.time.ZoneSource
 import de.jeanlucmakiola.calendula.data.prefs.firstDayOfWeek
 import de.jeanlucmakiola.calendula.data.prefs.resolveDefaultEventDuration
 import de.jeanlucmakiola.calendula.data.prefs.resolveDefaultReminder
-import de.jeanlucmakiola.calendula.domain.canSaveAsOccurrence
 import de.jeanlucmakiola.calendula.domain.AccessLevel
 import de.jeanlucmakiola.calendula.domain.Availability
-import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EditSnapshot
 import de.jeanlucmakiola.calendula.domain.EventAttendee
 import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.endInstant
 import de.jeanlucmakiola.calendula.domain.nextFullHour
 import de.jeanlucmakiola.calendula.domain.toFormTime
 import de.jeanlucmakiola.calendula.domain.resolvedZone
@@ -43,8 +43,6 @@ import de.jeanlucmakiola.calendula.ui.detail.EventDetailViewModel.Companion.NO_O
 import de.jeanlucmakiola.calendula.ui.common.DeleteOutcome
 import de.jeanlucmakiola.calendula.ui.common.tryDeleteEvent
 import de.jeanlucmakiola.calendula.ui.common.stageEventShare
-import de.jeanlucmakiola.floret.android.stateWhileSubscribed
-import de.jeanlucmakiola.floret.di.IoDispatcher
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
@@ -337,13 +335,13 @@ class EventEditViewModel @Inject constructor(
             // the scope dialog drops "only this event" after a rule change.
             recurrenceChanged = local.editTarget != null &&
                 resolved.rrule != local.editTarget.original.rrule,
-            offerCancelled = local.editTarget?.original?.status == EventStatus.Cancelled,
             colorPalette = palette,
             allowColorOnUnsupportedCalendars = external.allowColorOnUnsupported,
         )
     }
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = null,
         )
 
@@ -593,9 +591,6 @@ class EventEditViewModel @Inject constructor(
         }
     }
 
-    /** The form as the user has it now, or null when none is open. */
-    fun currentForm(): EventForm? = _form.value
-
     /** Forget the open form; the next [openNew]/[openForEdit] starts clean. */
     fun reset() {
         session++
@@ -674,7 +669,6 @@ class EventEditViewModel @Inject constructor(
         applyDefaultDuration(id)
     }
     fun setAvailability(value: Availability) = edit { it.copy(availability = value) }
-    fun setStatus(value: EventStatus) = edit { it.copy(status = value) }
     fun setAccessLevel(value: AccessLevel) = edit { it.copy(accessLevel = value) }
 
     /** Pick a palette colour (round-trips via its key); [argb] is its swatch. */
@@ -781,7 +775,6 @@ class EventEditViewModel @Inject constructor(
     fun saveWithScope(scope: RecurringWriteScope) {
         val current = state.value ?: return
         if (current.saveState != SaveUiState.AwaitingScope) return
-        if (scope == RecurringWriteScope.ThisEvent && !current.form.canSaveAsOccurrence()) return
         performSave(current.form, scope)
     }
 

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

@@ -20,10 +20,8 @@ import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.FailureReason
-import de.jeanlucmakiola.calendula.ui.common.CalendarAccountGroup
 import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
-import de.jeanlucmakiola.calendula.ui.common.accountGroupTitle
-import de.jeanlucmakiola.calendula.ui.common.orUnnamed
+import de.jeanlucmakiola.calendula.ui.common.sourceAppName
 import de.jeanlucmakiola.floret.components.GroupedListInset
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.positionOf
@@ -45,7 +43,6 @@ fun CalendarFilterList(
         is FilterUiState.Failure -> FilterMessage(s.reason, modifier)
         is FilterUiState.Success -> FilterList(
             groups = s.groups,
-            hidden = s.hidden,
             onSetVisible = viewModel::setVisible,
             modifier = modifier,
         )
@@ -59,15 +56,23 @@ fun CalendarFilterList(
  */
 @Composable
 private fun FilterList(
-    groups: List<CalendarAccountGroup>,
-    hidden: Set<Long>,
+    groups: List<AccountGroup>,
     onSetVisible: (Long, Boolean) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     Column(modifier = modifier.fillMaxWidth()) {
         groups.forEach { group ->
+            val account = group.account.ifBlank { stringResource(R.string.calendar_unnamed) }
             Text(
-                text = accountGroupTitle(group),
+                text = if (group.ambiguous) {
+                    stringResource(
+                        R.string.calendars_account_from_source,
+                        account,
+                        sourceAppName(group.accountType),
+                    )
+                } else {
+                    account
+                },
                 style = MaterialTheme.typography.labelMedium,
                 color = MaterialTheme.colorScheme.onSurfaceVariant,
                 modifier = Modifier.padding(
@@ -78,19 +83,18 @@ private fun FilterList(
                 ),
             )
             group.calendars.forEachIndexed { index, cal ->
-                val visible = cal.id !in hidden
                 GroupedRow(
-                    title = cal.displayName.orUnnamed(),
+                    title = cal.displayName.ifBlank { stringResource(R.string.calendar_unnamed) },
                     position = positionOf(index, group.calendars.size),
                     minHeight = 56.dp,
                     leading = { CalendarColorChip(cal.color) },
                     trailing = {
                         Checkbox(
-                            checked = visible,
+                            checked = cal.visible,
                             onCheckedChange = { onSetVisible(cal.id, it) },
                         )
                     },
-                    onClick = { onSetVisible(cal.id, !visible) },
+                    onClick = { onSetVisible(cal.id, !cal.visible) },
                 )
             }
         }

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

@@ -1,7 +1,6 @@
 package de.jeanlucmakiola.calendula.ui.filter
 
 import de.jeanlucmakiola.calendula.domain.FailureReason
-import de.jeanlucmakiola.calendula.ui.common.CalendarAccountGroup
 
 /**
  * State for the calendar-filter sheet (M3). The user toggles per-calendar
@@ -11,9 +10,26 @@ import de.jeanlucmakiola.calendula.ui.common.CalendarAccountGroup
 sealed interface FilterUiState {
     data object Loading : FilterUiState
     data class Failure(val reason: FailureReason) : FilterUiState
-    /** A calendar shows when its id is *not* in [hidden]. */
-    data class Success(
-        val groups: List<CalendarAccountGroup>,
-        val hidden: Set<Long>,
-    ) : FilterUiState
+    data class Success(val groups: List<AccountGroup>) : FilterUiState
 }
+
+/**
+ * Calendars grouped under the account that owns them (Nextcloud / Local / …).
+ *
+ * [accountType] and [ambiguous] carry what the header needs to tell two
+ * same-named accounts from different apps apart (#77); the label itself is
+ * built in the UI layer, which is where the source app's name can be looked up.
+ */
+data class AccountGroup(
+    val account: String,
+    val accountType: String,
+    val ambiguous: Boolean,
+    val calendars: List<CalendarRow>,
+)
+
+data class CalendarRow(
+    val id: Long,
+    val displayName: String,
+    val color: Int,
+    val visible: Boolean,
+)