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

.gitea/workflows/beta.yaml

@@ -15,7 +15,7 @@ jobs:
   detect:
     # Gitea only; see the same guard in release.yaml.
     if: github.repository_owner == 'makiolaj'
-    runs-on: docker
+    runs-on: light
     outputs:
       is_beta: ${{ steps.v.outputs.is_beta }}
       version: ${{ steps.v.outputs.version }}
@@ -41,7 +41,7 @@ jobs:
   beta:
     needs: detect
     if: needs.detect.outputs.is_beta == 'true'
-    runs-on: docker
+    runs-on: gradle
     env:
       ANDROID_HOME: /opt/android-sdk
       ANDROID_SDK_ROOT: /opt/android-sdk

.gitea/workflows/release.yaml

@@ -43,7 +43,7 @@ jobs:
     # secrets. repository_owner differs between the two forges regardless of
     # URL, proxy or instance rename, so this closes it permanently.
     if: github.repository_owner == 'makiolaj'
-    runs-on: docker
+    runs-on: light
     outputs:
       is_release: ${{ steps.v.outputs.is_release }}
       version: ${{ steps.v.outputs.version }}
@@ -85,7 +85,7 @@ jobs:
   release:
     needs: detect
     if: needs.detect.outputs.is_release == 'true' || github.event_name == 'workflow_dispatch'
-    runs-on: docker
+    runs-on: gradle
     env:
       ANDROID_HOME: /opt/android-sdk
       ANDROID_SDK_ROOT: /opt/android-sdk

CHANGELOG.md

@@ -9,9 +9,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### 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. 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]).
 - **Scroll back to earlier days in the agenda.** Scroll up past today to see earlier days' events, loaded a month at a time. Past days follow the past-events setting: Dim fades them, and with Hide the agenda still starts at today ([#367]).
+- **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]).
 
 ### 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]).
 
@@ -1859,3 +1867,10 @@ automatically, with zero telemetry and no internet permission.
 [#367]: https://codeberg.org/jlmakiola/calendula/issues/367
 [#373]: https://codeberg.org/jlmakiola/calendula/issues/373
 [#141]: https://codeberg.org/jlmakiola/calendula/issues/141
+[#153]: https://codeberg.org/jlmakiola/calendula/issues/153
+[#339]: https://codeberg.org/jlmakiola/calendula/issues/339
+[#387]: https://codeberg.org/jlmakiola/calendula/issues/387
+[#271]: https://codeberg.org/jlmakiola/calendula/issues/271
+[#181]: https://codeberg.org/jlmakiola/calendula/issues/181
+[#306]: https://codeberg.org/jlmakiola/calendula/issues/306
+[#178]: https://codeberg.org/jlmakiola/calendula/issues/178

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 = 2230001
-        versionName = "2.23.0-beta.1"
+        versionCode = 2230004
+        versionName = "2.23.0-beta.4"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

app/src/androidTest/java/de/jeanlucmakiola/calendula/ui/detail/PhoneLinksPlatformTest.kt

@@ -0,0 +1,101 @@
+package de.jeanlucmakiola.calendula.ui.detail
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * The platform phone matcher on real text. It reads the region off the SIM,
+ * so these stick to international numbers and to text that must never match
+ * anywhere — domestic formats depend on the device they run on.
+ */
+@RunWith(AndroidJUnit4::class)
+class PhoneLinksPlatformTest {
+
+    private fun numbers(text: String) = findPhoneLinks(text).map { it.number }
+
+    @Test
+    fun internationalNumbers_areFound() {
+        assertThat(numbers("Call +49 30 1234567 or +1 646-558-8656"))
+            .containsExactly("+49301234567", "+16465588656")
+            .inOrder()
+    }
+
+    @Test
+    fun trunkZero_isDroppedWithOrWithoutSpace() {
+        assertThat(numbers("+49 (0)151 2345678")).containsExactly("+491512345678")
+        assertThat(numbers("+49 (0) 151 2345678")).containsExactly("+491512345678")
+    }
+
+    @Test
+    fun neighbouringNumbers_doNotJoinTheNumber() {
+        assertThat(numbers("Start 10:00 +49 151 2345678")).containsExactly("+491512345678")
+        assertThat(numbers("Call +49 151 2345678 2 times")).containsExactly("+491512345678")
+    }
+
+    @Test
+    fun conferenceDialIn_keepsMeetingId() {
+        assertThat(numbers("One tap mobile: +16465588656,,85012345678# US"))
+            .containsExactly("+16465588656,,85012345678#")
+    }
+
+    @Test
+    fun meetingIds_areNotNumbers() {
+        assertThat(numbers("Meeting ID: 850 1234 5678")).isEmpty()
+        assertThat(numbers("Conference ID: 123 456 789#")).isEmpty()
+    }
+
+    @Test
+    fun datesAndTimes_areNotNumbers() {
+        assertThat(numbers("2026-10-14 10:00")).isEmpty()
+        assertThat(numbers("Am 14.10.2026 10:00 Uhr")).isEmpty()
+        assertThat(numbers("14.10.26 - 16.10.26")).isEmpty()
+        assertThat(numbers("10:00 - 11:30")).isEmpty()
+        assertThat(numbers("Schuljahr 2025/2026, Season 2025-2026")).isEmpty()
+        assertThat(numbers("1.10.2026 - 3.10.2026")).isEmpty()
+    }
+
+    @Test
+    fun amounts_areNotNumbers() {
+        assertThat(numbers("Budget 1.250.000 EUR, 1 250 000 EUR")).isEmpty()
+    }
+
+    @Test
+    fun isbn_isNotANumber() {
+        assertThat(numbers("ISBN 978-3-16-148410-0")).isEmpty()
+    }
+
+    @Test
+    fun extension_becomesAPause() {
+        assertThat(numbers("+1 212 555 1234 ext. 567")).containsExactly("+12125551234,567")
+    }
+
+    @Test
+    fun webexAccessCode_isNotANumber() {
+        assertThat(numbers("Meeting number (access code): 2732 123 4567")).isEmpty()
+    }
+
+    @Test
+    fun commaSeparatedNumbers_stayApart() {
+        assertThat(numbers("+49 30 1234567,+49 151 2345678"))
+            .containsExactly("+49301234567", "+491512345678")
+            .inOrder()
+    }
+
+    @Test
+    fun dottedTimes_areNotNumbers() {
+        assertThat(numbers("Beginn 9.30 – 12.00 Uhr")).isEmpty()
+        assertThat(numbers("10.00-11.30")).isEmpty()
+    }
+
+    @Test
+    fun schemelessUrlDigits_areNotNumbers() {
+        assertThat(numbers("zoom.us/j/85012345678")).isEmpty()
+    }
+
+    @Test
+    fun webLinkDigits_areNotNumbers() {
+        assertThat(numbers("https://zoom.us/j/85012345678?pwd=1")).isEmpty()
+    }
+}

app/src/main/AndroidManifest.xml

@@ -151,6 +151,19 @@
                 <data android:mimeType="application/ics" />
             </intent-filter>
 
+            <!-- Text shared or selected in another app opens a prefilled new
+                 event (MainActivity.sharedTextExtrasOrNull, issue #306). -->
+            <intent-filter>
+                <action android:name="android.intent.action.SEND" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:mimeType="text/plain" />
+            </intent-filter>
+            <intent-filter android:label="@string/process_text_create_event">
+                <action android:name="android.intent.action.PROCESS_TEXT" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:mimeType="text/plain" />
+            </intent-filter>
+
             <!-- Let another app or widget (e.g. the Todo Agenda widget) launch us
                  to create a new event, the way the AOSP calendar accepts it:
                  ACTION_INSERT on the events *dir* mime type, carrying the new

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

@@ -25,12 +25,15 @@ import androidx.core.content.IntentCompat
 import androidx.core.net.toUri
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+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.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.RootScreen
 import de.jeanlucmakiola.calendula.ui.common.LocalShowHourGrid
 import de.jeanlucmakiola.calendula.ui.common.LocalMultiDayCount
@@ -50,8 +53,11 @@ import de.jeanlucmakiola.floret.crash.CrashReportDialog
 import de.jeanlucmakiola.floret.crash.CrashReporter
 import de.jeanlucmakiola.floret.crash.submitCrashReport
 import de.jeanlucmakiola.calendula.ui.theme.CalendulaTheme
+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.launch
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toLocalDateTime
@@ -66,6 +72,7 @@ private data class InsertRequest(val form: EventForm, val source: ImportSource)
 class MainActivity : AppCompatActivity() {
 
     @Inject lateinit var calendarRepository: CalendarRepository
+    @Inject lateinit var settingsPrefs: SettingsPrefs
 
     // Which of light/dark the system bars are drawn for. The styles installed
     // in onCreate read this field live, so androidx's config-change replay
@@ -86,10 +93,18 @@ class MainActivity : AppCompatActivity() {
     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). Consumed once by
-    // CalendarHost, which opens it in the create form for review.
+    // 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.
+    private var insertFormOpen = false
+
+    // Started just for an external create, so closing its form returns to the
+    // 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.
@@ -115,9 +130,25 @@ class MainActivity : AppCompatActivity() {
             return
         }
 
-        systemBarsDark = resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK ==
+        val systemDark = resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK ==
             Configuration.UI_MODE_NIGHT_YES
+        // The stored theme only arrives after the first frame, so a Light, Dark
+        // or Black override starts from its last mirrored copy: the matching
+        // backdrop and bar icons instead of the night qualifier's (#181).
+        val cachedTheme = WindowThemeCache.read(this)
+        cachedTheme?.windowBackgroundRes()?.let { window.setBackgroundDrawableResource(it) }
+        systemBarsDark = when (cachedTheme) {
+            null, ThemeMode.SYSTEM -> systemDark
+            ThemeMode.LIGHT -> false
+            ThemeMode.DARK, ThemeMode.BLACK -> true
+        }
         applyEdgeToEdge()
+        lifecycleScope.launch {
+            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
         // time the activity is recreated — on a rotation, or on a restart after
         // the system reclaimed the process. Re-running a launch that opens one
@@ -128,7 +159,8 @@ class MainActivity : AppCompatActivity() {
         //
         // Only those channels are held back. An .ics import or a prefilled
         // create form keeps no saved state of its own, so re-reading the intent
-        // is what carries one through a recreation.
+        // is what carries one through a recreation — the create form only while
+        // it's still open.
         val replaying = savedInstanceState != null || intent.isRelaunch()
         if (!replaying) {
             requestedDetailKey = intent.detailKeyOrNull() ?: intent.viewEventKeyOrNull()
@@ -137,7 +169,11 @@ class MainActivity : AppCompatActivity() {
         requestedNav = intent.navRequestOrNull()
             ?.takeUnless { replaying && it is WidgetNavRequest.OpenEvent }
         requestedImportUri = intent.importUriOrNull()
-        requestedInsert = intent.insertRequestOrNull()
+        val insertOpenBefore = savedInstanceState?.getBoolean(KEY_INSERT_FORM_OPEN) == true
+        requestedInsert = intent.createRequestOrNull()?.takeIf { !replaying || insertOpenBefore }
+        insertFormOpen = requestedInsert != null
+        launchedForInsert = savedInstanceState?.getBoolean(KEY_LAUNCHED_FOR_INSERT)
+            ?: (requestedInsert != null)
         if (CrashReporter.shouldPrompt(this)) pendingCrashReport = CrashReporter.pendingReport(this)
         setContent {
             // One activity-scoped SettingsViewModel drives both the theme here
@@ -147,7 +183,7 @@ class MainActivity : AppCompatActivity() {
             val darkTheme = when (settings.themeMode) {
                 ThemeMode.SYSTEM -> isSystemInDarkTheme()
                 ThemeMode.LIGHT -> false
-                ThemeMode.DARK -> true
+                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
@@ -187,6 +223,7 @@ class MainActivity : AppCompatActivity() {
             CalendulaTheme(
                 darkTheme = darkTheme,
                 dynamicColor = settings.dynamicColor,
+                pureBlack = settings.themeMode == ThemeMode.BLACK,
                 typography = typography,
             ) {
                 Box(modifier = Modifier.fillMaxSize()) {
@@ -208,6 +245,10 @@ class MainActivity : AppCompatActivity() {
                             requestedInsertForm = requestedInsert?.form,
                             requestedInsertSource = requestedInsert?.source ?: ImportSource.Insert,
                             onInsertConsumed = { requestedInsert = null },
+                            onExternalFormClosed = {
+                                insertFormOpen = false
+                                if (launchedForInsert) finish()
+                            },
                             requestedEditKey = requestedEditKey,
                             onEditKeyConsumed = { requestedEditKey = null },
                         )
@@ -261,12 +302,21 @@ class MainActivity : AppCompatActivity() {
         CrashReporter.markHealthy(this)
     }
 
+    override fun onSaveInstanceState(outState: Bundle) {
+        super.onSaveInstanceState(outState)
+        outState.putBoolean(KEY_INSERT_FORM_OPEN, insertFormOpen)
+        outState.putBoolean(KEY_LAUNCHED_FOR_INSERT, launchedForInsert)
+    }
+
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
         (intent.detailKeyOrNull() ?: intent.viewEventKeyOrNull())?.let { requestedDetailKey = it }
         intent.navRequestOrNull()?.let { requestedNav = it }
         intent.importUriOrNull()?.let { requestedImportUri = it }
-        intent.insertRequestOrNull()?.let { requestedInsert = it }
+        intent.createRequestOrNull()?.let {
+            requestedInsert = it
+            insertFormOpen = true
+        }
         intent.editEventKeyOrNull()?.let { requestedEditKey = it }
     }
 
@@ -288,7 +338,9 @@ class MainActivity : AppCompatActivity() {
     private fun Intent.importUriOrNull(): Uri? {
         val uri = when (action) {
             Intent.ACTION_VIEW -> data
+            // 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;
@@ -333,6 +385,36 @@ class MainActivity : AppCompatActivity() {
         return InsertRequest(form, if (namesEnd) ImportSource.Insert else ImportSource.InsertOpenEnded)
     }
 
+    /** Any external request to create an event: shared text or an insert intent. */
+    private fun Intent.createRequestOrNull(): InsertRequest? = sharedTextRequestOrNull() ?: insertRequestOrNull()
+
+    /**
+     * Plain text shared into us (`ACTION_SEND`) or picked from a text-selection
+     * menu (`ACTION_PROCESS_TEXT`), as a new event at the default time (#306).
+     */
+    private fun Intent.sharedTextRequestOrNull(): InsertRequest? {
+        val shared = when (action) {
+            Intent.ACTION_SEND -> if (type == SHARED_TEXT_TYPE) {
+                sharedTextOrNull(
+                    subject = getCharSequenceExtra(Intent.EXTRA_SUBJECT)?.toString(),
+                    text = getCharSequenceExtra(Intent.EXTRA_TEXT)?.toString(),
+                )
+            } else {
+                null
+            }
+            Intent.ACTION_PROCESS_TEXT ->
+                sharedTextOrNull(subject = null, text = getCharSequenceExtra(Intent.EXTRA_PROCESS_TEXT)?.toString())
+            else -> null
+        } ?: return null
+        val form = buildInsertEventForm(
+            title = shared.title,
+            description = shared.description,
+            zone = TimeZone.currentSystemDefault(),
+            now = Clock.System.now(),
+        )
+        return InsertRequest(form, ImportSource.InsertOpenEnded)
+    }
+
     /** 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
@@ -458,6 +540,9 @@ class MainActivity : AppCompatActivity() {
         // The calendar provider's authority/host. A date tap arrives as
         // 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 const val KEY_INSERT_FORM_OPEN = "insert_form_open"
+        private const val KEY_LAUNCHED_FOR_INSERT = "launched_for_insert"
 
         private const val EXTRA_EVENT_ID = "de.jeanlucmakiola.calendula.extra.EVENT_ID"
         private const val EXTRA_BEGIN_MILLIS = "de.jeanlucmakiola.calendula.extra.BEGIN"

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

@@ -1,15 +1,19 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
+import de.jeanlucmakiola.calendula.domain.instantIn
+import kotlinx.datetime.toKotlinTimeZone
 import android.provider.CalendarContract
 import de.jeanlucmakiola.calendula.domain.AccessLevel
 import de.jeanlucmakiola.calendula.domain.Availability
 import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.FormTime
 import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
 import de.jeanlucmakiola.calendula.domain.nearestTo
 import kotlinx.datetime.toJavaLocalDate
 import kotlinx.datetime.toJavaLocalDateTime
+import kotlinx.datetime.toJavaZoneOffset
 import java.time.Duration
 import java.time.Instant
 import java.time.ZoneId
@@ -48,8 +52,8 @@ internal fun EventForm.toWriteTimes(zone: ZoneId): EventWriteTimes = if (isAllDa
 } else {
     val writeZone = writeZone(zone)
     EventWriteTimes(
-        dtStartMillis = start.toJavaLocalDateTime().atZone(writeZone).toInstant().toEpochMilli(),
-        dtEndMillis = end.toJavaLocalDateTime().atZone(writeZone).toInstant().toEpochMilli(),
+        dtStartMillis = start.instantIn(writeZone.toKotlinTimeZone()).toEpochMilliseconds(),
+        dtEndMillis = end.instantIn(writeZone.toKotlinTimeZone()).toEpochMilliseconds(),
         timezone = writeZone.id,
     )
 }
@@ -75,7 +79,7 @@ private fun EventForm.writeZone(deviceZone: ZoneId): ZoneId = if (isAllDay) {
 private fun EventForm.anchorLocal(): JavaLocalDateTime = if (isAllDay) {
     start.date.toJavaLocalDate().atStartOfDay()
 } else {
-    start.toJavaLocalDateTime()
+    start.dateTime.toJavaLocalDateTime()
 }
 
 /**
@@ -181,7 +185,8 @@ internal fun buildEventUpdateValues(
 
     // A zone change counts as a time change even when the wall-clock is
     // untouched: the same 09:00 in another zone is a different instant, so
-    // DTSTART has to move with it.
+    // DTSTART has to move with it. So does a switch between the two passes of
+    // the fall-back hour, which each [FormTime] carries (#387).
     val timesChanged = updated.start != original.start ||
         updated.end != original.end ||
         updated.isAllDay != original.isAllDay ||
@@ -209,15 +214,23 @@ internal fun buildEventUpdateValues(
         // is a different offset from the series anchor's whenever a DST boundary
         // sits between them, or whenever the zone itself changed. Working in wall
         // clock keeps "09:00" meaning 09:00 at both ends.
-        val seriesLocal = Instant.ofEpochMilli(seriesDtStartMillis)
-            .atZone(original.writeZone(zone)).toLocalDateTime()
+        val seriesZoned = Instant.ofEpochMilli(seriesDtStartMillis).atZone(original.writeZone(zone))
+        val seriesLocal = seriesZoned.toLocalDateTime()
         val wallClockShift = Duration.between(original.anchorLocal(), updated.anchorLocal())
         val shifted = seriesLocal.plus(wallClockShift)
         // An all-day series anchor must sit on a UTC midnight. A pure day move
         // already lands there (both ends are midnights), but *switching* a
         // recurring event to all-day shifts by a time-of-day too, so snap.
         val newSeriesLocal = if (updated.isAllDay) shifted.toLocalDate().atStartOfDay() else shifted
-        val newSeriesStart = newSeriesLocal.atZone(updated.writeZone(zone))
+        // A wall clock the fall-back hour repeats keeps the anchor's own pass, or,
+        // when the anchor is the edited occurrence itself, the pass the form now
+        // holds: a bare wall clock would always take the earlier one (#387).
+        val pass = if (seriesLocal == original.anchorLocal()) {
+            updated.start.offset?.toJavaZoneOffset()
+        } else {
+            seriesZoned.offset
+        }
+        val newSeriesStart = ZonedDateTime.ofLocal(newSeriesLocal, updated.writeZone(zone), pass)
         put(CalendarContract.Events.DTSTART, newSeriesStart.toInstant().toEpochMilli())
         put(CalendarContract.Events.DTEND, null)
         put(CalendarContract.Events.RRULE, updated.rrule)

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

@@ -8,6 +8,7 @@ import de.jeanlucmakiola.floret.reminders.ReminderOverride
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.Availability
 import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.FormTime
 import de.jeanlucmakiola.calendula.domain.RecurrenceFreq
 import de.jeanlucmakiola.calendula.domain.SimpleRecurrence
 import de.jeanlucmakiola.calendula.domain.contacts.ContactSpecialDate
@@ -212,8 +213,8 @@ class SpecialDatesSyncEngine @Inject constructor(
             calendarId = calendarId,
             title = title,
             isAllDay = true,
-            start = start,
-            end = start,
+            start = FormTime(start),
+            end = FormTime(start),
             reminders = reminderCtx.resolveAllDay(calendarId),
             availability = Availability.Free,
             rrule = YEARLY_RRULE,

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

@@ -21,7 +21,9 @@ import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesCalendarSpec
 import de.jeanlucmakiola.calendula.data.reminders.ProviderReminderInstanceSource
 import de.jeanlucmakiola.calendula.data.reminders.ReminderInstanceSource
 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.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import javax.inject.Singleton
@@ -69,6 +71,12 @@ abstract class DataBindModule {
     abstract fun bindTodaySource(
         impl: AndroidTodaySource,
     ): TodaySource
+
+    @Binds
+    @Singleton
+    abstract fun bindZoneSource(
+        impl: AndroidZoneSource,
+    ): ZoneSource
 }
 
 @Module

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

@@ -41,8 +41,11 @@ import java.util.Locale
 import javax.inject.Inject
 import javax.inject.Singleton
 
-/** Light/dark override. SYSTEM follows the device setting. */
-enum class ThemeMode { SYSTEM, LIGHT, DARK }
+/**
+ * Light/dark override. SYSTEM follows the device setting; BLACK is dark with
+ * pure-black surfaces, for AMOLED screens (#181).
+ */
+enum class ThemeMode { SYSTEM, LIGHT, DARK, BLACK }
 
 /**
  * Week-start override. [Auto] derives the first day from the active locale;
@@ -346,6 +349,19 @@ class SettingsPrefs @Inject constructor(
         store.edit { it[DRAG_TO_RESCHEDULE_KEY] = enabled }
     }
 
+    /**
+     * Whether tapping an event in the calendar views opens the edit form instead
+     * of the detail screen (#178). Defaults to OFF; read-only events and
+     * reminder notifications always open the detail screen.
+     */
+    val tapOpensEditor: Flow<Boolean> = store.data.map { prefs ->
+        prefs[TAP_OPENS_EDITOR_KEY] ?: false
+    }
+
+    suspend fun setTapOpensEditor(enabled: Boolean) {
+        store.edit { it[TAP_OPENS_EDITOR_KEY] = enabled }
+    }
+
     /**
      * How far ahead the in-app Agenda screen shows events (v2.11). Defaults to
      * [AgendaRange.Month] — a month of upcoming events. Independent of the
@@ -1019,6 +1035,7 @@ class SettingsPrefs @Inject constructor(
         internal val TIMELINE_SCALE_KEY = stringPreferencesKey("timeline_scale")
         internal val TODAY_BUTTON_IN_TOOLBAR_KEY = booleanPreferencesKey("today_button_in_toolbar")
         internal val DRAG_TO_RESCHEDULE_KEY = booleanPreferencesKey("drag_to_reschedule")
+        internal val TAP_OPENS_EDITOR_KEY = booleanPreferencesKey("tap_opens_editor")
         internal val DEFAULT_VIEW_KEY = stringPreferencesKey("default_view")
         internal val QUICK_SWITCH_VIEWS_KEY = stringPreferencesKey("quick_switch_views")
         internal val DRAWER_VIEW_ORDER_KEY = stringPreferencesKey("drawer_view_order")

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

@@ -0,0 +1,51 @@
+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 kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onStart
+import kotlinx.datetime.TimeZone
+import javax.inject.Inject
+
+/**
+ * The zone the device is in. Every screen that turns wall clock into instants
+ * reads it from here, so the timeline, the event form and a saved move use the
+ * same zone (#387).
+ */
+interface ZoneSource {
+    /** The device's zone, re-emitted whenever it changes. */
+    val zone: Flow<TimeZone>
+
+    /** The device's zone right now. */
+    fun current(): TimeZone
+}
+
+/** Follows the system's zone broadcast. */
+class AndroidZoneSource @Inject constructor(
+    @ApplicationContext private val context: Context,
+) : ZoneSource {
+
+    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()
+
+    override fun current(): TimeZone = TimeZone.currentSystemDefault()
+}

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

@@ -4,7 +4,7 @@ import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
-import kotlinx.datetime.toInstant
+import kotlinx.datetime.UtcOffset
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Instant
 
@@ -17,8 +17,8 @@ data class EventForm(
     val calendarId: Long?,
     val title: String = "",
     val isAllDay: Boolean = false,
-    val start: LocalDateTime,
-    val end: LocalDateTime,
+    val start: FormTime,
+    val end: FormTime,
     /**
      * The zone [start]/[end] are wall-clock values in, or null to follow the
      * device — null is not "no zone", it is "whichever zone the device is in
@@ -70,6 +70,19 @@ data class EventForm(
     val attendees: List<EventAttendee> = emptyList(),
 )
 
+/**
+ * One end of a form's span: a wall-clock [dateTime] in the form's zone, and the
+ * [offset] it was read at when the fall-back hour repeats that wall clock — both
+ * of the hour's instants share one [LocalDateTime] (#387). Null everywhere else,
+ * so a time changed and changed back compares equal again. A time picked by hand
+ * gets its pass from [repicked]; one without an offset reads as the earlier
+ * pass. One value, so a time never changes without its pass. See [toFormTime].
+ */
+data class FormTime(val dateTime: LocalDateTime, val offset: UtcOffset? = null) {
+    val date: LocalDate get() = dateTime.date
+    val time: LocalTime get() = dateTime.time
+}
+
 /**
  * One editable guest: the user controls the [email] (the identity we dedup and
  * write on), an optional display [name], and whether they're [optional] rather
@@ -145,16 +158,15 @@ fun EventDetail.toEditForm(beginMillis: Long, endMillis: Long, zone: TimeZone):
             ?.takeIf { runCatching { TimeZone.of(it) }.isSuccess }
     }
     val formZone = pinnedZone?.let { TimeZone.of(it) } ?: zone
+    val begin = Instant.fromEpochMilliseconds(beginMillis)
+    val finish = Instant.fromEpochMilliseconds(endMillis)
     val (start, end) = if (instance.isAllDay) {
-        val startDate = Instant.fromEpochMilliseconds(beginMillis)
-            .toLocalDateTime(TimeZone.UTC).date
-        val endExclusive = Instant.fromEpochMilliseconds(endMillis)
-            .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))
-        LocalDateTime(startDate, LocalTime(9, 0)) to LocalDateTime(endDate, LocalTime(10, 0))
+        FormTime(LocalDateTime(startDate, LocalTime(9, 0))) to FormTime(LocalDateTime(endDate, LocalTime(10, 0)))
     } else {
-        Instant.fromEpochMilliseconds(beginMillis).toLocalDateTime(formZone) to
-            Instant.fromEpochMilliseconds(endMillis).toLocalDateTime(formZone)
+        begin.toFormTime(formZone) to finish.toFormTime(formZone)
     }
     return EventForm(
         calendarId = instance.calendarId,
@@ -221,20 +233,18 @@ fun EventDetail.toEditSnapshot(beginMillis: Long, endMillis: Long, zone: TimeZon
     )
 
 /**
- * The form's times as they land in [target] — what a pinned event's wall-clock
- * actually means where the user is standing. Null when there's nothing to
- * disambiguate: an unpinned event (already in [target]), one pinned to [target]
- * itself, an all-day event (no zone), or an unparseable pinned zone.
+ * 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
+ * unpinned event (already in [target]), one pinned to [target] itself, an
+ * all-day event (no zone), or an unparseable pinned zone.
  *
- * The form edits a pinned event in its own zone, so this is what lets the UI
- * show the other side of the pair rather than making the user do the arithmetic.
+ * The form edits a pinned event in its own zone, so this is what tells the UI
+ * to show the other side of the pair rather than making the user do the arithmetic.
  */
-fun EventForm.timesIn(target: TimeZone): Pair<LocalDateTime, LocalDateTime>? {
-    if (isAllDay) return null
-    val pinned = timezone?.let { runCatching { TimeZone.of(it) }.getOrNull() } ?: return null
-    if (pinned.id == target.id) return null
-    return start.toInstant(pinned).toLocalDateTime(target) to
-        end.toInstant(pinned).toLocalDateTime(target)
+fun EventForm.isPinnedAwayFrom(target: TimeZone): Boolean {
+    if (isAllDay) return false
+    val pinned = timezone?.let { runCatching { TimeZone.of(it) }.getOrNull() } ?: return false
+    return pinned.id != target.id
 }
 
 /**
@@ -254,9 +264,19 @@ fun EventForm.populatedFields(): Set<EventFormField> = buildSet {
     if (attendees.isNotEmpty()) add(EventFormField.Attendees)
 }
 
-fun EventForm.problems(): Set<EventFormProblem> = buildSet {
+/**
+ * What stops this form from saving. A timed span is checked as instants in the
+ * form's zone (else [deviceZone]): one ending in the fall-back hour's repeat can
+ * end on an earlier wall clock than it starts (#387).
+ */
+fun EventForm.problems(deviceZone: TimeZone): Set<EventFormProblem> = buildSet {
     if (calendarId == null) add(EventFormProblem.NoCalendar)
-    val endsTooEarly = if (isAllDay) end.date < start.date else end < start
+    val endsTooEarly = if (isAllDay) {
+        end.date < start.date
+    } else {
+        val zone = resolvedZone(deviceZone)
+        endInstant(zone) < startInstant(zone)
+    }
     if (endsTooEarly) add(EventFormProblem.EndBeforeStart)
     // An UNTIL before the first day would make the provider generate zero
     // occurrences — the event would silently vanish from every view.

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

@@ -162,16 +162,20 @@ object EventSearch {
         val title = candidate.title?.takeIf { it.isNotBlank() }
         val location = candidate.event.location?.takeIf { it.isNotBlank() }
         // Collapsed so a multi-line description matches the way it is drawn.
-        val description = candidate.description
+        val rich = candidate.description?.let(::descriptionRichText)
+        val description = rich?.text
             ?.replace(WHITESPACE, " ")
             ?.trim()
             ?.takeIf { it.isNotEmpty() }
+        // A link's address isn't in the drawn text, but "zoom.us" should still find the invite.
+        val linkUrls = rich?.links.orEmpty().map { it.url }
 
         // Mid-word counts: "termin" has to keep finding "Zahnarzttermin".
         val present = { token: String ->
             title?.contains(token, ignoreCase = true) == true ||
                 location?.contains(token, ignoreCase = true) == true ||
-                description?.contains(token, ignoreCase = true) == true
+                description?.contains(token, ignoreCase = true) == true ||
+                linkUrls.any { it.contains(token, ignoreCase = true) }
         }
         if (!tokens.all(present)) return null
 

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

@@ -3,10 +3,19 @@ package de.jeanlucmakiola.calendula.domain
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.TimeZone
+import kotlinx.datetime.UtcOffset
+import kotlinx.datetime.offsetAt
 import kotlinx.datetime.plus
 import kotlinx.datetime.toInstant
+import kotlinx.datetime.toJavaLocalDateTime
+import kotlinx.datetime.toJavaZoneId
+import kotlinx.datetime.toJavaZoneOffset
+import kotlinx.datetime.toKotlinUtcOffset
 import kotlinx.datetime.toLocalDateTime
+import java.time.ZonedDateTime
 import kotlin.time.Instant
+import kotlin.time.toJavaInstant
+import kotlin.time.toKotlinInstant
 
 /**
  * The zone this form's wall-clock times mean, matching what the data layer
@@ -15,6 +24,114 @@ import kotlin.time.Instant
 fun EventForm.resolvedZone(deviceZone: TimeZone): TimeZone =
     timezone?.let { runCatching { TimeZone.of(it) }.getOrNull() } ?: deviceZone
 
+/**
+ * This wall-clock time in [zone], at [preferred] when the fall-back hour repeats
+ * it and that is one of its two offsets — otherwise the earlier one (#387).
+ */
+fun LocalDateTime.resolveIn(zone: TimeZone, preferred: UtcOffset?): Instant =
+    ZonedDateTime.ofLocal(toJavaLocalDateTime(), zone.toJavaZoneId(), preferred?.toJavaZoneOffset())
+        .toInstant().toKotlinInstant()
+
+/** Whether this instant's wall clock in [zone] is one the fall-back hour repeats. */
+fun Instant.inRepeatedHour(zone: TimeZone): Boolean {
+    val zid = zone.toJavaZoneId()
+    return zid.rules.getTransition(java.time.LocalDateTime.ofInstant(toJavaInstant(), zid))?.isOverlap == true
+}
+
+/**
+ * [at]'s offset in this zone when its wall clock is one the fall-back hour
+ * repeats, else null: elsewhere the wall clock alone already names the instant.
+ * What a [FormTime.offset] holds (#387).
+ */
+fun TimeZone.repeatedHourOffsetAt(at: Instant): UtcOffset? = if (at.inRepeatedHour(this)) offsetAt(at) else null
+
+/** This instant as a [FormTime] in [zone], keeping its pass of a repeated hour. */
+fun Instant.toFormTime(zone: TimeZone): FormTime = FormTime(toLocalDateTime(zone), zone.repeatedHourOffsetAt(this))
+
+/** This time as an instant in [zone], on its kept pass of a repeated hour. */
+fun FormTime.instantIn(zone: TimeZone): Instant = dateTime.resolveIn(zone, offset)
+
+/**
+ * This edge of an event moved to [picked] by hand — a picker or a resize handle —
+ * as a [FormTime] in [zone]. A time in the spring-forward gap moves on to the
+ * real one, as the provider would read it. A wall clock the fall-back hour
+ * repeats has two instants; which one it means (#387):
+ * - [original]'s, when [picked] is the wall clock the event was opened with, so
+ *   a time changed and changed back is the time it was;
+ * - else the one that moves the edge in the direction the user moved it:
+ *   earlier than this edge's instant when [picked] is before [shownAt] (where
+ *   the edge was on screen), later when after;
+ * - kept within [notBefore]..[notAfter] (the other edge), and to the ones
+ *   [drawable] accepts — where the screen can show it — when any fit.
+ */
+fun FormTime.repicked(
+    picked: LocalDateTime,
+    zone: TimeZone,
+    shownAt: LocalDateTime = dateTime,
+    original: FormTime? = null,
+    notBefore: Instant? = null,
+    notAfter: Instant? = null,
+    drawable: (Instant) -> Boolean = { true },
+): FormTime {
+    if (picked == dateTime && picked == shownAt) return this
+    val offsets = zone.toJavaZoneId().rules.getValidOffsets(picked.toJavaLocalDateTime())
+    if (offsets.isEmpty()) return FormTime(picked).instantIn(zone).toFormTime(zone)
+    if (offsets.size == 1) return FormTime(picked)
+    val passes = offsets.map { picked.toInstant(it.toKotlinUtcOffset()) }.sorted()
+    val bounded = passes.filter { (notBefore == null || it >= notBefore) && (notAfter == null || it <= notAfter) }
+        .ifEmpty { passes }
+    val fitting = bounded.filter(drawable).ifEmpty { bounded }
+    if (original?.dateTime == picked && original.offset != null && original.instantIn(zone) in fitting) return original
+    val from = instantIn(zone)
+    val chosen = when {
+        picked < shownAt -> fitting.lastOrNull { it < from }
+        picked > shownAt -> fitting.firstOrNull { it > from }
+        else -> null
+    } ?: fitting.minBy { (it - from).absoluteValue }
+    return chosen.toFormTime(zone)
+}
+
+/** The form's start as an instant in [zone]. */
+fun EventForm.startInstant(zone: TimeZone): Instant = start.instantIn(zone)
+
+/** The form's end as an instant in [zone]. */
+fun EventForm.endInstant(zone: TimeZone): Instant = end.instantIn(zone)
+
+/** The form's timed span set to these instants, read in [zone]. */
+fun EventForm.withTimes(start: Instant, end: Instant, zone: TimeZone): EventForm =
+    copy(start = start.toFormTime(zone), end = end.toFormTime(zone))
+
+/**
+ * The form pinned to [zoneId] (null: the device). A kept pass of a repeated hour
+ * was one of the old zone's, so it goes when the zone the times mean changes.
+ */
+fun EventForm.withTimezone(zoneId: String?, deviceZone: TimeZone): EventForm {
+    val pinned = copy(timezone = zoneId)
+    if (pinned.resolvedZone(deviceZone) == resolvedZone(deviceZone)) return pinned
+    return pinned.withoutKeptPasses()
+}
+
+/**
+ * The form with its start picked by hand, keeping its length. A repeated hour's
+ * pass is [repicked]: [original] is the start the event was opened with.
+ */
+fun EventForm.withStart(start: LocalDateTime, zone: TimeZone, original: FormTime? = null): EventForm {
+    val span = endInstant(zone) - startInstant(zone)
+    val startAt = this.start.repicked(start, zone, original = original).instantIn(zone)
+    return withTimes(startAt, startAt + span, zone)
+}
+
+/**
+ * The form with its end picked by hand. A repeated hour's pass is [repicked],
+ * kept after the start where it can be: [original] is the end the event was
+ * opened with.
+ */
+fun EventForm.withEnd(end: LocalDateTime, zone: TimeZone, original: FormTime? = null): EventForm =
+    copy(end = this.end.repicked(end, zone, original = original, notBefore = startInstant(zone)))
+
+/** The form with no kept passes: its times as the wall clock alone says them. */
+fun EventForm.withoutKeptPasses(): EventForm = copy(start = FormTime(start.dateTime), end = FormTime(end.dateTime))
+
 /**
  * The form moved so it starts at [newStart], keeping its **instant** duration —
  * a recurring event's length travels to the provider as `DURATION`, so keeping
@@ -26,11 +143,8 @@ fun EventForm.resolvedZone(deviceZone: TimeZone): TimeZone =
 fun EventForm.shiftedTo(newStart: Instant, deviceZone: TimeZone): EventForm {
     if (isAllDay) return this
     val zone = resolvedZone(deviceZone)
-    val span = end.toInstant(zone) - start.toInstant(zone)
-    return copy(
-        start = newStart.toLocalDateTime(zone),
-        end = (newStart + span).toLocalDateTime(zone),
-    )
+    val span = endInstant(zone) - startInstant(zone)
+    return withTimes(newStart, newStart + span, zone)
 }
 
 /**
@@ -43,21 +157,21 @@ fun EventForm.shiftedByDays(days: Int, deviceZone: TimeZone): EventForm {
     val newStart = LocalDateTime(start.date.plus(days, DateTimeUnit.DAY), start.time)
     if (isAllDay) {
         return copy(
-            start = newStart,
-            end = LocalDateTime(end.date.plus(days, DateTimeUnit.DAY), end.time),
+            start = FormTime(newStart),
+            end = FormTime(LocalDateTime(end.date.plus(days, DateTimeUnit.DAY), end.time)),
         )
     }
     val zone = resolvedZone(deviceZone)
-    val span = end.toInstant(zone) - start.toInstant(zone)
-    return copy(start = newStart, end = (newStart.toInstant(zone) + span).toLocalDateTime(zone))
+    val span = endInstant(zone) - startInstant(zone)
+    val startAt = FormTime(newStart, start.offset).instantIn(zone)
+    // The start keeps the wall clock it was moved to, even one the spring-forward
+    // gap skips, so a recurring series still sees a whole-day move.
+    val movedStart = startAt.toFormTime(zone).takeIf { it.dateTime == newStart } ?: FormTime(newStart)
+    return copy(start = movedStart, end = (startAt + span).toFormTime(zone))
 }
 
 /** The form with new start and end, each in the form's own zone — a resize. All-day is untouched. */
 fun EventForm.resizedTo(newStart: Instant, newEnd: Instant, deviceZone: TimeZone): EventForm {
     if (isAllDay) return this
-    val zone = resolvedZone(deviceZone)
-    return copy(
-        start = newStart.toLocalDateTime(zone),
-        end = newEnd.toLocalDateTime(zone),
-    )
+    return withTimes(newStart, newEnd, resolvedZone(deviceZone))
 }

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

@@ -0,0 +1,387 @@
+package de.jeanlucmakiola.calendula.domain
+
+/** Inline formatting an HTML description keeps; fonts, sizes and colours are dropped. */
+enum class InlineStyle { Bold, Italic, Underline, Strikethrough, Superscript, Subscript, Monospace }
+
+data class StyleRange(val start: Int, val end: Int, val style: InlineStyle)
+
+/** A link from an `<a href>`, spanning [start] until [end] (exclusive). */
+data class LinkRange(val start: Int, val end: Int, val url: String)
+
+/** Text as drawn, with the formatting and links that sit on it. Plain text has neither. */
+data class RichText(
+    val text: String,
+    val styles: List<StyleRange> = emptyList(),
+    val links: List<LinkRange> = emptyList(),
+) {
+    /**
+     * [text] with each link's address after it, where the text doesn't already
+     * show it, so a copied "Join the meeting" still carries its URL.
+     */
+    fun copyText(): String {
+        if (links.isEmpty()) return text
+        val out = StringBuilder(text)
+        for (link in links.sortedByDescending { it.end }) {
+            val address = link.url.removePrefix("mailto:").removePrefix("tel:")
+            if (address !in text.substring(link.start, link.end)) out.insert(link.end, " ($address)")
+        }
+        return out.toString()
+    }
+}
+
+fun looksLikeHtml(text: String): Boolean = htmlTagRegex.containsMatchIn(text)
+
+/** [description] as it reads: HTML rendered down to [RichText], plain text as it is. */
+fun descriptionRichText(description: String): RichText =
+    if (looksLikeHtml(description)) parseHtml(description) else RichText(description)
+
+private val BLOCK_TAGS = setOf(
+    "p", "div", "ul", "ol", "li", "table", "tr", "blockquote", "pre", "hr", "section", "article",
+    "header", "footer", "dl", "dt", "dd", "address", "center", "h1", "h2", "h3", "h4", "h5", "h6",
+)
+
+// Their content is never text to show.
+private val SKIPPED_TAGS = setOf("head", "style", "script", "title", "xml", "template")
+
+private val STYLE_TAGS = mapOf(
+    "b" to InlineStyle.Bold, "strong" to InlineStyle.Bold, "th" to InlineStyle.Bold,
+    "h1" to InlineStyle.Bold, "h2" to InlineStyle.Bold, "h3" to InlineStyle.Bold,
+    "h4" to InlineStyle.Bold, "h5" to InlineStyle.Bold, "h6" to InlineStyle.Bold,
+    "i" to InlineStyle.Italic, "em" to InlineStyle.Italic, "cite" to InlineStyle.Italic,
+    "u" to InlineStyle.Underline, "ins" to InlineStyle.Underline,
+    "s" to InlineStyle.Strikethrough, "strike" to InlineStyle.Strikethrough, "del" to InlineStyle.Strikethrough,
+    "sup" to InlineStyle.Superscript, "sub" to InlineStyle.Subscript,
+    "code" to InlineStyle.Monospace, "tt" to InlineStyle.Monospace, "pre" to InlineStyle.Monospace,
+)
+
+// A real tag the renderer knows, not prose like "<3" or "a < b". Google
+// Calendar and Exchange both store their descriptions as HTML.
+private val htmlTagRegex = Regex(
+    (BLOCK_TAGS + SKIPPED_TAGS + STYLE_TAGS.keys + setOf("html", "body", "br", "span", "a", "font", "img", "meta", "td"))
+        .joinToString("|", prefix = """</?(?:""", postfix = """)(?:\s[^<>]*)?/?>"""),
+    RegexOption.IGNORE_CASE,
+)
+
+private val LINK_SCHEMES = listOf("http://", "https://", "mailto:", "tel:")
+
+private const val NBSP = '\u00A0'
+private const val CELL_SEPARATOR = " · "
+
+/**
+ * Render [html] down to text with its inline formatting and links. Blocks and
+ * `<br>` become line breaks, list items get a bullet or number, table rows a
+ * line each with their cells side by side. Lenient about broken markup:
+ * whatever doesn't parse as a tag stays text.
+ */
+fun parseHtml(html: String): RichText = HtmlRenderer(html).render()
+
+// Markup that sets its own lines. Without any, the text's newlines are the
+// lines: "Agenda:\n1. Intro" with one <a href> in it stays on two lines.
+private val lineTagRegex = Regex("""<(?:br|p|div|li|tr|h[1-6]|pre|blockquote|table)\b""", RegexOption.IGNORE_CASE)
+
+private class HtmlRenderer(private val html: String) {
+    private val out = StringBuilder()
+    private val styles = mutableListOf<StyleRange>()
+    private val links = mutableListOf<LinkRange>()
+    private val openStyles = mutableListOf<Pair<String, Int>>()
+    private var openLink: Pair<String, Int>? = null
+    private val lists = mutableListOf<ListState>()
+    private val keepNewlines = !lineTagRegex.containsMatchIn(html)
+    private var preDepth = 0
+    private var rowStart = 0
+    private var cellNeedsSeparator = false
+    // Where the current list item's bullet ends, so a <p> inside the item
+    // doesn't push its text off the bullet's line.
+    private var markerEnd = -1
+
+    private class ListState(val ordered: Boolean, var count: Int = 0)
+
+    fun render(): RichText {
+        var i = 0
+        while (i < html.length) {
+            val lt = html.indexOf('<', i)
+            if (lt < 0) {
+                text(html.substring(i))
+                break
+            }
+            if (lt > i) text(html.substring(i, lt))
+            i = tag(lt)
+        }
+        return normalize()
+    }
+
+    /** Handle the markup at [lt]; returns where reading continues. */
+    private fun tag(lt: Int): Int {
+        if (html.startsWith("<!--", lt)) {
+            val end = html.indexOf("-->", lt + 4)
+            return if (end < 0) html.length else end + 3
+        }
+        if (html.startsWith("<!", lt) || html.startsWith("<?", lt)) {
+            val end = html.indexOf('>', lt)
+            return if (end < 0) html.length else end + 1
+        }
+        val closing = html.getOrNull(lt + 1) == '/'
+        val nameStart = if (closing) lt + 2 else lt + 1
+        if (html.getOrNull(nameStart)?.isLetter() != true) {
+            text("<")
+            return lt + 1
+        }
+        val end = tagEnd(lt)
+        if (end < 0) {
+            text("<")
+            return lt + 1
+        }
+        var nameEnd = nameStart
+        while (nameEnd < end && (html[nameEnd].isLetterOrDigit() || html[nameEnd] == ':')) nameEnd++
+        val name = html.substring(nameStart, nameEnd).lowercase()
+        val attrs = html.substring(nameEnd, end)
+        if (closing) {
+            close(name)
+        } else if (name in SKIPPED_TAGS && !attrs.trimEnd().endsWith("/")) {
+            // Never closed (an omitted </head> is valid): just ignore the tag.
+            val closeAt = html.indexOf("</$name", end, ignoreCase = true)
+            if (closeAt < 0) return end + 1
+            val closeEnd = html.indexOf('>', closeAt)
+            return if (closeEnd < 0) html.length else closeEnd + 1
+        } else {
+            open(name, attrs)
+        }
+        return end + 1
+    }
+
+    /** The `>` closing the tag at [lt], skipping any inside quoted attributes. */
+    private fun tagEnd(lt: Int): Int {
+        var quote: Char? = null
+        for (j in lt + 1 until html.length) {
+            val c = html[j]
+            when {
+                quote != null -> if (c == quote) quote = null
+                c == '"' || c == '\'' -> quote = c
+                c == '>' -> return j
+                c == '<' -> return -1
+            }
+        }
+        return -1
+    }
+
+    private fun open(name: String, attrs: String) {
+        when (name) {
+            "br" -> newline()
+            "li" -> {
+                markerEnd = -1
+                cellNeedsSeparator = false
+                lineBreak()
+                val list = lists.lastOrNull()
+                out.append("$NBSP$NBSP".repeat((lists.size - 1).coerceAtLeast(0)))
+                if (list?.ordered == true) {
+                    list.count++
+                    out.append("${list.count}. ")
+                } else {
+                    out.append("• ")
+                }
+                markerEnd = out.length
+            }
+            "ul", "ol" -> {
+                cellNeedsSeparator = false
+                lineBreak()
+                val start = startRegex.find(attrs)?.groupValues?.get(1)?.toIntOrNull() ?: 1
+                lists += ListState(ordered = name == "ol", count = start - 1)
+            }
+            "tr" -> {
+                lineBreak()
+                rowStart = out.length
+                cellNeedsSeparator = false
+            }
+            "td", "th" -> {
+                // An empty spacer cell leaves nothing behind, not even its &nbsp;.
+                if (rowStart <= out.length && (rowStart until out.length).none { out[it].isContent() }) {
+                    cut(rowStart)
+                } else {
+                    cellNeedsSeparator = true
+                }
+            }
+            "a" -> {
+                closeLink()
+                hrefRegex.find(attrs)
+                    ?.groupValues?.drop(1)?.firstOrNull { it.isNotEmpty() }
+                    ?.let(::decodeEntities)
+                    ?.trim()
+                    ?.let { href ->
+                        val scheme = LINK_SCHEMES.firstOrNull { href.startsWith(it, ignoreCase = true) }
+                            ?: return@let
+                        // Intent filters match the scheme case-sensitively.
+                        openLink = scheme + href.substring(scheme.length) to out.length
+                    }
+            }
+            else -> if (name in BLOCK_TAGS) lineBreak()
+        }
+        if (name == "pre") preDepth++
+        STYLE_TAGS[name]?.let { openStyles += name to out.length }
+    }
+
+    private fun close(name: String) {
+        // A row's last cell, if empty, leaves a separator pending; it ends with the row.
+        if (name == "tr" || name == "table") cellNeedsSeparator = false
+        val index = openStyles.indexOfLast { it.first == name }
+        if (index >= 0) {
+            val (_, start) = openStyles.removeAt(index)
+            if (out.length > start) styles += StyleRange(start, out.length, STYLE_TAGS.getValue(name))
+        }
+        if (name == "pre") preDepth = (preDepth - 1).coerceAtLeast(0)
+        if (name == "li" || name == "ul" || name == "ol") {
+            if (out.length == markerEnd) cut(out.lastIndexOf("\n") + 1)
+            markerEnd = -1
+        }
+        when (name) {
+            "ul", "ol" -> {
+                lists.removeLastOrNull()
+                lineBreak()
+            }
+            "a" -> closeLink()
+            else -> if (name in BLOCK_TAGS) lineBreak()
+        }
+    }
+
+    private fun closeLink() {
+        val (url, start) = openLink ?: return
+        if (out.length > start) links += LinkRange(start, out.length, url)
+        openLink = null
+    }
+
+    private fun text(raw: String) {
+        val decoded = decodeEntities(raw)
+        if (preDepth > 0) {
+            out.append(decoded.replace("\r\n", "\n"))
+            return
+        }
+        for (c in decoded) {
+            if (c == '\n' && keepNewlines) {
+                newline()
+            } else if (c == ' ' || c == '\n' || c == '\t' || c == '\r' || c == '\u000C') {
+                if (out.isNotEmpty() && out.last() != ' ' && out.last() != '\n') out.append(' ')
+            } else {
+                if (cellNeedsSeparator && c.isContent()) separateCell()
+                out.append(c)
+            }
+        }
+    }
+
+    /** Put this cell's text beside the row's last, even after a block in that cell ended its line. */
+    private fun separateCell() {
+        cellNeedsSeparator = false
+        var end = out.length
+        while (end > rowStart && !out[end - 1].isContent()) end--
+        cut(end)
+        out.append(CELL_SEPARATOR)
+        openStyles.replaceAll { (name, start) -> name to if (start >= end) out.length else start }
+        openLink = openLink?.let { (url, start) -> url to if (start >= end) out.length else start }
+    }
+
+    private fun Char.isContent() = !isWhitespace() && this != NBSP
+
+    private fun newline() {
+        trimTrailingSpaces()
+        out.append('\n')
+    }
+
+    /** End the current line, unless it's already ended or holds just a bullet. */
+    private fun lineBreak() {
+        if (out.length == markerEnd) return
+        trimTrailingSpaces()
+        if (out.isNotEmpty() && out.last() != '\n') out.append('\n')
+    }
+
+    private fun trimTrailingSpaces() {
+        while (out.isNotEmpty() && out.last() == ' ') out.setLength(out.length - 1)
+    }
+
+    /** Drop the output from [length] on, with whatever formatting lay only there. */
+    private fun cut(length: Int) {
+        if (length >= out.length) return
+        out.setLength(length)
+        styles.replaceAll { it.copy(end = minOf(it.end, length)) }
+        styles.removeAll { it.end <= it.start }
+        links.replaceAll { it.copy(end = minOf(it.end, length)) }
+        links.removeAll { it.end <= it.start }
+        openStyles.replaceAll { (name, start) -> name to minOf(start, length) }
+        openLink = openLink?.let { (url, start) -> url to minOf(start, length) }
+    }
+
+    /**
+     * Tidy the rendered text: no-break spaces become plain, lines lose trailing
+     * blanks, runs of empty lines shrink to one and the ends are trimmed. Spans
+     * move with the text they cover.
+     */
+    private fun normalize(): RichText {
+        closeLink()
+        for ((name, start) in openStyles) {
+            if (out.length > start) styles += StyleRange(start, out.length, STYLE_TAGS.getValue(name))
+        }
+        val src = out.toString().replace(NBSP, ' ')
+        val map = IntArray(src.length + 1)
+        val result = StringBuilder()
+        var i = 0
+        while (i < src.length) {
+            var lineEnd = src.indexOf('\n', i)
+            if (lineEnd < 0) lineEnd = src.length
+            var contentEnd = lineEnd
+            while (contentEnd > i && src[contentEnd - 1].isWhitespace()) contentEnd--
+            for (j in i until lineEnd) {
+                map[j] = result.length
+                if (j < contentEnd) result.append(src[j])
+            }
+            if (lineEnd < src.length) {
+                map[lineEnd] = result.length
+                if (!result.endsWith("\n\n")) result.append('\n')
+            }
+            i = lineEnd + 1
+        }
+        map[src.length] = result.length
+        val leading = result.length - result.trimStart().length
+        val text = result.trim().toString()
+        fun at(index: Int) = (map[index] - leading).coerceIn(0, text.length)
+        return RichText(
+            text = text,
+            styles = styles.mapNotNull { r -> StyleRange(at(r.start), at(r.end), r.style).takeIf { it.end > it.start } },
+            links = links.mapNotNull { r -> LinkRange(at(r.start), at(r.end), r.url).takeIf { it.end > it.start } },
+        )
+    }
+}
+
+private val startRegex = Regex("""(?:^|\s)start\s*=\s*["']?(-?\d{1,6})""", RegexOption.IGNORE_CASE)
+private val hrefRegex = Regex("""(?:^|\s)href\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))""", RegexOption.IGNORE_CASE)
+
+// Latin-1 (&nbsp; … &yuml;) in code point order, then the common extras.
+private val LATIN1_ENTITIES = ("nbsp iexcl cent pound curren yen brvbar sect uml copy ordf laquo not shy reg macr " +
+        "deg plusmn sup2 sup3 acute micro para middot cedil sup1 ordm raquo frac14 frac12 frac34 iquest " +
+        "Agrave Aacute Acirc Atilde Auml Aring AElig Ccedil Egrave Eacute Ecirc Euml Igrave Iacute Icirc Iuml " +
+        "ETH Ntilde Ograve Oacute Ocirc Otilde Ouml times Oslash Ugrave Uacute Ucirc Uuml Yacute THORN szlig " +
+        "agrave aacute acirc atilde auml aring aelig ccedil egrave eacute ecirc euml igrave iacute icirc iuml " +
+        "eth ntilde ograve oacute ocirc otilde ouml divide oslash ugrave uacute ucirc uuml yacute thorn yuml").split(' ')
+
+private val ENTITIES: Map<String, String> = LATIN1_ENTITIES.withIndex()
+    .associate { (i, name) -> name to (0xA0 + i).toChar().toString() } + mapOf(
+    "amp" to "&", "lt" to "<", "gt" to ">", "quot" to "\"", "apos" to "'",
+    "ndash" to "–", "mdash" to "—", "hellip" to "…", "bull" to "•",
+    "lsquo" to "‘", "rsquo" to "’", "ldquo" to "“", "rdquo" to "”", "sbquo" to "‚", "bdquo" to "„",
+    "euro" to "€", "trade" to "™", "OElig" to "Œ", "oelig" to "œ", "Scaron" to "Š", "scaron" to "š",
+    "zwnj" to "\u200C", "zwj" to "\u200D", "ensp" to "\u2002", "emsp" to "\u2003", "thinsp" to "\u2009",
+)
+
+// A named reference needs its ";": "?id=5&reg=eu" in a link is a query, not "®".
+private val entityRegex = Regex("""&(?:(#[0-9]{1,7}|#[xX][0-9a-fA-F]{1,6});?|([a-zA-Z][a-zA-Z0-9]{1,31});)""")
+
+/** Decode character references; an unknown name is left as written. */
+internal fun decodeEntities(text: String): String {
+    if ('&' !in text) return text
+    return entityRegex.replace(text) { match ->
+        val name = match.groupValues[2]
+        if (name.isNotEmpty()) return@replace ENTITIES[name] ?: match.value
+        val body = match.groupValues[1]
+        val code = when {
+            body.startsWith("#x", ignoreCase = true) -> body.substring(2).toIntOrNull(16)
+            else -> body.substring(1).toIntOrNull()
+        }
+        if (code == null || code == 0 || !Character.isValidCodePoint(code)) "�" else String(Character.toChars(code))
+    }
+}

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

@@ -4,7 +4,6 @@ import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
-import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Duration.Companion.hours
 import kotlin.time.Instant
@@ -25,13 +24,13 @@ import kotlin.time.Instant
  * the extras lives in `MainActivity.insertFormOrNull`.
  */
 fun buildInsertEventForm(
-    beginMillis: Long?,
-    endMillis: Long?,
-    isAllDay: Boolean,
+    beginMillis: Long? = null,
+    endMillis: Long? = null,
+    isAllDay: Boolean = false,
     title: String?,
     description: String?,
-    location: String?,
-    rrule: String?,
+    location: String? = null,
+    rrule: String? = null,
     zone: TimeZone,
     now: Instant,
 ): EventForm {
@@ -46,16 +45,12 @@ fun buildInsertEventForm(
             ?.let { Instant.fromEpochMilliseconds(it).toLocalDateTime(TimeZone.UTC).date }
             ?.let { exclusive -> maxOf(startDate, LocalDate.fromEpochDays(exclusive.toEpochDays() - 1)) }
             ?: startDate
-        LocalDateTime(startDate, LocalTime(9, 0)) to LocalDateTime(endDate, LocalTime(10, 0))
+        FormTime(LocalDateTime(startDate, LocalTime(9, 0))) to FormTime(LocalDateTime(endDate, LocalTime(10, 0)))
     } else {
-        val startTime = beginMillis
-            ?.let { Instant.fromEpochMilliseconds(it).toLocalDateTime(zone) }
-            ?: nextFullHour(now, zone)
-        val endTime = endMillis
-            ?.let { Instant.fromEpochMilliseconds(it).toLocalDateTime(zone) }
-            ?.takeIf { it >= startTime }
-            ?: (startTime.toInstant(zone) + 1.hours).toLocalDateTime(zone)
-        startTime to endTime
+        val startAt = beginMillis?.let(Instant::fromEpochMilliseconds) ?: nextFullHour(now)
+        val endAt = endMillis?.let(Instant::fromEpochMilliseconds)?.takeIf { it >= startAt }
+            ?: (startAt + 1.hours)
+        startAt.toFormTime(zone) to endAt.toFormTime(zone)
     }
     return EventForm(
         calendarId = null,
@@ -71,8 +66,34 @@ fun buildInsertEventForm(
     )
 }
 
-private fun nextFullHour(now: Instant, zone: TimeZone): LocalDateTime {
+/** The first full hour after [now]: may roll into the next day before midnight. */
+internal fun nextFullHour(now: Instant): Instant {
     val hourMillis = 3_600_000L
-    val rounded = (now.toEpochMilliseconds() / hourMillis + 1) * hourMillis
-    return Instant.fromEpochMilliseconds(rounded).toLocalDateTime(zone)
+    return Instant.fromEpochMilliseconds((now.toEpochMilliseconds() / hourMillis + 1) * hourMillis)
+}
+
+/** Title and description for text shared or selected into the app (#306). */
+data class SharedText(val title: String, val description: String)
+
+/**
+ * Split shared text into an event title and description: the share's subject
+ * becomes the title and the text the description. Without a subject the text's
+ * first non-blank line is the title and the rest the description. A title longer
+ * than [maxTitle] is cut, and the full text then stays in the description.
+ * Null when there is nothing to use.
+ */
+fun sharedTextOrNull(subject: String?, text: String?, maxTitle: Int = 255): SharedText? {
+    val body = text?.trim().orEmpty()
+    val given = subject?.trim()?.takeIf { it.isNotEmpty() }
+    val (title, rest) = if (given != null) {
+        given to body
+    } else {
+        val lines = body.lines()
+        val first = lines.firstOrNull()?.trim()?.takeIf { it.isNotEmpty() } ?: return null
+        first to lines.drop(1).joinToString("\n").trim()
+    }
+    if (title.length <= maxTitle) return SharedText(title, rest)
+    val cut = title.take(maxTitle).let { if (it.last().isHighSurrogate()) it.dropLast(1) else it }
+    val full = if (given != null) listOf(given, body).filter { it.isNotEmpty() }.joinToString("\n\n") else body
+    return SharedText(cut.trimEnd(), full)
 }

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

@@ -165,6 +165,17 @@ data class EventDetail(
     val isException: Boolean = false,
 )
 
+/**
+ * This event on one occurrence's times. The Events row holds the series start,
+ * so a recurring event needs the tapped occurrence pinned to render and share right.
+ */
+fun EventDetail.atOccurrence(beginMillis: Long, endMillis: Long): EventDetail = copy(
+    instance = instance.copy(
+        start = Instant.fromEpochMilliseconds(beginMillis),
+        end = Instant.fromEpochMilliseconds(endMillis),
+    ),
+)
+
 /**
  * One selectable event colour published by a calendar's account
  * (`CalendarContract.Colors`, `TYPE_EVENT`): [key] is the account-scoped

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

@@ -157,14 +157,36 @@ fun timeZoneOptionOf(
  * the offset isn't stated twice in ICU's spelling and ours.
  */
 fun zoneDescriptor(option: TimeZoneOption): String {
-    val abbrev = option.shortName
-    return when {
-        abbrev == "UTC" -> "UTC"
-        abbrev.startsWith("GMT") -> formatGmtOffset(option.offsetMinutes)
-        else -> "$abbrev · ${formatGmtOffset(option.offsetMinutes)}"
-    }
+    val name = zoneAbbreviation(option)
+    val statesOffset = option.shortName == "UTC" || option.shortName.startsWith("GMT")
+    return if (statesOffset) name else "$name · ${formatGmtOffset(option.offsetMinutes)}"
 }
 
+/**
+ * [option]'s short name on its own — "CEST", "UTC" — with an offset-shaped one
+ * normalised to our GMT form, as [zoneDescriptor] spells it.
+ */
+fun zoneAbbreviation(option: TimeZoneOption): String = abbreviation(option.shortName, option.offsetMinutes)
+
+/**
+ * Zone [id]'s abbreviation [at] an instant, as [zoneAbbreviation] spells it,
+ * without the localized long name a whole [TimeZoneOption] would look up. Null
+ * for an id the tz database can't parse.
+ */
+fun zoneAbbreviationAt(
+    id: String,
+    locale: Locale,
+    at: Instant,
+    regionOf: (String) -> String? = { null },
+): String? {
+    val zone = runCatching { ZoneId.of(id) }.getOrNull() ?: return null
+    val shortName = resolveAbbreviation(zone.id, zone.rules.isDaylightSavings(at), locale, regionOf)
+    return abbreviation(shortName, zone.rules.getOffset(at).totalSeconds / 60)
+}
+
+private fun abbreviation(shortName: String, offsetMinutes: Int): String =
+    if (shortName.startsWith("GMT")) formatGmtOffset(offsetMinutes) else shortName
+
 /**
  * [options] matching [query], best matches first; a blank query returns the list
  * unchanged. Matching is accent- and case-insensitive and treats underscores as

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

@@ -1,6 +1,8 @@
 package de.jeanlucmakiola.calendula.domain.ics
 
 import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.FormTime
+import de.jeanlucmakiola.calendula.domain.toFormTime
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
@@ -24,9 +26,9 @@ fun ParsedIcsEvent.toEventForm(zone: TimeZone): EventForm {
         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))
-        LocalDateTime(startDate, LocalTime(9, 0)) to LocalDateTime(endDate, LocalTime(10, 0))
+        FormTime(LocalDateTime(startDate, LocalTime(9, 0))) to FormTime(LocalDateTime(endDate, LocalTime(10, 0)))
     } else {
-        this.start.toLocalDateTime(zone) to this.end.toLocalDateTime(zone)
+        this.start.toFormTime(zone) to this.end.toFormTime(zone)
     }
     return EventForm(
         calendarId = null,

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

@@ -19,6 +19,7 @@ import androidx.compose.material3.Scaffold
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.rememberDrawerState
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
 import androidx.compose.runtime.setValue
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
@@ -29,6 +30,7 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 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.screen
 import de.jeanlucmakiola.calendula.ui.common.ViewScreen
@@ -60,6 +62,8 @@ import de.jeanlucmakiola.calendula.ui.common.EventMoveHost
 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.rememberWriteGateOr
 import de.jeanlucmakiola.calendula.ui.common.EventMoveScope
 import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
 import de.jeanlucmakiola.calendula.ui.common.LocalManageCalendars
@@ -80,6 +84,7 @@ import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.common.selectView
 import de.jeanlucmakiola.calendula.ui.common.viewBaseStack
 import de.jeanlucmakiola.calendula.ui.detail.EventDetailScreen
+import de.jeanlucmakiola.calendula.ui.edit.EventEditViewModel
 import de.jeanlucmakiola.calendula.ui.edit.EventEditScreen
 import de.jeanlucmakiola.calendula.ui.edit.ImportSource
 import de.jeanlucmakiola.calendula.ui.imports.ImportScreen
@@ -95,6 +100,7 @@ import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toLocalDateTime
 import kotlin.coroutines.cancellation.CancellationException
 import kotlin.time.Clock
+import kotlin.time.Instant
 
 /**
  * Holds the top-level view back stack (spec M1) and swaps between the calendar
@@ -130,6 +136,7 @@ fun CalendarHost(
     requestedInsertForm: EventForm? = null,
     requestedInsertSource: ImportSource = ImportSource.Insert,
     onInsertConsumed: () -> Unit = {},
+    onExternalFormClosed: () -> Unit = {},
     requestedEditKey: LongArray? = null,
     onEditKeyConsumed: () -> Unit = {},
     viewModel: CalendarHostViewModel = hiltViewModel(),
@@ -192,7 +199,7 @@ fun CalendarHost(
     // placeholder — so the destination never loads a bogus id=0 on first frame.
     var detailKey by rememberSaveable { mutableStateOf<LongArray?>(null) }
     var heldKey by remember { mutableStateOf<LongArray?>(null) }
-    val onEventClick: (EventInstance) -> Unit = { event ->
+    val onOpenDetail: (EventInstance) -> Unit = { event ->
         val key = longArrayOf(
             event.eventId,
             event.start.toEpochMilliseconds(),
@@ -239,11 +246,23 @@ fun CalendarHost(
     var heldCreateIso by remember { mutableStateOf<String?>(null) }
     var createStartMinutes by rememberSaveable { mutableStateOf<Int?>(null) }
     var heldCreateMinutes by remember { mutableStateOf<Int?>(null) }
-    val onCreateEvent: (LocalDate, Int?) -> Unit = { date, startMinutes ->
+    // 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
+    }
+    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, null, longArrayOf(start.toEpochMilliseconds(), end.toEpochMilliseconds()))
     }
 
     // Edit form (v1.3) — reuses the detail screen's occurrence key; for
@@ -263,6 +282,34 @@ fun CalendarHost(
     // 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 remember { mutableStateOf(ImportSource.File) }
+    // Bumped per open, so even an equal prefill starts a fresh form.
+    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 importViewModel: EventEditViewModel = hiltViewModel(key = "import")
+    fun openImportForm(form: EventForm, source: ImportSource, fromRequest: Boolean = false) {
+        importFormSource = source
+        importForm = form
+        importFormId++
+        importFromRequest = fromRequest
+    }
+    fun closeImportForm() {
+        val next = pendingInsert
+        pendingInsert = null
+        if (next != null) {
+            openImportForm(next.first, next.second, fromRequest = true)
+        } else {
+            importForm = null
+            if (importFromRequest) {
+                importFromRequest = false
+                onExternalFormClosed()
+            }
+        }
+    }
     // A restore (in-app "Restore from .ics" button) always runs the full import
     // 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
@@ -292,8 +339,11 @@ fun CalendarHost(
     // reveals on top of whatever was open without extra dismissal.
     LaunchedEffect(requestedInsertForm) {
         if (requestedInsertForm != null) {
-            importFormSource = requestedInsertSource
-            importForm = requestedInsertForm
+            if (importForm == null) {
+                openImportForm(requestedInsertForm, requestedInsertSource, fromRequest = true)
+            } else {
+                pendingInsert = requestedInsertForm to requestedInsertSource
+            }
             onInsertConsumed()
         }
     }
@@ -309,6 +359,9 @@ fun CalendarHost(
         editKey = null
         importUri = null
         importForm = null
+        importFromRequest = false
+        pendingInsert = null
+        importViewModel.reset()
     }
 
     // An external "edit this event" (ACTION_EDIT, e.g. an assistant/task app or
@@ -380,6 +433,8 @@ fun CalendarHost(
                 createDateIso = iso
                 heldCreateMinutes = null
                 createStartMinutes = null
+                heldCreateDraftMillis = null
+                createDraftMillis = null
                 onWidgetNavConsumed()
             }
             null -> {}
@@ -402,6 +457,28 @@ fun CalendarHost(
         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) }
+    val onEventClick: (EventInstance) -> Unit = { event ->
+        tapScope.launch {
+            val toEditor = viewModel.tapOpensEditor() && eventActions.canModify(event.calendarId)
+            when {
+                !toEditor -> onOpenDetail(event)
+                tapContext.canWriteCalendar() -> onEditEvent(event)
+                tapWriteRefused -> onOpenDetail(event)
+                else -> requireWriteOr({ onEditEvent(event) }) {
+                    tapWriteRefused = true
+                    onOpenDetail(event)
+                }
+            }
+        }
+    }
     // Off by preference (#173) switches off the gesture, not the scope: blocks
     // register no drag, while the edit form and its TalkBack action stay put.
     val dragToReschedule = viewModel.dragToReschedule.collectAsStateWithLifecycle().value
@@ -542,8 +619,7 @@ fun CalendarHost(
                     onEdit = onEditEvent,
                     onDuplicate = { form ->
                         // A fresh event, like a duplicate from the detail screen (#52).
-                        importFormSource = ImportSource.Insert
-                        importForm = form
+                        openImportForm(form, ImportSource.Insert)
                     },
                     chipShown = moveOutcome != null || selectionFailure != null,
                     onDismissChip = {
@@ -583,6 +659,7 @@ fun CalendarHost(
                     onOpenDay = onOpenDay,
                     onEventClick = onEventClick,
                     onCreateEvent = onCreateEvent,
+                    onCreateDraft = onCreateDraft,
                 )
                 ViewScreen.Month -> MonthScreen(
                     onOpenDay = onOpenDay,
@@ -652,8 +729,7 @@ fun CalendarHost(
                         // Reuse the prefilled-create overlay: a duplicate is a
                         // fresh event, so it applies the default reminder like an
                         // in-app new event (#52).
-                        importFormSource = ImportSource.Insert
-                        importForm = form
+                        openImportForm(form, ImportSource.Insert)
                         detailKey = null
                     },
                     visible = detailKey != null,
@@ -671,10 +747,12 @@ fun CalendarHost(
                 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"),
                 )
             }
         }
@@ -695,7 +773,20 @@ fun CalendarHost(
                         detailKey = null
                     },
                     onManageCalendars = { showCalendars = true },
+                    onDuplicate = { form ->
+                        openImportForm(form, ImportSource.Insert)
+                    },
+                    // Opened straight from a tap (#178) there's no detail screen
+                    // below to show why, so open it.
+                    onLoadFailed = {
+                        editKey = null
+                        if (detailKey == null) {
+                            heldKey = key
+                            detailKey = key
+                        }
+                    },
                     visible = editKey != null,
+                    viewModel = hiltViewModel(key = "edit"),
                 )
             }
         }
@@ -741,20 +832,24 @@ fun CalendarHost(
                     importUri = null
                     calendarsAfterImport = false
                     backupAfterImport = false
-                    importFormSource = ImportSource.File
-                    importForm = form
+                    openImportForm(form, ImportSource.File)
                 },
             )
         }
         importForm?.let { form ->
-            EventEditScreen(
-                initialDateIso = null,
-                initialForm = form,
-                initialFormSource = importFormSource,
-                onClose = { importForm = null },
-                onSaved = { importForm = null },
-                onManageCalendars = { showCalendars = true },
-            )
+            key(importFormId) {
+                EventEditScreen(
+                    initialDateIso = null,
+                    initialForm = form,
+                    initialFormSource = importFormSource,
+                    onClose = ::closeImportForm,
+                    onSaved = ::closeImportForm,
+                    onManageCalendars = { showCalendars = true },
+                    leaveRequested = pendingInsert != null,
+                    onLeaveDeclined = { pendingInsert = null },
+                    viewModel = importViewModel,
+                )
+            }
         }
 
         // Declared last so it covers every overlay that can open it: Settings,

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

@@ -11,6 +11,7 @@ import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 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
@@ -78,4 +79,9 @@ class CalendarHostViewModel @Inject constructor(
             started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = false,
         )
+
+    private val tapOpensEditorPref = prefs.tapOpensEditor
+
+    /** Whether tapping an event opens the edit form rather than the detail screen (#178). */
+    suspend fun tapOpensEditor(): Boolean = tapOpensEditorPref.first()
 }

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

@@ -54,6 +54,7 @@ fun RootScreen(
     requestedInsertSource: de.jeanlucmakiola.calendula.ui.edit.ImportSource =
         de.jeanlucmakiola.calendula.ui.edit.ImportSource.Insert,
     onInsertConsumed: () -> Unit = {},
+    onExternalFormClosed: () -> Unit = {},
     requestedEditKey: LongArray? = null,
     onEditKeyConsumed: () -> Unit = {},
 ) {
@@ -155,6 +156,7 @@ fun RootScreen(
                 requestedInsertForm = requestedInsertForm,
                 requestedInsertSource = requestedInsertSource,
                 onInsertConsumed = onInsertConsumed,
+                onExternalFormClosed = onExternalFormClosed,
                 requestedEditKey = requestedEditKey,
                 onEditKeyConsumed = onEditKeyConsumed,
             )

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

@@ -2,7 +2,6 @@ package de.jeanlucmakiola.calendula.ui.agenda
 
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
@@ -39,6 +38,7 @@ import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.ui.common.formatTimeOfDay
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.Position
+import de.jeanlucmakiola.floret.identity.LocalFloretDarkTheme
 import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.floret.locale.localizedDateFormatter
 import kotlinx.datetime.DateTimeUnit
@@ -127,7 +127,7 @@ internal fun AgendaEventRow(
     modifier: Modifier = Modifier,
     onClick: () -> Unit,
 ) {
-    val dark = isSystemInDarkTheme()
+    val dark = LocalFloretDarkTheme.current
     val soften = LocalSoftenColors.current
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
     GroupedRow(

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

@@ -6,7 +6,6 @@ import android.content.Intent
 import android.provider.Settings
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -95,6 +94,7 @@ import de.jeanlucmakiola.calendula.ui.common.LeadingAvatar
 import de.jeanlucmakiola.calendula.ui.common.SourceLogo
 import de.jeanlucmakiola.calendula.ui.common.curatedSourcePackage
 import de.jeanlucmakiola.floret.components.CollapsingScaffold
+import de.jeanlucmakiola.floret.identity.LocalFloretDarkTheme
 import de.jeanlucmakiola.floret.identity.collapseExit
 import de.jeanlucmakiola.floret.identity.expandEnter
 import de.jeanlucmakiola.floret.identity.predictiveBack
@@ -478,7 +478,7 @@ private fun CalendarNameField(
     onNameChange: (String) -> Unit,
     onImeAction: () -> Unit,
 ) {
-    val dark = isSystemInDarkTheme()
+    val dark = LocalFloretDarkTheme.current
     val soften = LocalSoftenColors.current
     GroupedSurface(position = Position.Alone, modifier = Modifier.padding(horizontal = 16.dp)) {
         Row(
@@ -522,7 +522,7 @@ private fun CalendarNameField(
  */
 @Composable
 private fun CalendarColorGrid(selected: Int, onSelect: (Int) -> Unit) {
-    val dark = isSystemInDarkTheme()
+    val dark = LocalFloretDarkTheme.current
     val soften = LocalSoftenColors.current
     GroupedSurface(position = Position.Alone, modifier = Modifier.padding(horizontal = 16.dp)) {
         Column(

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

@@ -278,12 +278,23 @@ data class BlockPlacement(val xFraction: Float, val widthFraction: Float, val y:
  * A pinch-zoom rewrites the hour height every pointer frame, and the gutter and
  * grid lines follow it instantly — so the tween stands down for the gesture
  * rather than leaving the blocks trailing the ruler they are measured against.
+ * A [landing] block, under a dropped copy, moves without the spring's bounce.
  */
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun animatedBlockPlacement(xFraction: Float, widthFraction: Float, y: Dp, height: Dp): BlockPlacement {
+fun animatedBlockPlacement(
+    xFraction: Float,
+    widthFraction: Float,
+    y: Dp,
+    height: Dp,
+    landing: Boolean = false,
+): BlockPlacement {
     val still = rememberReduceMotion() || LocalTimelineZoom.current.isPinching
-    val dpSpec: FiniteAnimationSpec<Dp> = if (still) snap() else MaterialTheme.motionScheme.fastSpatialSpec()
+    val dpSpec: FiniteAnimationSpec<Dp> = when {
+        still -> snap()
+        landing -> MaterialTheme.motionScheme.fastEffectsSpec()
+        else -> MaterialTheme.motionScheme.fastSpatialSpec()
+    }
     val shareSpec: FiniteAnimationSpec<Float> = if (still) snap() else MaterialTheme.motionScheme.fastSpatialSpec()
     val animatedX by animateFloatAsState(xFraction, shareSpec, label = "block-x")
     val animatedWidth by animateFloatAsState(widthFraction, shareSpec, label = "block-width")

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

@@ -69,9 +69,15 @@ class ScreenActions(
 /**
  * An event a long press left selected (#141), which the host answers with the
  * action bar in place of the FAB. [dismiss] clears it on the screen that owns it.
+ * [create] is set for a block drafted on an empty slot (#153), which has no
+ * event yet, so the bar offers to create one.
  */
 @Stable
-class EventSelection(val event: EventInstance, val dismiss: () -> Unit)
+class EventSelection(
+    val event: EventInstance,
+    val dismiss: () -> Unit,
+    val create: (() -> Unit)? = null,
+)
 
 /** The screen on show's [ScreenChrome] and [ScreenActions], for the host to draw. */
 @Stable
@@ -114,10 +120,26 @@ fun PublishChrome(chrome: ScreenChrome, actions: ScreenActions) {
 
 /** Hands the screen's selected [event] to the host, for as long as it stays selected. */
 @Composable
-fun PublishSelection(event: EventInstance?, busy: Boolean, compact: Boolean, onDismiss: () -> Unit) {
+fun PublishSelection(
+    event: EventInstance?,
+    busy: Boolean,
+    compact: Boolean,
+    onDismiss: () -> Unit,
+    onCreate: (() -> Unit)? = null,
+) {
     val slot = LocalChromeSlot.current ?: return
     val currentDismiss by rememberUpdatedState(onDismiss)
-    val selection = remember(event) { event?.let { EventSelection(it) { currentDismiss() } } }
+    val currentCreate by rememberUpdatedState(onCreate)
+    val drafted = onCreate != null
+    val selection = remember(event, drafted) {
+        event?.let {
+            EventSelection(
+                event = it,
+                dismiss = { currentDismiss() },
+                create = if (drafted) ({ currentCreate?.invoke() }) else null,
+            )
+        }
+    }
     val host = slot.host
     val current = slot.current
     DisposableEffect(host, selection, current) {

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

@@ -1,7 +1,6 @@
 package de.jeanlucmakiola.calendula.ui.common
 
 import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
@@ -14,6 +13,7 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.floret.identity.LocalFloretDarkTheme
 
 /**
  * Leading avatar for a calendar: a neutral chip holding a calendar glyph tinted
@@ -23,7 +23,7 @@ import androidx.compose.ui.unit.dp
  */
 @Composable
 fun CalendarColorChip(color: Int, modifier: Modifier = Modifier) {
-    val dark = isSystemInDarkTheme()
+    val dark = LocalFloretDarkTheme.current
     val soften = LocalSoftenColors.current
     Box(
         modifier = modifier

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

@@ -2,14 +2,16 @@ package de.jeanlucmakiola.calendula.ui.common
 
 import android.content.ClipData
 import android.os.Build
-import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.input.pointer.PointerEventPass
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.platform.ClipEntry
 import androidx.compose.ui.platform.LocalClipboard
@@ -67,9 +69,12 @@ fun rememberFieldCopier(snackbarHostState: SnackbarHostState): FieldCopier {
  *
  * [onTap] carries a field's existing tap action through, announced as
  * [onTapLabel]; a field without one stays unclickable rather than growing a
- * ripple that leads nowhere, and gets its long press announced through semantics instead. That branch merges the
- * node it sits on, so a screen reader lands on the field itself and finds the
- * action there — a bare container is never focused.
+ * ripple that leads nowhere. The long press is announced through semantics,
+ * merging the node it sits on, so a screen reader lands on the field itself
+ * and finds the action there — a bare container is never focused.
+ *
+ * The press is caught ahead of the field's children, so a long press on a
+ * link inside the text copies too instead of leaving that stretch dead.
  */
 @Composable
 fun Modifier.copyOnLongPress(
@@ -80,27 +85,45 @@ fun Modifier.copyOnLongPress(
     onTapLabel: String? = null,
 ): Modifier {
     val actionLabel = stringResource(R.string.field_copy_action)
-    return if (onTap != null) {
-        combinedClickable(
-            onClick = onTap,
-            onClickLabel = onTapLabel,
-            onLongClickLabel = actionLabel,
-            onLongClick = { copy(label, text) },
-        )
-    } else {
-        val haptics = LocalHapticFeedback.current
-        pointerInput(label, text, copy) {
-            detectTapGestures(
-                onLongPress = {
-                    haptics.performHapticFeedback(HapticFeedbackType.LongPress)
-                    copy(label, text)
-                },
-            )
-        }.semantics(mergeDescendants = true) {
+    val haptics = LocalHapticFeedback.current
+    return longPressAheadOfChildren(label, text, copy) {
+        haptics.performHapticFeedback(HapticFeedbackType.LongPress)
+        copy(label, text)
+    }
+        .then(if (onTap != null) Modifier.clickable(onClickLabel = onTapLabel, onClick = onTap) else Modifier)
+        .semantics(mergeDescendants = true) {
             onLongClick(actionLabel) {
                 copy(label, text)
                 true
             }
         }
-    }
 }
+
+/**
+ * Run [onLongPress] once a press has held still for the long-press timeout,
+ * watching on the initial pass — before the children see the events — and
+ * then swallow the rest of that press, so neither a link under the finger nor
+ * a tap handler fires on release.
+ */
+private fun Modifier.longPressAheadOfChildren(vararg keys: Any?, onLongPress: () -> Unit): Modifier =
+    pointerInput(*keys) {
+        awaitEachGesture {
+            val down = awaitFirstDown(requireUnconsumed = false, pass = PointerEventPass.Initial)
+            val endedEarly = withTimeoutOrNull(viewConfiguration.longPressTimeoutMillis) {
+                while (true) {
+                    val change = awaitPointerEvent(PointerEventPass.Initial).changes
+                        .firstOrNull { it.id == down.id }
+                    val moved = change != null &&
+                        (change.position - down.position).getDistance() > viewConfiguration.touchSlop
+                    if (change == null || !change.pressed || moved) break
+                }
+                true
+            }
+            if (endedEarly != null) return@awaitEachGesture
+            onLongPress()
+            do {
+                val event = awaitPointerEvent(PointerEventPass.Initial)
+                event.changes.forEach { it.consume() }
+            } while (event.changes.any { it.pressed })
+        }
+    }

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

@@ -5,6 +5,7 @@ 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
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.foundation.layout.Arrangement
@@ -25,12 +26,14 @@ 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
 import de.jeanlucmakiola.calendula.data.ics.IcsExporter
 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.components.OptionCard
+import kotlin.coroutines.cancellation.CancellationException
 import kotlin.time.Clock
 
 /**
@@ -67,6 +70,33 @@ suspend fun CalendarRepository.deleteEvent(
     RecurringWriteScope.ThisAndFollowing -> deleteEventFromOccurrence(eventId, beginMillis)
 }
 
+/** How a [tryDeleteEvent] ended. */
+enum class DeleteOutcome { Deleted, Gone, NeedsPermission, Failed }
+
+/** Whether this install may write to the calendar; v1.0 installs only hold read access. */
+fun Context.canWriteCalendar(): Boolean =
+    ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_CALENDAR) ==
+        PackageManager.PERMISSION_GRANTED
+
+/** [deleteEvent], with the provider's failures mapped to a [DeleteOutcome]. */
+suspend fun CalendarRepository.tryDeleteEvent(
+    eventId: Long,
+    beginMillis: Long,
+    scope: RecurringWriteScope,
+): DeleteOutcome = try {
+    deleteEvent(eventId, beginMillis, scope)
+    DeleteOutcome.Deleted
+} catch (e: CancellationException) {
+    throw e
+} catch (e: SecurityException) {
+    DeleteOutcome.NeedsPermission
+} catch (e: NoSuchEventException) {
+    DeleteOutcome.Gone
+} catch (e: Exception) {
+    Log.w("EventActions", "Delete failed (scope=$scope, eventId=$eventId)", e)
+    DeleteOutcome.Failed
+}
+
 /**
  * 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
@@ -74,23 +104,26 @@ suspend fun CalendarRepository.deleteEvent(
  */
 @Composable
 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
-    var pending by remember { mutableStateOf<(() -> Unit)?>(null) }
+    var pending by remember { mutableStateOf<Pair<() -> Unit, () -> Unit>?>(null) }
     val launcher = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.RequestPermission(),
     ) { granted ->
-        if (granted) pending?.invoke()
+        pending?.let { (action, fallback) -> if (granted) action() else fallback() }
         pending = null
     }
-    return { action ->
-        val granted = ContextCompat.checkSelfPermission(
-            context,
-            Manifest.permission.WRITE_CALENDAR,
-        ) == PackageManager.PERMISSION_GRANTED
-        if (granted) {
+    return { action, fallback ->
+        if (context.canWriteCalendar()) {
             action()
         } else {
-            pending = action
+            pending = action to fallback
             launcher.launch(Manifest.permission.WRITE_CALENDAR)
         }
     }

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

@@ -13,6 +13,7 @@ import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.EventForm
 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 kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -20,6 +21,7 @@ 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
@@ -87,17 +89,11 @@ class EventActionsViewModel @Inject constructor(
         _deletePrompt.value = null
         viewModelScope.launch {
             val event = prompt.event
-            _failure.value = try {
-                repository.deleteEvent(event.eventId, event.start.toEpochMilliseconds(), scope)
-                null
-            } catch (e: CancellationException) {
-                throw e
-            } catch (e: SecurityException) {
-                EventActionFailure.WriteDenied
-            } catch (e: NoSuchEventException) {
-                EventActionFailure.Gone
-            } catch (e: Exception) {
-                EventActionFailure.DeleteFailed
+            _failure.value = when (repository.tryDeleteEvent(event.eventId, event.start.toEpochMilliseconds(), scope)) {
+                DeleteOutcome.Deleted -> null
+                DeleteOutcome.Gone -> EventActionFailure.Gone
+                DeleteOutcome.NeedsPermission -> EventActionFailure.WriteDenied
+                DeleteOutcome.Failed -> EventActionFailure.DeleteFailed
             }
         }
     }
@@ -115,10 +111,22 @@ class EventActionsViewModel @Inject constructor(
         _failure.value = null
     }
 
+    /** Whether [calendarId] takes writes, asking the provider while [calendars] hasn't loaded yet. */
+    suspend fun canModify(calendarId: Long): Boolean {
+        val calendar = calendars.value[calendarId] ?: try {
+            repository.calendars().first().firstOrNull { it.id == calendarId }
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            null
+        }
+        return calendar?.canModifyContents == true
+    }
+
     private suspend fun load(event: EventInstance): EventDetail? = try {
-        val detail = repository.eventDetail(event.eventId)
         // The row holds the series start; the actions work on this occurrence.
-        detail.copy(instance = detail.instance.copy(start = event.start, end = event.end))
+        repository.eventDetail(event.eventId)
+            .atOccurrence(event.start.toEpochMilliseconds(), event.end.toEpochMilliseconds())
     } catch (e: CancellationException) {
         throw e
     } catch (e: NoSuchEventException) {

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

@@ -73,7 +73,8 @@ fun rememberEventDragSource(
  * The same pickup, for a surface that carries many draggable pieces rather than
  * being one itself — the month grid, whose chips are covered by a full-bleed tap
  * layer. [onPickUp] receives the press position local to this node and answers
- * whether anything is there; false abandons the gesture.
+ * whether anything is there; false abandons the gesture. [skipClaimedDown] leaves
+ * a press a descendant already consumed alone.
  */
 @Composable
 fun rememberDragSurface(
@@ -83,6 +84,8 @@ fun rememberDragSurface(
     onMove: (pointerInRoot: Offset) -> Unit,
     onDrop: () -> Unit,
     onCancel: () -> Unit,
+    onRelease: (() -> Unit)? = null,
+    skipClaimedDown: Boolean = false,
 ): Modifier = rememberPickUpSurface(
     enabled = enabled,
     key = key,
@@ -93,7 +96,8 @@ fun rememberDragSurface(
     onMove = onMove,
     onDrop = onDrop,
     onCancel = onCancel,
-    onRelease = null,
+    onRelease = onRelease,
+    skipClaimedDown = skipClaimedDown,
 )
 
 @Composable
@@ -106,6 +110,7 @@ private fun rememberPickUpSurface(
     onDrop: () -> Unit,
     onCancel: () -> Unit,
     onRelease: (() -> Unit)?,
+    skipClaimedDown: Boolean = false,
 ): Modifier {
     if (!enabled) return Modifier
     val holdMillis = LocalViewConfiguration.current.longPressTimeoutMillis
@@ -125,6 +130,8 @@ private fun rememberPickUpSurface(
             val slop = viewConfiguration.touchSlop
             awaitEachGesture {
                 val down = awaitFirstDown(requireUnconsumed = false)
+                // A child that took the press, such as a resize handle, keeps it.
+                if (skipClaimedDown && down.isConsumed) return@awaitEachGesture
                 val origin = down.position
                 val immediate = currentImmediate
                 // Null: held still. True: an immediate pickup past slop. False: abandoned.

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

@@ -5,6 +5,8 @@ import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.filled.Close
 import androidx.compose.material.icons.filled.ContentCopy
 import androidx.compose.material.icons.filled.Delete
 import androidx.compose.material.icons.filled.Edit
@@ -52,6 +54,26 @@ fun EventSelectionBar(
     }
 }
 
+/** A drafted block's bar (#153): create the event, or let the draft go. */
+@Composable
+fun DraftSelectionBar(onCreate: () -> Unit, onDiscard: () -> Unit, modifier: Modifier = Modifier) {
+    Surface(
+        shape = CircleShape,
+        color = MaterialTheme.colorScheme.primaryContainer,
+        contentColor = MaterialTheme.colorScheme.onPrimaryContainer,
+        shadowElevation = 6.dp,
+        modifier = modifier.height(FabSize),
+    ) {
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            modifier = Modifier.padding(horizontal = 4.dp),
+        ) {
+            BarAction(Icons.Default.Close, R.string.event_draft_discard, onDiscard)
+            BarAction(Icons.Default.Check, R.string.event_draft_create, onCreate)
+        }
+    }
+}
+
 @Composable
 private fun BarAction(icon: ImageVector, label: Int, onClick: () -> Unit) {
     IconButton(onClick = onClick) {

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

@@ -47,6 +47,23 @@ fun rememberFabSelection(
     val currentWrite by rememberUpdatedState(requireWrite)
 
     val selection = host.selection ?: return null
+    selection.create?.let { create ->
+        return remember(selection, expanded, chipShown) {
+            FabSelection(
+                expanded = expanded,
+                onToggle = {
+                    if (chipShown) currentDismissChip()
+                    chosen = !expanded
+                },
+                bar = {
+                    DraftSelectionBar(
+                        onCreate = { currentWrite { create() } },
+                        onDiscard = selection.dismiss,
+                    )
+                },
+            )
+        }
+    }
     val event = selection.event
     val calendar = calendars[event.calendarId]
     val canEdit = calendar?.canModifyContents == true

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

@@ -195,15 +195,20 @@ class OutOfViewEdges internal constructor(
         }
     }
 
+    /** Whether a press at [y] (content px) lands on an edge bar (#153). */
+    fun covers(y: Float): Boolean = edgeAt(y) != null
+
+    private fun edgeAt(y: Float) = tappedEdge(
+        events = events,
+        y = y,
+        viewportTop = scrollState.value.toFloat(),
+        viewportPx = scrollState.viewportSize,
+        reachPx = reachPx,
+    )
+
     /** Reveals the hidden event if a tap at [y] (content px) lands on a bar. */
     fun tap(y: Float): Boolean {
-        val edge = tappedEdge(
-            events = events,
-            y = y,
-            viewportTop = scrollState.value.toFloat(),
-            viewportPx = scrollState.viewportSize,
-            reachPx = reachPx,
-        ) ?: return false
+        val edge = edgeAt(y) ?: return false
         reveal(edge)
         return true
     }

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

@@ -3,6 +3,7 @@ package de.jeanlucmakiola.calendula.ui.common
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 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.data.di.IoDispatcher
@@ -16,6 +17,8 @@ import de.jeanlucmakiola.calendula.domain.parseSimpleRecurrence
 import de.jeanlucmakiola.calendula.domain.problems
 import de.jeanlucmakiola.calendula.domain.realignRecurrence
 import de.jeanlucmakiola.calendula.domain.resizedTo
+import de.jeanlucmakiola.calendula.domain.endInstant
+import de.jeanlucmakiola.calendula.domain.startInstant
 import de.jeanlucmakiola.calendula.domain.resolvedZone
 import de.jeanlucmakiola.calendula.domain.shiftedByDays
 import de.jeanlucmakiola.calendula.domain.shiftedTo
@@ -128,6 +131,7 @@ sealed interface MoveOutcome {
 class RescheduleViewModel @Inject constructor(
     private val repository: CalendarRepository,
     @IoDispatcher private val io: CoroutineDispatcher,
+    private val zoneSource: ZoneSource,
 ) : ViewModel() {
 
     private val _scopePrompt = MutableStateFlow<MoveScopePrompt?>(null)
@@ -317,7 +321,7 @@ class RescheduleViewModel @Inject constructor(
             return null
         }
 
-        val zone = TimeZone.currentSystemDefault()
+        val zone = zoneSource.current()
         val original = detail.toEditForm(request.beginMillis, request.endMillis, zone)
         val shifted = when (val target = request.target) {
             is MoveTarget.Start -> original.shiftedTo(target.instant, zone)
@@ -329,7 +333,7 @@ class RescheduleViewModel @Inject constructor(
 
         // The UNTIL check is deferred to the write, which knows how far the move
         // reaches and so which date has to clear it.
-        if ((shifted.problems() - EventFormProblem.RecurrenceEndsBeforeStart).isNotEmpty()) {
+        if ((shifted.problems(zone) - EventFormProblem.RecurrenceEndsBeforeStart).isNotEmpty()) {
             _outcome.value = MoveOutcome.Failed
             return null
         }
@@ -495,8 +499,7 @@ class RescheduleViewModel @Inject constructor(
     private fun resizedEndMillis(prepared: PreparedMove): Long? {
         if (prepared.request.target !is MoveTarget.Span) return null
         val form = prepared.updated
-        return form.end.toInstant(form.resolvedZone(TimeZone.currentSystemDefault()))
-            .toEpochMilliseconds()
+        return form.endInstant(form.resolvedZone(zoneSource.current())).toEpochMilliseconds()
     }
 
     /**
@@ -508,8 +511,7 @@ class RescheduleViewModel @Inject constructor(
         return if (form.isAllDay) {
             form.start.date.atStartOfDayIn(TimeZone.UTC).toEpochMilliseconds()
         } else {
-            form.start.toInstant(form.resolvedZone(TimeZone.currentSystemDefault()))
-                .toEpochMilliseconds()
+            form.startInstant(form.resolvedZone(zoneSource.current())).toEpochMilliseconds()
         }
     }
 

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

@@ -40,7 +40,9 @@ fun SelectionTopBar(selection: EventSelection) {
             IconButton(onClick = selection.dismiss) {
                 Icon(
                     imageVector = Icons.Default.Close,
-                    contentDescription = stringResource(R.string.event_selection_close),
+                    contentDescription = stringResource(
+                        if (selection.create != null) R.string.event_draft_discard else R.string.event_selection_close,
+                    ),
                 )
             }
         },

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

@@ -1,7 +1,12 @@
 package de.jeanlucmakiola.calendula.ui.common
 
 import androidx.compose.runtime.staticCompositionLocalOf
+import de.jeanlucmakiola.calendula.domain.inRepeatedHour
+import de.jeanlucmakiola.calendula.domain.zoneAbbreviationAt
+import kotlinx.datetime.TimeZone
 import java.time.LocalTime
+import kotlin.time.Instant
+import kotlin.time.toJavaInstant
 import java.time.format.DateTimeFormatter
 import java.util.Locale
 
@@ -68,3 +73,15 @@ fun formatHourLabel(hour: Int, is24Hour: Boolean, locale: Locale): String =
     }
 
 private const val MINUTES_PER_DAY = 1_440
+
+/**
+ * [formatted] — [instant]'s time in [zone] — with the zone's abbreviation after
+ * it ("2:30 AM CEST") when the fall-back hour repeats that time, the one case
+ * where the time alone doesn't say which instant it is (#387).
+ */
+fun withRepeatedHourZone(formatted: String, instant: Instant, zone: TimeZone, locale: Locale): String {
+    if (!instant.inRepeatedHour(zone)) return formatted
+    val abbreviation = zoneAbbreviationAt(zone.id, locale, instant.toJavaInstant(), ::icuTimeZoneRegion)
+        ?: return formatted
+    return "$formatted $abbreviation"
+}

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

@@ -6,7 +6,6 @@ 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.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
@@ -44,9 +43,19 @@ import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.IntSize
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.instantIn
+import de.jeanlucmakiola.calendula.domain.repeatedHourOffsetAt
+import de.jeanlucmakiola.calendula.domain.repicked
+import de.jeanlucmakiola.calendula.domain.toFormTime
+import de.jeanlucmakiola.calendula.domain.resolveIn
 import de.jeanlucmakiola.calendula.ui.week.MINUTES_PER_DAY
 import de.jeanlucmakiola.calendula.ui.week.TimedBlock
+import de.jeanlucmakiola.calendula.ui.week.minutesPast
+import de.jeanlucmakiola.calendula.ui.week.wallClockEndMinutes
+import de.jeanlucmakiola.calendula.ui.week.wallClockMinutes
+import de.jeanlucmakiola.floret.identity.LocalFloretDarkTheme
 import de.jeanlucmakiola.floret.identity.rememberReduceMotion
 import de.jeanlucmakiola.floret.locale.currentLocale
 import kotlinx.coroutines.delay
@@ -54,13 +63,15 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.UtcOffset
 import kotlinx.datetime.plus
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
-import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
 import kotlin.math.roundToInt
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.minutes
 import kotlin.time.Instant
 
 /** Start granularity a dragged block snaps to, matching the big calendar apps. */
@@ -269,12 +280,95 @@ data class TimelineDrop(
     val clipOffsetMin: Int = 0,
 )
 
+/** The id a drafted block's stand-in event carries, which no provider row has (#153). */
+private const val DRAFT_ID = Long.MIN_VALUE
+
+/** Whether this is the stand-in for a block drafted on an empty slot, not a real event. */
+val EventInstance.isDraft: Boolean get() = instanceId == DRAFT_ID
+
+/** A drafted block's stand-in event, [minutes] long from [start]. */
+fun draftEvent(title: String, color: Int, start: Instant, minutes: Int): EventInstance = EventInstance(
+    instanceId = DRAFT_ID,
+    eventId = DRAFT_ID,
+    calendarId = DRAFT_ID,
+    title = title,
+    start = start,
+    end = start + minutes.minutes,
+    isAllDay = false,
+    color = color,
+    location = null,
+)
+
+/** Where a long press [minutes] down the column starts its draft, snapped down to the slot. */
+internal fun draftStartMin(minutes: Float): Int =
+    (minutes / DRAG_SNAP_MINUTES).toInt().times(DRAG_SNAP_MINUTES)
+        .coerceIn(0, MINUTES_PER_DAY - DRAG_SNAP_MINUTES)
+
+/** The part of [draft] on [date] as a full-width block, or null if none of it falls there. */
+internal fun draftBlock(draft: EventInstance, date: LocalDate, zone: TimeZone): TimedBlock? {
+    // Clipped to the day the way the grid lays out events, so it's drawn the same across a DST change (#387).
+    // The end is exclusive, so a draft ending at midnight belongs to the day before.
+    val start = maxOf(draft.start, date.atStartOfDayIn(zone))
+    val end = minOf(draft.end, date.plus(1, DateTimeUnit.DAY).atStartOfDayIn(zone))
+    if (end <= start) return null
+    val startMin = wallClockMinutes(start, date, zone)
+    val endMin = wallClockEndMinutes(startMin, start, end, date, zone).coerceAtMost(MINUTES_PER_DAY)
+    return TimedBlock(draft, startMin, endMin, lane = 0, laneCount = 1)
+}
+
 /** Which end of an event a resize handle moves (#141). */
 enum class ResizeEdge { Top, Bottom }
 
 /** Where a finished resize asks its event to begin and end. */
 data class TimelineResizeDrop(val event: EventInstance, val start: Instant, val end: Instant)
 
+/**
+ * [event] resized by its [edge] to the span [startMin]..+[spanMin] from [date]'s
+ * midnight. Only the held edge moves. The other keeps its own instant rather than
+ * a round trip through the grid, where an end in the fall-back hour's repeat is
+ * drawn to that hour's end, not at its own time (#387). In a repeated hour, the
+ * held edge takes the pass that matches the direction it was dragged from where
+ * it was drawn (see [repicked]). An end takes a pass the grid draws at the drop
+ * point, so the block settles under the finger.
+ */
+internal fun resizedDrop(
+    event: EventInstance,
+    edge: ResizeEdge?,
+    date: LocalDate,
+    startMin: Int,
+    spanMin: Int,
+    zone: TimeZone,
+): TimelineResizeDrop {
+    val drawn = wallClockSpan(event, zone)
+    return TimelineResizeDrop(
+        event = event,
+        start = if (edge == ResizeEdge.Top) {
+            event.start.toFormTime(zone).repicked(
+                wallClockTime(date, startMin),
+                zone,
+                shownAt = wallClockTime(drawn.day, drawn.startMin),
+                notAfter = event.end,
+            ).instantIn(zone)
+        } else {
+            event.start
+        },
+        end = if (edge == ResizeEdge.Bottom) {
+            val picked = wallClockTime(date, startMin + spanMin)
+            val pickedMin = (picked.date.toEpochDays() - drawn.day.toEpochDays()).toInt() * MINUTES_PER_DAY +
+                picked.time.toSecondOfDay() / 60
+            event.end.toFormTime(zone).repicked(
+                picked,
+                zone,
+                shownAt = wallClockTime(drawn.day, drawn.endMin),
+                notBefore = event.start,
+                drawable = { wallClockEndMinutes(drawn.startMin, event.start, it, drawn.day, zone) == pickedMin },
+            ).instantIn(zone)
+        } else {
+            event.end
+        },
+    )
+}
+
 /**
  * The span after dragging [edge] to [edgeMin] in day [edgeDay], in minutes from the
  * start day's midnight. Snapped, and at least one snap step long.
@@ -391,6 +485,9 @@ class TimelineDragController {
      */
     private var settledOrigin: Pair<Long, Instant>? by mutableStateOf(null)
 
+    /** How long a block drafted on an empty slot starts out, in minutes (#153). */
+    var draftMinutes: Int = SettingsPrefs.DEFAULT_EVENT_DURATION
+
     /** The selected event, if any — see [TimelineSelection]. */
     var selection: TimelineSelection? by mutableStateOf(null)
         private set
@@ -401,6 +498,7 @@ class TimelineDragController {
     }
 
     fun deselect() {
+        if (selection?.event?.isDraft == true && settling?.event?.isDraft == true) release()
         selection = null
         selectionCovered = false
     }
@@ -506,6 +604,10 @@ class TimelineDragController {
      * finger is on; this is what turns where it lands back into an event start.
      */
     private var clipOffsetMin = 0
+    private var dragZone: TimeZone? = null
+    private var dragDuration = Duration.ZERO
+    /** The dragged event's pass of a repeated hour, worked out once per drag (#387). */
+    private var dragKept: UtcOffset? = null
 
     /** What the picked-up block drew its title over — see [TimelineDrag.titleLines]. */
     private var titleLines = 0
@@ -539,6 +641,7 @@ class TimelineDragController {
     fun begin(
         block: TimedBlock,
         clipOffsetMin: Int,
+        zone: TimeZone,
         titleLines: Int,
         pointerInRoot: Offset,
         blockInRoot: Offset,
@@ -547,6 +650,9 @@ class TimelineDragController {
         if (!isSelected(block)) deselect()
         source = block
         this.clipOffsetMin = clipOffsetMin
+        dragZone = zone
+        dragDuration = (block.event.end - block.event.start).coerceAtLeast(Duration.ZERO)
+        dragKept = zone.repeatedHourOffsetAt(block.event.start)
         this.titleLines = titleLines
         settling = null
         isDragging = true
@@ -560,6 +666,16 @@ class TimelineDragController {
         originSlot = drag?.slot
     }
 
+    /**
+     * Draft a block on an empty slot and lift it at once (#153). It is selected
+     * from the start, so it keeps its handles and bar once the finger lets go.
+     */
+    fun beginDraft(block: TimedBlock, zone: TimeZone, pointerInRoot: Offset, blockInRoot: Offset) {
+        deselect()
+        select(block.event)
+        begin(block, clipOffsetMin = 0, zone, titleLines = 1, pointerInRoot = pointerInRoot, blockInRoot = blockInRoot)
+    }
+
     fun move(pointerInRoot: Offset) {
         pointer = pointerInRoot
         if (!pointerMoved && (pointerInRoot - pickupPointer).getDistance() > slopPx) pointerMoved = true
@@ -573,6 +689,9 @@ class TimelineDragController {
         resizeSlot = null
         source = null
         clipOffsetMin = 0
+        dragZone = null
+        dragDuration = Duration.ZERO
+        dragKept = null
         titleLines = 0
         isDragging = false
         pointerMoved = false
@@ -640,6 +759,8 @@ class TimelineDragController {
         val clipOffset = clipOffsetMin
         cancel()
         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
         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
@@ -663,18 +784,12 @@ class TimelineDragController {
         titleLines: Int,
         pointerInRoot: Offset,
     ) {
-        val start = block.event.start.toLocalDateTime(zone)
-        val end = block.event.end.toLocalDateTime(zone)
+        val span = wallClockSpan(block.event, zone)
         source = block
         resizeEdge = edge
-        resizeDay = start.date
-        resizeStartMin = start.time.toSecondOfDay() / 60
-        // Wall clock at both ends, as the drop resolves them (DST-safe).
-        resizeEndMin = maxOf(
-            resizeStartMin,
-            (end.date.toEpochDays() - start.date.toEpochDays()).toInt() * MINUTES_PER_DAY +
-                end.time.toSecondOfDay() / 60,
-        )
+        resizeDay = span.day
+        resizeStartMin = span.startMin
+        resizeEndMin = span.endMin
         clipOffsetMin = 0
         this.titleLines = titleLines
         settling = null
@@ -684,7 +799,7 @@ class TimelineDragController {
         pointer = pointerInRoot
         // Measured from the edge's own column: the handle overhangs into the next.
         val edgeDay = if (edge == ResizeEdge.Top) 0 else (resizeEndMin - 1).floorDiv(MINUTES_PER_DAY).coerceAtLeast(0)
-        val edgeIndex = geometry.days.indexOf(start.date.plus(edgeDay, DateTimeUnit.DAY))
+        val edgeIndex = geometry.days.indexOf(span.day.plus(edgeDay, DateTimeUnit.DAY))
         resizeColumn = edgeIndex.takeIf { it >= 0 }
             ?.let { if (geometry.isRtl) geometry.days.lastIndex - it else it }
         resizeGrabMin = (pointerResizeMinutes() ?: 0f) -
@@ -701,18 +816,15 @@ class TimelineDragController {
     fun finishResize(zone: TimeZone): TimelineResizeDrop? {
         val landed = drag
         val origin = originSlot
+        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)
         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
-        val drop = TimelineResizeDrop(
-            event = landed.event,
-            start = wallClockInstant(landed.date, landed.eventStartMin, zone),
-            end = wallClockInstant(landed.date, landed.eventStartMin + landed.eventSpanMin, zone),
-        )
         settledEnd = drop.end
         return drop
     }
@@ -835,13 +947,22 @@ class TimelineDragController {
         val origin = grid.positionInRoot()
         val rawMinutes = (pointer.y - grab.y - origin.y) / hourPx * 60f
         val snapped = (rawMinutes / DRAG_SNAP_MINUTES).roundToInt() * DRAG_SNAP_MINUTES
-        val eventSpan = (block.event.end - block.event.start).inWholeMinutes.toInt()
-            .coerceAtLeast(0)
-        val floor = dragFloorMin(clipOffsetMin, eventSpan)
-        val startMin = snapped.coerceIn(floor, MINUTES_PER_DAY - DRAG_SNAP_MINUTES)
-        val eventStartMin = startMin - clipOffsetMin
+        val zone = dragZone ?: return
         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
+        // wall clock gains or loses the hour of a DST change it crosses (#387).
+        val floor = dragFloorMin(
+            clipOffsetMin,
+            wallClockSpanMinutes(target, snapped - clipOffsetMin, dragDuration, zone, keep),
+        )
+        val held = snapped.coerceIn(floor, MINUTES_PER_DAY - DRAG_SNAP_MINUTES) - clipOffsetMin
+        // A start in the spring-forward gap lands an hour on; show it there.
+        val eventStartMin = wallClockInstant(target, held, zone, keep).minutesPast(target, zone)
+        val startMin = (eventStartMin + clipOffsetMin).coerceAtMost(MINUTES_PER_DAY - DRAG_SNAP_MINUTES)
+        val eventSpan = wallClockSpanMinutes(target, eventStartMin, dragDuration, zone, keep)
         val visible = -dayIndex..days.lastIndex - dayIndex
         val onGrid = dragSlices(eventStartMin, eventSpan, within = visible)
         val slices = onGrid.ifEmpty {
@@ -929,10 +1050,7 @@ fun rememberTimelineDragController(): TimelineDragController {
  * so the offset has to come back off at the drop (#253).
  */
 fun TimedBlock.clipOffsetMinutes(day: LocalDate, zone: TimeZone): Int {
-    val start = event.start.toLocalDateTime(zone)
-    val days = (day.toEpochDays() - start.date.toEpochDays()).toInt()
-    val minutes = days * MINUTES_PER_DAY + startMin - start.time.toSecondOfDay() / 60
-    return minutes.coerceAtLeast(0)
+    return (startMin - event.start.minutesPast(day, zone)).coerceAtLeast(0)
 }
 
 /**
@@ -954,13 +1072,57 @@ fun TimedBlock.continuesAfter(day: LocalDate, zone: TimeZone): Boolean =
  * visibly settles there.
  */
 fun TimelineDrop.startInstant(zone: TimeZone): Instant =
-    wallClockInstant(date, startMin - clipOffsetMin, zone)
+    wallClockInstant(date, startMin - clipOffsetMin, zone, kept = zone.repeatedHourOffsetAt(event.start))
 
-/** [minutes] past [date]'s midnight, either way past it, as wall clock in [zone] (DST-safe). */
-fun wallClockInstant(date: LocalDate, minutes: Int, zone: TimeZone): Instant {
+/**
+ * The wall-clock minutes an event lasting [duration] covers when it starts
+ * [startMin] past [date]'s midnight in [zone] — its real length, give or take a
+ * DST change in between (#387).
+ */
+internal fun wallClockSpanMinutes(
+    date: LocalDate,
+    startMin: Int,
+    duration: Duration,
+    zone: TimeZone,
+    kept: UtcOffset? = null,
+): Int {
+    val start = wallClockInstant(date, startMin, zone, kept)
+    return wallClockEndMinutes(startMin, start, start + duration, date, zone) - startMin
+}
+
+/**
+ * [minutes] past [date]'s midnight, either way past it, as wall clock in [zone]
+ * (DST-safe). A time the fall-back hour repeats lands on its earlier pass, unless
+ * [kept] is its later one: an event there stays on it (#387). Pass
+ * [repeatedHourOffsetAt] of the event's time, which is null outside the hour —
+ * such an instant says nothing about which pass the grid slot means, so a drop
+ * never depends on the season the event came from.
+ */
+fun wallClockInstant(date: LocalDate, minutes: Int, zone: TimeZone, kept: UtcOffset? = null): Instant =
+    wallClockTime(date, minutes).resolveIn(zone, kept)
+
+/** The wall-clock time [minutes] past [date]'s midnight, on a later day past 1440. */
+fun wallClockTime(date: LocalDate, minutes: Int): LocalDateTime {
     val day = date.plus(minutes.floorDiv(MINUTES_PER_DAY), DateTimeUnit.DAY)
     val minute = minutes.mod(MINUTES_PER_DAY)
-    return LocalDateTime(day, LocalTime(minute / 60, minute % 60)).toInstant(zone)
+    return LocalDateTime(day, LocalTime(minute / 60, minute % 60))
+}
+
+/** An event's span as wall-clock minutes from its start day's midnight. */
+data class WallClockSpan(val day: LocalDate, val startMin: Int, val endMin: Int)
+
+/**
+ * [event]'s [WallClockSpan], its end past 1440 when it ends on a later day
+ * (DST-safe). One ending in the fall-back hour's repeat ends where that hour does.
+ */
+fun wallClockSpan(event: EventInstance, zone: TimeZone): WallClockSpan {
+    val start = event.start.toLocalDateTime(zone)
+    val startMin = start.time.toSecondOfDay() / 60
+    return WallClockSpan(
+        start.date,
+        startMin,
+        wallClockEndMinutes(startMin, event.start, event.end, start.date, zone),
+    )
 }
 
 /**
@@ -990,7 +1152,7 @@ const val SETTLE_FADE_MILLIS: Int = 250
 fun TimelineDragOverlay(controller: TimelineDragController, modifier: Modifier = Modifier) {
     var origin by remember { mutableStateOf(Offset.Zero) }
     val density = LocalDensity.current
-    val dark = isSystemInDarkTheme()
+    val dark = LocalFloretDarkTheme.current
     val use24Hour = LocalUse24HourFormat.current
     val locale = currentLocale()
     val reduceMotion = rememberReduceMotion()
@@ -1212,7 +1374,7 @@ private fun DragCopy(
                 Text(
                     text = label,
                     // As the block it lifted off sets its own time (#219).
-                    style = MaterialTheme.typography.labelSmall.asEventTime(),
+                    style = rememberPackedLines(MaterialTheme.typography.labelSmall.asEventTime()),
                     maxLines = timeMaxLines,
                     overflow = overflow.overflow,
                     softWrap = overflow.softWrap,
@@ -1233,7 +1395,8 @@ fun selectionLift(selected: Boolean, snap: Boolean = false): Float {
         val target = if (selected) 1f else 0f
         if (reduceMotion || (selected && snap)) raise.snapTo(target) else raise.animateTo(target, spec)
     }
-    return raise.value
+    // The effect runs a frame late, and that frame would show the block unlifted.
+    return if (selected && snap) 1f else raise.value
 }
 
 /**

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

@@ -5,7 +5,6 @@ import android.content.Intent
 import android.net.Uri
 import android.widget.Toast
 import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -67,10 +66,14 @@ import androidx.compose.ui.text.LinkAnnotation
 import androidx.compose.ui.text.SpanStyle
 import androidx.compose.ui.text.TextLinkStyles
 import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontStyle
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.BaselineShift
 import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.em
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
@@ -83,10 +86,13 @@ import de.jeanlucmakiola.calendula.domain.Availability
 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.floret.identity.LocalFloretDarkTheme
 import de.jeanlucmakiola.floret.identity.predictiveBack
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.DeleteEventDialog
@@ -102,6 +108,7 @@ 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
+import de.jeanlucmakiola.calendula.ui.common.withRepeatedHourZone
 import de.jeanlucmakiola.calendula.ui.common.recurrenceText
 import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
 import kotlinx.coroutines.launch
@@ -296,7 +303,7 @@ private fun EventDetailContent(
 ) {
     val detail = state.detail
     val instance = detail.instance
-    val dark = isSystemInDarkTheme()
+    val dark = LocalFloretDarkTheme.current
     val locale = currentDetailLocale()
     val accent = eventAccent(instance.color, dark, LocalSoftenColors.current)
 
@@ -311,15 +318,26 @@ private fun EventDetailContent(
         // cancelled event strikes through its title.
         Row(verticalAlignment = Alignment.Top) {
             val titleLabel = stringResource(R.string.event_detail_title)
+            val titleDecoration = if (detail.status == EventStatus.Cancelled) {
+                TextDecoration.LineThrough
+            } else {
+                null
+            }
             Text(
-                text = instance.title.ifBlank { stringResource(R.string.event_untitled) },
+                // A phone number in the title ("Call Anna 0151 …") dials too.
+                text = if (instance.title.isBlank()) {
+                    AnnotatedString(stringResource(R.string.event_untitled))
+                } else {
+                    linkify(
+                        instance.title,
+                        state.phoneLinks.title,
+                        MaterialTheme.colorScheme.primary,
+                        titleDecoration,
+                    )
+                },
                 style = MaterialTheme.typography.headlineMedium,
                 fontWeight = FontWeight.SemiBold,
-                textDecoration = if (detail.status == EventStatus.Cancelled) {
-                    TextDecoration.LineThrough
-                } else {
-                    null
-                },
+                textDecoration = titleDecoration,
                 modifier = Modifier
                     .weight(1f)
                     .then(
@@ -366,7 +384,7 @@ private fun EventDetailContent(
         val gap = 12.dp
 
         // "When" — date/all-day plus the time range.
-        val (whenPrimary, whenSecondary) = formatWhen(instance, TimeZone.currentSystemDefault(), locale)
+        val (whenPrimary, whenSecondary) = rememberWhen(instance, TimeZone.currentSystemDefault(), locale)
         DetailCard(icon = Icons.Default.Schedule, iconContentDescription = null) {
             Text(text = whenPrimary, style = MaterialTheme.typography.titleMedium)
             if (whenSecondary != null) {
@@ -406,7 +424,7 @@ private fun EventDetailContent(
                 // 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 = runCatching { TimeZone.of(zoneOption.id) }.getOrNull()
-                    ?.let { formatWhen(instance, it, locale) }
+                    ?.let { rememberWhen(instance, it, locale) }
                     ?.let { (primary, secondary) -> secondary ?: primary }
                 Spacer(Modifier.height(2.dp))
                 Text(
@@ -436,7 +454,8 @@ private fun EventDetailContent(
             )
         }
 
-        // Location (conditional). URLs open in the browser, the rest in maps.
+        // Location (conditional). URLs open in the browser, phone numbers in the
+        // dialer, the rest in maps.
         instance.location?.takeIf { it.isNotBlank() }?.let { location ->
             val context = LocalContext.current
             val locationLabel = stringResource(R.string.event_detail_location)
@@ -446,7 +465,7 @@ private fun EventDetailContent(
                 iconContentDescription = locationLabel,
             ) {
                 Text(
-                    text = linkifyUrls(location, MaterialTheme.colorScheme.primary),
+                    text = linkify(location, state.phoneLinks.location, MaterialTheme.colorScheme.primary),
                     style = MaterialTheme.typography.titleMedium,
                     color = MaterialTheme.colorScheme.primary,
                     modifier = Modifier
@@ -463,8 +482,9 @@ private fun EventDetailContent(
             }
         }
 
-        // Description (conditional). URLs are auto-linked.
-        detail.description?.takeIf { it.isNotBlank() }?.let { description ->
+        // Description (conditional). HTML is rendered (#271); URLs and phone
+        // numbers are auto-linked.
+        state.description?.let { description ->
             val descriptionLabel = stringResource(R.string.event_detail_description)
             Spacer(Modifier.height(gap))
             DetailCard(
@@ -473,10 +493,10 @@ private fun EventDetailContent(
                 // The gesture sits on the card so the icon and padding answer
                 // it too: every linkified URL owns the pointer over its own
                 // glyphs, which leaves the text itself a patchy target.
-                modifier = Modifier.copyOnLongPress(descriptionLabel, description, copyField),
+                modifier = Modifier.copyOnLongPress(descriptionLabel, description.copyText(), copyField),
             ) {
                 Text(
-                    text = linkifyUrls(description, MaterialTheme.colorScheme.primary),
+                    text = linkify(description, state.phoneLinks.description, MaterialTheme.colorScheme.primary),
                     style = MaterialTheme.typography.bodyMedium,
                 )
             }
@@ -749,45 +769,114 @@ private fun foreignTimeZone(
     )
 }
 
-/** Wrap http(s) URLs in [text] as links tinted [linkColor] that open in the browser. */
+/**
+ * Wrap http(s) URLs in [text] as links that open in the browser, and its
+ * [phoneLinks] as links that open the dialer, both tinted [linkColor]. A
+ * link's underline joins [textDecoration] rather than replacing it, so a
+ * cancelled title stays struck through across its links.
+ */
 @Composable
-private fun linkifyUrls(text: String, linkColor: Color): AnnotatedString {
+private fun linkify(
+    text: String,
+    phoneLinks: List<PhoneLink>,
+    linkColor: Color,
+    textDecoration: TextDecoration? = null,
+): AnnotatedString = linkify(RichText(text), phoneLinks, linkColor, textDecoration)
+
+/**
+ * [linkify] for text rendered from HTML: its own formatting and `<a href>`
+ * links come along, and a URL or number already inside one isn't linked again.
+ */
+@Composable
+private fun linkify(
+    text: RichText,
+    phoneLinks: List<PhoneLink>,
+    linkColor: Color,
+    textDecoration: TextDecoration? = null,
+): AnnotatedString {
     val context = LocalContext.current
-    return remember(text, linkColor, context) {
-        val styles = TextLinkStyles(
-            style = SpanStyle(color = linkColor, textDecoration = TextDecoration.Underline),
-        )
+    return remember(text, phoneLinks, linkColor, textDecoration, context) {
+        // Decorations go on separately so overlapping ones add up: a span's
+        // textDecoration replaces whatever sits under it.
+        val styles = TextLinkStyles(style = SpanStyle(color = linkColor))
+        val decorations = mutableListOf<Triple<Int, Int, TextDecoration>>()
+        textDecoration?.let { decorations += Triple(0, text.text.length, it) }
+        for (range in text.styles) {
+            when (range.style) {
+                InlineStyle.Underline -> decorations += Triple(range.start, range.end, TextDecoration.Underline)
+                InlineStyle.Strikethrough -> decorations += Triple(range.start, range.end, TextDecoration.LineThrough)
+                else -> Unit
+            }
+        }
+        fun linked(start: Int, end: Int) = text.links.any { start < it.end && it.start < end }
         buildAnnotatedString {
-            append(text)
-            for (link in findWebLinks(text)) {
-                addLink(
-                    LinkAnnotation.Url(link.url, styles) { openWebLink(context, link.url) },
-                    link.start,
-                    link.end,
-                )
+            append(text.text)
+            for (range in text.styles) range.style.toSpanStyle()?.let { addStyle(it, range.start, range.end) }
+            fun link(url: String, start: Int, end: Int, onClick: () -> Unit) {
+                addLink(LinkAnnotation.Url(url, styles) { onClick() }, start, end)
+                decorations += Triple(start, end, TextDecoration.Underline)
+            }
+            for (link in text.links) {
+                if (link.url.startsWith("tel:")) {
+                    link(link.url, link.start, link.end) { dial(context, Uri.decode(link.url.substring(4))) }
+                } else {
+                    link(link.url, link.start, link.end) { openWebLink(context, link.url) }
+                }
+            }
+            for (link in findWebLinks(text.text)) {
+                if (linked(link.start, link.end)) continue
+                link(link.url, link.start, link.end) { openWebLink(context, link.url) }
+            }
+            for (link in phoneLinks) {
+                if (linked(link.start, link.end)) continue
+                link("tel:${link.number}", link.start, link.end) { dial(context, link.number) }
+            }
+            val bounds = decorations.flatMap { listOf(it.first, it.second) }.distinct().sorted()
+            for ((start, end) in bounds.zipWithNext()) {
+                val covering = decorations.filter { it.first <= start && end <= it.second }.map { it.third }.distinct()
+                if (covering.isNotEmpty()) addStyle(SpanStyle(textDecoration = TextDecoration.combine(covering)), start, end)
             }
         }
     }
 }
 
+private fun InlineStyle.toSpanStyle(): SpanStyle? = when (this) {
+    InlineStyle.Bold -> SpanStyle(fontWeight = FontWeight.Bold)
+    InlineStyle.Italic -> SpanStyle(fontStyle = FontStyle.Italic)
+    InlineStyle.Superscript -> SpanStyle(baselineShift = BaselineShift.Superscript, fontSize = 0.75.em)
+    InlineStyle.Subscript -> SpanStyle(baselineShift = BaselineShift.Subscript, fontSize = 0.75.em)
+    InlineStyle.Monospace -> SpanStyle(fontFamily = FontFamily.Monospace)
+    InlineStyle.Underline, InlineStyle.Strikethrough -> null
+}
+
 /**
  * Format an event's time into a primary line (date, or "All day") and an
  * optional secondary line (time range). Multi-day timed events collapse into a
  * single primary line spanning both ends.
  */
 @Composable
+private fun rememberWhen(instance: EventInstance, zone: TimeZone, locale: Locale): Pair<String, String?> {
+    val use24Hour = LocalUse24HourFormat.current
+    val allDayLabel = stringResource(R.string.event_detail_all_day)
+    // Remembered: a time in the repeated hour looks up its zone abbreviation (#387).
+    return remember(instance, zone, locale, use24Hour, allDayLabel) {
+        formatWhen(instance, zone, locale, use24Hour, allDayLabel)
+    }
+}
+
 private fun formatWhen(
     instance: EventInstance,
     zone: TimeZone,
     locale: Locale,
+    use24Hour: Boolean,
+    allDayLabel: String,
 ): Pair<String, String?> {
     val zid = ZoneId.of(zone.id)
     val dateFull = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL).withLocale(locale)
     val dateMedium = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
-    val timeShort = timeOfDayFormatter(LocalUse24HourFormat.current, locale)
+    val timeShort = timeOfDayFormatter(use24Hour, locale)
 
     val startLdt = instance.start.toJavaLocalDateTime(zid)
-    val allDayLabel = stringResource(R.string.event_detail_all_day)
 
     if (instance.isAllDay) {
         // All-day events live at UTC midnights with an exclusive end. Resolve
@@ -807,12 +896,13 @@ private fun formatWhen(
     }
 
     val endLdt = instance.end.toJavaLocalDateTime(zid)
+    val startTime = withRepeatedHourZone(timeShort.format(startLdt), instance.start, zone, locale)
+    val endTime = withRepeatedHourZone(timeShort.format(endLdt), instance.end, zone, locale)
     return if (startLdt.toLocalDate() == endLdt.toLocalDate()) {
-        dateFull.format(startLdt.toLocalDate()) to
-            "${timeShort.format(startLdt)} – ${timeShort.format(endLdt)}"
+        dateFull.format(startLdt.toLocalDate()) to "$startTime – $endTime"
     } else {
-        val start = "${dateMedium.format(startLdt.toLocalDate())} ${timeShort.format(startLdt)}"
-        val end = "${dateMedium.format(endLdt.toLocalDate())} ${timeShort.format(endLdt)}"
+        val start = "${dateMedium.format(startLdt.toLocalDate())} $startTime"
+        val end = "${dateMedium.format(endLdt.toLocalDate())} $endTime"
         "$start – $end" to null
     }
 }
@@ -822,7 +912,15 @@ private fun Instant.toJavaLocalDateTime(zid: ZoneId): java.time.LocalDateTime =
 
 /** Open [url] in a browsable app, or say so when none can take it. */
 private fun openWebLink(context: Context, url: String) {
-    val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url)).addCategory(Intent.CATEGORY_BROWSABLE)
+    startOrSayNoApp(context, Intent(Intent.ACTION_VIEW, Uri.parse(url)).addCategory(Intent.CATEGORY_BROWSABLE))
+}
+
+/** Open the dialer with [number] filled in, or say so when none can take it. */
+private fun dial(context: Context, number: String) {
+    startOrSayNoApp(context, Intent(Intent.ACTION_DIAL, Uri.fromParts("tel", number, null)))
+}
+
+private fun startOrSayNoApp(context: Context, intent: Intent) {
     if (runCatching { context.startActivity(intent) }.isFailure) {
         Toast.makeText(context, R.string.link_open_failed, Toast.LENGTH_SHORT).show()
     }

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

@@ -2,6 +2,7 @@ package de.jeanlucmakiola.calendula.ui.detail
 
 import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.FailureReason
+import de.jeanlucmakiola.calendula.domain.RichText
 
 /**
  * UI state for the event-detail screen (spec S4).
@@ -21,6 +22,10 @@ sealed interface EventDetailUiState {
          * the sync would just resurrect it. Contact dates are removed at the source.
          */
         val isManaged: Boolean = false,
+        /** Phone numbers to link in the title, location and description. */
+        val phoneLinks: EventPhoneLinks = EventPhoneLinks(),
+        /** The description as drawn — HTML rendered (#271); null when there is none. */
+        val description: RichText? = null,
     ) : EventDetailUiState
 }
 

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

@@ -11,8 +11,11 @@ import de.jeanlucmakiola.calendula.data.ics.IcsExporter
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
+import de.jeanlucmakiola.calendula.domain.atOccurrence
+import de.jeanlucmakiola.calendula.domain.descriptionRichText
 import de.jeanlucmakiola.calendula.domain.toDuplicateForm
-import de.jeanlucmakiola.calendula.ui.common.deleteEvent
+import de.jeanlucmakiola.calendula.ui.common.DeleteOutcome
+import de.jeanlucmakiola.calendula.ui.common.tryDeleteEvent
 import de.jeanlucmakiola.calendula.ui.common.stageEventShare
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.withContext
@@ -31,7 +34,6 @@ import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.datetime.TimeZone
 import kotlin.coroutines.cancellation.CancellationException
-import kotlin.time.Instant
 import javax.inject.Inject
 
 /**
@@ -111,15 +113,11 @@ class EventDetailViewModel @Inject constructor(
         if (_deleteState.value == DeleteUiState.Deleting) return
         viewModelScope.launch {
             _deleteState.value = DeleteUiState.Deleting
-            _deleteState.value = try {
-                repository.deleteEvent(target.eventId, target.beginMillis, scope)
-                DeleteUiState.Deleted
-            } catch (e: CancellationException) {
-                throw e
-            } catch (e: SecurityException) {
-                DeleteUiState.NeedsPermission
-            } catch (e: Exception) {
-                DeleteUiState.Failed
+            _deleteState.value = when (repository.tryDeleteEvent(target.eventId, target.beginMillis, scope)) {
+                // Already gone is what a delete wants anyway.
+                DeleteOutcome.Deleted, DeleteOutcome.Gone -> DeleteUiState.Deleted
+                DeleteOutcome.NeedsPermission -> DeleteUiState.NeedsPermission
+                DeleteOutcome.Failed -> DeleteUiState.Failed
             }
         }
     }
@@ -150,28 +148,32 @@ class EventDetailViewModel @Inject constructor(
 
     private suspend fun loadDetail(target: Target): EventDetailUiState = try {
         val detail = repository.eventDetail(target.eventId)
-        // The Events row holds the series start; replace it with this
-        // occurrence's time so recurring events render correctly. An external
-        // "open event" that names no occurrence ([NO_OCCURRENCE_TIME] — e.g. a
-        // bare content://.../events/<id> VIEW intent, issue #48) keeps the row's
-        // own DTSTART/DTEND instead of overriding it to the epoch.
+        // An external "open event" that names no occurrence ([NO_OCCURRENCE_TIME] —
+        // e.g. a bare content://.../events/<id> VIEW intent, issue #48) keeps the
+        // row's own DTSTART/DTEND instead of overriding it to the epoch.
         val corrected = if (target.beginMillis == NO_OCCURRENCE_TIME) {
             detail
         } else {
-            detail.copy(
-                instance = detail.instance.copy(
-                    start = Instant.fromEpochMilliseconds(target.beginMillis),
-                    end = Instant.fromEpochMilliseconds(target.endMillis),
-                ),
-            )
+            detail.atOccurrence(target.beginMillis, target.endMillis)
         }
         val calendar = repository.calendars().first()
             .firstOrNull { it.id == corrected.instance.calendarId }
+        val description = corrected.description
+            ?.let(::descriptionRichText)
+            ?.takeIf { it.text.isNotBlank() }
         EventDetailUiState.Success(
             detail = corrected,
             calendarName = calendar?.displayName,
             canModify = calendar?.canModifyContents == true,
             isManaged = calendar?.isManaged == true,
+            // Found here, off the main thread and once per load: the platform
+            // matcher loads its metadata on first use.
+            phoneLinks = findEventPhoneLinks(
+                title = corrected.instance.title,
+                location = corrected.instance.location,
+                description = description?.text,
+            ),
+            description = description,
         )
     } catch (e: CancellationException) {
         throw e

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

@@ -0,0 +1,202 @@
+package de.jeanlucmakiola.calendula.ui.detail
+
+import android.text.SpannableString
+import android.text.style.URLSpan
+import android.text.util.Linkify
+
+/**
+ * A phone number found in free text, spanning [start] until [end] (exclusive).
+ * [number] is what the dialer gets: digits, a leading `+`, and any `,`/`#`
+ * dial-in suffix — the separators that only made it readable are gone.
+ */
+data class PhoneLink(val start: Int, val end: Int, val number: String)
+
+/** The phone numbers in an event's free-text fields, each against its own text. */
+data class EventPhoneLinks(
+    val title: List<PhoneLink> = emptyList(),
+    val location: List<PhoneLink> = emptyList(),
+    val description: List<PhoneLink> = emptyList(),
+)
+
+/** Where the platform matcher saw a phone number: [start] until [end] (exclusive). */
+internal data class PhoneMatch(val start: Int, val end: Int)
+
+// A conference dial-in's pauses and meeting id right after the number:
+// "+16465588656,,85012345678#" or Zoom's ",,850…#,,,,*123456#". It opens on a
+// double comma or closes on "#", so "030 1234567,0151 2345678" stays a list.
+private val dialSuffixRegex = Regex("""^(?:,,+[\d*]+#?|,[\d*]+#)(?:,+[\d*]+#?)*""")
+
+// Whitespace as invites write it: Java's \s misses the no-break space and the
+// invisible direction marks Meet and Outlook wrap around numbers.
+private const val GAP = """\s\u00A0\u200E\u200F\u202A-\u202E\u2066-\u2069"""
+
+// A number right after one of these labels is an id to type in, not one to
+// call. English and German cover the Zoom/Teams/Meet/Webex invites seen so far.
+// "Conference number" is left out: invites use it for the dial-in itself.
+private val notAPhoneLabelRegex = Regex(
+    """(?:(?:meeting|webinar|besprechungs)[ -]?(?:id|number|nummer)|(?:conference|konferenz)[ -]?id|""" +
+        """\bpin|passcode|password|passwort|kenncode|access code|zugangscode)[$GAP:#.()]*$""",
+    RegexOption.IGNORE_CASE,
+)
+
+// A day.month.year (or year-month-day, or US month/day/year) date: exactly
+// three groups, so a French "01.23.45.67.89" chain doesn't read as one.
+private val dateRegex = Regex("""(?<![\d./-])(\d{1,4})([./-])(\d{1,2})\2(\d{4}|\d{2})(?![\d]|[./-]\d)""")
+
+// Thousands groups. A short lead ("1.250.000", "12 500 000") is an amount; a
+// three-digit lead is one only beside a currency — "612 345 678" and
+// "612.345.678" are Spanish mobiles, "125.000.000 €" a budget.
+private val shortLeadAmountRegex = Regex("""[1-9]\d?(?:([. ])\d{3})(?:\1\d{3})*""")
+private val amountRegex = Regex("""[1-9]\d{0,2}(?:([. ])\d{3})(?:\1\d{3})*""")
+private val currencyBeforeRegex = Regex("""(?:[€$£]|\b(?:eur|euro|usd|chf|gbp))\s*$""", RegexOption.IGNORE_CASE)
+private val currencyAfterRegex = Regex("""^\s*(?:[€$£]|(?:eur|euro|usd|chf|gbp)\b)""", RegexOption.IGNORE_CASE)
+
+// A short group set off by a space after a long one, with a word straight
+// after — "… 2345678 2 times" — is the prose's count, not the number's tail.
+// Without the word ("030 123456 0") or after a short group ("0221 1234 56")
+// it is the number's own.
+private val strayTailRegex = Regex("""(?<=\d{6})\s+\d{1,2}$""")
+private val wordAfterRegex = Regex("""[ \t\u00A0]+\p{L}""")
+
+// "9.30 – 12.00", "10.00-11.30": times of day written the German way.
+private val dottedTimesRegex = Regex("""(\d{1,2})\.(\d{2})(?:\s*[-–]\s*(\d{1,2})\.(\d{2}))?""")
+
+// "ext. 567", "x567", "Durchwahl 567": the dialer reaches an extension after a pause.
+private val extensionRegex = Regex("""\s*(?:ext\.?|extension|x|durchwahl|dw\.?)\s*(?=\d)""", RegexOption.IGNORE_CASE)
+
+private val trunkPrefixRegex = Regex("""\(\s*0\s*\)""")
+private val strandedCountryCodeRegex = Regex("""\+\d{1,3}\s*\(\s*0\s*\)\s*$""")
+
+// Short local numbers exist, but in event text a 5- or 6-digit run is far more
+// often a postcode, house number or booking reference.
+private const val MIN_DIGITS = 7
+
+/**
+ * Find the phone numbers in [text]. The platform's libphonenumber-backed
+ * matcher does the finding — it knows the device's region and real number
+ * lengths; [refinePhoneMatches] then fits what it found to an event's text.
+ * Call off the main thread: the matcher loads its metadata on first use.
+ * No match at all when the platform matcher fails.
+ */
+internal fun findPhoneLinks(text: String): List<PhoneLink> =
+    refinePhoneMatches(text, platformPhoneMatches(text), findWebLinks(text))
+
+/** [findPhoneLinks] for each of an event's free-text fields. */
+internal fun findEventPhoneLinks(title: String, location: String?, description: String?) = EventPhoneLinks(
+    title = findPhoneLinks(title),
+    location = location?.let(::findPhoneLinks).orEmpty(),
+    description = description?.let(::findPhoneLinks).orEmpty(),
+)
+
+// The matcher reads the region off the SIM, which throws on a device without
+// telephony; a field then just goes without phone links.
+private fun platformPhoneMatches(text: String): List<PhoneMatch> = runCatching {
+    val spannable = SpannableString(text)
+    if (!Linkify.addLinks(spannable, Linkify.PHONE_NUMBERS)) return emptyList()
+    spannable.getSpans(0, spannable.length, URLSpan::class.java)
+        .map { PhoneMatch(spannable.getSpanStart(it), spannable.getSpanEnd(it)) }
+}.getOrDefault(emptyList())
+
+/**
+ * Turn the platform's [matches] in [text] into dialable links. The matcher is
+ * lenient, so a match is dropped when it sits inside one of the [webLinks],
+ * follows a meeting id or PIN label, holds a date, reads as an amount or is
+ * too short. What's kept loses a stray count off its end, regains an
+ * international "+49 (0)" prefix the matcher left behind, and carries a
+ * conference dial-in suffix along.
+ */
+internal fun refinePhoneMatches(
+    text: String,
+    matches: List<PhoneMatch>,
+    webLinks: List<WebLink>,
+): List<PhoneLink> {
+    val links = mutableListOf<PhoneLink>()
+    for (match in matches.sortedBy { it.start }) {
+        var start = match.start
+        var end = match.end
+        val matched = text.substring(start, end)
+        if (webLinks.any { start < it.end && it.start < end }) continue
+        if (gluedIntoAWord(text, start, end)) continue
+        val lineBefore = text.window(lineStart(text, start).coerceAtLeast(start - LOOK_BEHIND), start)
+        if (notAPhoneLabelRegex.containsMatchIn(lineBefore)) continue
+        if (dateRegex.findAll(matched).any { it.isDate() }) continue
+        if (isDottedTimes(matched)) continue
+        if (isAmount(text, start, end)) continue
+        strayTailRegex.find(matched)?.let { tail ->
+            if (wordAfterRegex.matchesAt(text, end)) end = start + tail.range.first
+        }
+        // "+49 (0)151 …": a matcher that stops at the "(0)" leaves the domestic
+        // tail, which would dial without the country code.
+        strandedCountryCodeRegex.find(text.window(start - LOOK_BEHIND, start))
+            ?.let { start -= it.value.length }
+        val number = dialable(text.substring(start, end))
+        if (number.count { it.isDigit() } < MIN_DIGITS) continue
+        val suffix = dialSuffixRegex.find(text.window(end, end + LOOK_AHEAD))?.value.orEmpty()
+        // A suffix swallowed what the matcher saw as the next number.
+        if (links.lastOrNull()?.let { start < it.end } == true) continue
+        links += PhoneLink(start, end + suffix.length, number + dialable(suffix))
+    }
+    return links
+}
+
+// How far around a match the label, prefix, currency and suffix checks look.
+// Enough for any of them, and it keeps a long invite from being re-read whole
+// for every number in it.
+private const val LOOK_BEHIND = 40
+private const val LOOK_AHEAD = 60
+
+private fun String.window(from: Int, to: Int): String =
+    substring(from.coerceAtLeast(0), to.coerceAtMost(length))
+
+/**
+ * Digits run straight into a letter or a URL path — "zoom.us/j/850…" without
+ * its https:// — which no web link covered. A phone number stands apart.
+ */
+private fun gluedIntoAWord(text: String, start: Int, end: Int): Boolean {
+    val before = text.getOrNull(start - 1)
+    val after = text.getOrNull(end)
+    return (before != null && (before.isLetter() || before in "/=?&")) ||
+        (after != null && (after.isLetter() || after == '/'))
+}
+
+private fun isDottedTimes(matched: String): Boolean {
+    val times = dottedTimesRegex.matchEntire(matched) ?: return false
+    return times.groupValues.drop(1).chunked(2).all { (hour, minute) ->
+        hour.isEmpty() || (hour.toInt() in 0..24 && minute.toInt() in 0..59)
+    }
+}
+
+private fun isAmount(text: String, start: Int, end: Int): Boolean {
+    val matched = text.substring(start, end)
+    if (shortLeadAmountRegex.matches(matched)) return true
+    return amountRegex.matches(matched) &&
+        (currencyBeforeRegex.containsMatchIn(text.window(start - LOOK_BEHIND, start)) ||
+            currencyAfterRegex.containsMatchIn(text.window(end, end + LOOK_AHEAD)))
+}
+
+private fun MatchResult.isDate(): Boolean {
+    val (a, _, b, c) = destructured
+    val first = a.toInt()
+    val second = b.toInt()
+    val last = c.toInt()
+    return when {
+        a.length == 4 -> second in 1..12 && last in 1..31 && c.length <= 2
+        a.length > 2 -> false
+        // Day first (most of the world) or month first (US).
+        else -> (first in 1..31 && second in 1..12) || (first in 1..12 && second in 1..31)
+    }
+}
+
+private fun lineStart(text: String, index: Int): Int = text.lastIndexOf('\n', index - 1) + 1
+
+/**
+ * Strip [raw] down to what a dialer takes. An international number's "(0)"
+ * trunk prefix — "+49 (0) 151 …" — is a domestic-only hint and would break the
+ * call, so it goes too; an extension becomes a pause.
+ */
+private fun dialable(raw: String): String {
+    val international = raw.trimStart('(').startsWith("+")
+    val withoutTrunk = if (international) raw.replace(trunkPrefixRegex, "") else raw
+    return withoutTrunk.replace(extensionRegex, ",")
+        .filter { it.isDigit() || it == '+' || it == ',' || it == '#' || it == '*' }
+}

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

@@ -4,7 +4,6 @@ import android.Manifest
 import android.app.Activity
 import android.content.Context
 import android.content.Intent
-import android.content.pm.PackageManager
 import android.net.Uri
 import android.provider.ContactsContract
 import android.util.Patterns
@@ -13,7 +12,6 @@ import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ColumnScope
@@ -36,6 +34,17 @@ import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.Notes
 import androidx.compose.material.icons.filled.Add
+import de.jeanlucmakiola.floret.identity.LocalFloretDarkTheme
+import kotlinx.coroutines.launch
+import de.jeanlucmakiola.calendula.ui.common.sendEventShare
+import de.jeanlucmakiola.calendula.ui.common.canWriteCalendar
+import de.jeanlucmakiola.calendula.ui.common.rememberWriteGate
+import de.jeanlucmakiola.calendula.ui.common.DeleteEventDialog
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.material.icons.filled.Share
+import androidx.compose.material.icons.filled.MoreVert
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material.icons.filled.ContentCopy
 import androidx.compose.material.icons.filled.ArrowDropDown
 import androidx.compose.material.icons.filled.CalendarMonth
 import androidx.compose.material.icons.filled.Close
@@ -106,7 +115,6 @@ import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
-import androidx.core.content.ContextCompat
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
@@ -116,10 +124,13 @@ import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventAttendee
 import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.startInstant
+import de.jeanlucmakiola.calendula.domain.endInstant
+import de.jeanlucmakiola.calendula.domain.resolvedZone
+import de.jeanlucmakiola.calendula.domain.isPinnedAwayFrom
 import de.jeanlucmakiola.calendula.domain.EventFormField
 import de.jeanlucmakiola.calendula.domain.zoneDescriptor
 import de.jeanlucmakiola.calendula.domain.timeZoneOptionOf
-import de.jeanlucmakiola.calendula.domain.timesIn
 import de.jeanlucmakiola.calendula.domain.EventFormProblem
 import de.jeanlucmakiola.calendula.domain.RecurrenceEnd
 import de.jeanlucmakiola.calendula.domain.RecurrenceFreq
@@ -162,6 +173,7 @@ import de.jeanlucmakiola.floret.reminders.ReminderUnit
 import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.timeOfDayFormatter
+import de.jeanlucmakiola.calendula.ui.common.withRepeatedHourZone
 import de.jeanlucmakiola.calendula.ui.common.reminderLeadTimeLabel
 import de.jeanlucmakiola.calendula.ui.common.reminderUnitLabel
 import de.jeanlucmakiola.calendula.ui.common.nextOccurrencesText
@@ -174,7 +186,6 @@ import kotlinx.datetime.TimeZone
 import kotlinx.datetime.isoDayNumber
 import kotlinx.datetime.toJavaDayOfWeek
 import kotlinx.datetime.toJavaLocalDate
-import kotlinx.datetime.toInstant
 import kotlinx.datetime.toJavaLocalTime
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.toJavaInstant
@@ -184,6 +195,7 @@ import java.time.format.FormatStyle
 import java.time.format.TextStyle as JavaTextStyle
 import java.util.Locale
 import kotlin.time.Clock
+import kotlin.time.Instant
 
 /**
  * Full-screen event form: create (v1.2, from the FAB's anchor date) and edit
@@ -192,6 +204,10 @@ import kotlin.time.Clock
  * first asks how far the change reaches (this occurrence / this and
  * following / whole series) — then closes. The calendar picker offers only
  * writable calendars; when editing, the calendar is fixed.
+ *
+ * Leaving with unsaved changes asks to save, discard or keep editing (#178).
+ * While editing, the overflow menu offers Duplicate (the form as it stands,
+ * handed to [onDuplicate] as a new event), Share and Delete.
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -201,13 +217,21 @@ fun EventEditScreen(
     onSaved: () -> Unit,
     editKey: LongArray? = null,
     initialStartMinutes: Int? = null,
+    initialDraft: LongArray? = null,
     initialForm: EventForm? = null,
     initialFormSource: ImportSource = ImportSource.File,
     onManageCalendars: (() -> Unit)? = null,
+    onDuplicate: ((EventForm) -> Unit)? = null,
+    onDeleted: () -> Unit = onSaved,
+    onLoadFailed: () -> Unit = onClose,
+    leaveRequested: Boolean = false,
+    onLeaveDeclined: () -> Unit = {},
     visible: Boolean = true,
     viewModel: EventEditViewModel = hiltViewModel(),
 ) {
-    LaunchedEffect(initialDateIso, editKey, initialForm) {
+    // Keyed on every input that decides the form, so a second draft or slot on
+    // the same day opens its own form even when the composition is kept alive.
+    LaunchedEffect(initialDateIso, editKey, initialForm, initialDraft, initialStartMinutes) {
         when {
             // A prefilled open: a single-event .ics for review, or an external
             // ACTION_INSERT intent. The source drives how reminders are seeded.
@@ -217,9 +241,14 @@ fun EventEditScreen(
                 beginMillis = editKey[1],
                 endMillis = editKey[2],
             )
+            // A block drafted on the timeline (#153): its own start and end.
+            initialDraft != null -> viewModel.openDraft(
+                start = Instant.fromEpochMilliseconds(initialDraft[0]),
+                end = Instant.fromEpochMilliseconds(initialDraft[1]),
+            )
             else -> {
                 val date = initialDateIso?.let { runCatching { LocalDate.parse(it) }.getOrNull() }
-                    ?: Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()).date
+                    ?: Clock.System.now().toLocalDateTime(viewModel.zone.value).date
                 viewModel.openNew(date, initialStartMinutes)
             }
         }
@@ -235,41 +264,91 @@ fun EventEditScreen(
         viewModel.reset()
         onClose()
     }
-    // The event vanished between the detail screen and the edit tap — fall
-    // back to the detail screen, which shows its own failure state.
+    val hasUnsavedChanges by viewModel.hasUnsavedChanges.collectAsStateWithLifecycle()
+    var showLeavePrompt by rememberSaveable { mutableStateOf(false) }
+    var showDeleteDialog by rememberSaveable { mutableStateOf(false) }
+    // A running save or delete can't be called back, so leaving waits for it;
+    // its result then closes the form or reports why it didn't.
+    val requestClose = {
+        when {
+            state?.saveState == SaveUiState.Saving -> Unit
+            hasUnsavedChanges -> showLeavePrompt = true
+            else -> close()
+        }
+    }
+    // Something else wants this form's place, e.g. a second share (#306).
+    LaunchedEffect(leaveRequested) {
+        if (leaveRequested) requestClose()
+    }
+    // The event vanished before the form could load it — fall back to the
+    // detail screen, which shows its own failure state.
     LaunchedEffect(loadFailed) {
-        if (loadFailed) close()
+        if (loadFailed) {
+            viewModel.reset()
+            onLoadFailed()
+        }
     }
 
     val context = LocalContext.current
     val snackbarHostState = remember { SnackbarHostState() }
 
-    // Contextual WRITE_CALENDAR upgrade for v1.0 installs, like delete.
-    val writePermissionLauncher = rememberLauncherForActivityResult(
+    val scope = rememberCoroutineScope()
+    val requireWrite = rememberWriteGate()
+    // Save keeps its own launcher: its result calls straight into the ViewModel,
+    // so a save waiting on the permission dialog survives a rotation.
+    val savePermissionLauncher = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.RequestPermission(),
     ) { granted ->
         if (granted) viewModel.save()
     }
     val onSaveClick = {
-        val granted = ContextCompat.checkSelfPermission(
-            context,
-            Manifest.permission.WRITE_CALENDAR,
-        ) == PackageManager.PERMISSION_GRANTED
-        if (granted) {
+        if (context.canWriteCalendar()) {
             viewModel.save()
         } else {
-            writePermissionLauncher.launch(Manifest.permission.WRITE_CALENDAR)
+            savePermissionLauncher.launch(Manifest.permission.WRITE_CALENDAR)
+        }
+    }
+    val shareFailedMessage = stringResource(R.string.event_share_failed)
+    val shareChooserTitle = stringResource(R.string.event_share_chooser_title)
+    val onShareClick: () -> Unit = {
+        scope.launch {
+            val uri = viewModel.shareUri()
+            val sent = uri != null && context.sendEventShare(uri, shareChooserTitle)
+            if (!sent) snackbarHostState.showSnackbar(shareFailedMessage)
+        }
+    }
+    // The copy opens over this form; a form with nothing to lose steps aside.
+    val onDuplicateClick: () -> Unit = {
+        requireWrite {
+            viewModel.duplicateForm()?.let { form ->
+                onDuplicate?.invoke(form)
+                if (!hasUnsavedChanges) close()
+            }
         }
     }
 
     val saveFailedMessage = stringResource(R.string.event_edit_save_failed)
     val writeDeniedMessage = stringResource(R.string.event_edit_write_denied)
+    val deleteFailedMessage = stringResource(R.string.event_delete_failed)
+    val deleteDeniedMessage = stringResource(R.string.event_delete_write_denied)
     LaunchedEffect(state?.saveState) {
         when (state?.saveState) {
             SaveUiState.Saved -> {
                 viewModel.reset()
                 onSaved()
             }
+            SaveUiState.Deleted -> {
+                viewModel.reset()
+                onDeleted()
+            }
+            SaveUiState.DeleteFailed -> {
+                viewModel.consumeSaveResult()
+                snackbarHostState.showSnackbar(deleteFailedMessage, duration = SnackbarDuration.Long)
+            }
+            SaveUiState.DeleteDenied -> {
+                viewModel.consumeSaveResult()
+                snackbarHostState.showSnackbar(deleteDeniedMessage, duration = SnackbarDuration.Long)
+            }
             // A failed save leaves the form looking unchanged, so the snackbar is
             // the only sign anything happened — long rather than the default
             // flash (Codeberg #234: it read as "nothing happens at all").
@@ -287,7 +366,7 @@ fun EventEditScreen(
     }
 
     Scaffold(
-        modifier = Modifier.predictiveBack(onBack = close, visible = visible),
+        modifier = Modifier.predictiveBack(onBack = requestClose, visible = visible),
         snackbarHost = { SnackbarHost(snackbarHostState) },
         topBar = {
             TopAppBar(
@@ -295,7 +374,7 @@ fun EventEditScreen(
                 // matching the detail screen's bare top bar.
                 title = {},
                 navigationIcon = {
-                    IconButton(onClick = close) {
+                    IconButton(onClick = requestClose) {
                         Icon(
                             imageVector = Icons.Default.Close,
                             contentDescription = stringResource(R.string.event_edit_close),
@@ -303,6 +382,15 @@ fun EventEditScreen(
                     }
                 },
                 actions = {
+                    if (state?.isEditing == true) {
+                        EditActionsMenu(
+                            canDelete = state?.isManaged == false,
+                            canDuplicate = onDuplicate != null,
+                            onDuplicate = onDuplicateClick,
+                            onShare = onShareClick,
+                            onDelete = { requireWrite { showDeleteDialog = true } },
+                        )
+                    }
                     Button(
                         onClick = onSaveClick,
                         enabled = state != null && state?.saveState != SaveUiState.Saving,
@@ -329,6 +417,35 @@ fun EventEditScreen(
         }
     }
 
+    if (showLeavePrompt) {
+        UnsavedChangesDialog(
+            onSave = {
+                showLeavePrompt = false
+                onSaveClick()
+            },
+            onDiscard = {
+                showLeavePrompt = false
+                close()
+            },
+            onDismiss = {
+                showLeavePrompt = false
+                if (leaveRequested) onLeaveDeclined()
+            },
+        )
+    }
+
+    val recurs = viewModel.editedEventRecurs()
+    if (showDeleteDialog && recurs != null) {
+        DeleteEventDialog(
+            isRecurring = recurs,
+            onConfirm = { deleteScope ->
+                showDeleteDialog = false
+                viewModel.delete(deleteScope)
+            },
+            onDismiss = { showDeleteDialog = false },
+        )
+    }
+
     if (state?.saveState == SaveUiState.AwaitingScope) {
         SaveScopeDialog(
             recurrenceChanged = state?.recurrenceChanged == true,
@@ -373,6 +490,90 @@ fun EventEditScreen(
     }
 }
 
+/** Duplicate, Share and Delete for the event being edited, behind an overflow button. */
+@Composable
+private fun EditActionsMenu(
+    canDelete: Boolean,
+    canDuplicate: Boolean,
+    onDuplicate: () -> Unit,
+    onShare: () -> Unit,
+    onDelete: () -> Unit,
+) {
+    var open by remember { mutableStateOf(false) }
+    Box {
+        IconButton(onClick = { open = true }) {
+            Icon(
+                imageVector = Icons.Default.MoreVert,
+                contentDescription = stringResource(R.string.event_edit_more_actions),
+            )
+        }
+        DropdownMenu(expanded = open, onDismissRequest = { open = false }) {
+            if (canDuplicate) {
+                DropdownMenuItem(
+                    text = { Text(stringResource(R.string.event_detail_duplicate)) },
+                    leadingIcon = { Icon(Icons.Default.ContentCopy, contentDescription = null) },
+                    onClick = {
+                        open = false
+                        onDuplicate()
+                    },
+                )
+            }
+            DropdownMenuItem(
+                text = { Text(stringResource(R.string.event_detail_share)) },
+                leadingIcon = { Icon(Icons.Default.Share, contentDescription = null) },
+                onClick = {
+                    open = false
+                    onShare()
+                },
+            )
+            // Managed special-dates events have no delete, as on the detail screen.
+            if (canDelete) {
+                DropdownMenuItem(
+                    text = { Text(stringResource(R.string.event_detail_delete)) },
+                    leadingIcon = { Icon(Icons.Default.Delete, contentDescription = null) },
+                    onClick = {
+                        open = false
+                        onDelete()
+                    },
+                )
+            }
+        }
+    }
+}
+
+/**
+ * Asked when leaving the form with unsaved changes (#178). Dismissing keeps
+ * editing; a form with nothing changed closes without asking.
+ */
+@Composable
+private fun UnsavedChangesDialog(
+    onSave: () -> Unit,
+    onDiscard: () -> Unit,
+    onDismiss: () -> Unit,
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.event_edit_unsaved_title)) },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                OptionCard(
+                    label = stringResource(R.string.event_edit_unsaved_save),
+                    onClick = onSave,
+                )
+                OptionCard(
+                    label = stringResource(R.string.event_edit_unsaved_discard),
+                    onClick = onDiscard,
+                )
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = onDismiss) {
+                Text(stringResource(R.string.event_edit_unsaved_keep))
+            }
+        },
+    )
+}
+
 /**
  * Offer to apply the settings default reminder to an event opened from a `.ics`
  * file. The file's own reminders are kept unless the user accepts. A plain
@@ -501,8 +702,9 @@ private fun EventEditContent(
 ) {
     val form = state.form
     val locale = currentLocale()
+    val deviceZone by viewModel.zone.collectAsStateWithLifecycle()
     val firstDayOfWeek by viewModel.firstDayOfWeek.collectAsStateWithLifecycle()
-    val dark = isSystemInDarkTheme()
+    val dark = LocalFloretDarkTheme.current
     // The title, date and recurrence are managed by the special-dates sync, so
     // they're locked here; everything else (reminders, location, notes) is the
     // user's to edit.
@@ -662,9 +864,14 @@ private fun EventEditContent(
             },
         ) {
             Spacer(Modifier.height(4.dp))
+            val formZone = remember(form.timezone, deviceZone) { form.resolvedZone(deviceZone) }
+            val startAt = remember(form.start, formZone) { form.startInstant(formZone) }
+            val endAt = remember(form.end, formZone) { form.endInstant(formZone) }
             ScheduleRow(
                 label = stringResource(R.string.event_edit_starts),
-                dateTime = form.start,
+                dateTime = form.start.dateTime,
+                instant = startAt,
+                zone = formZone,
                 isAllDay = form.isAllDay,
                 locale = locale,
                 onDateClick = { picker = PickerTarget.StartDate },
@@ -673,7 +880,9 @@ private fun EventEditContent(
             )
             ScheduleRow(
                 label = stringResource(R.string.event_edit_ends),
-                dateTime = form.end,
+                dateTime = form.end.dateTime,
+                instant = endAt,
+                zone = formZone,
                 isAllDay = form.isAllDay,
                 locale = locale,
                 onDateClick = { picker = PickerTarget.EndDate },
@@ -692,20 +901,20 @@ private fun EventEditContent(
             // The rows above edit a pinned event in *its own* zone, which is the
             // time it was set at — but that says nothing about when it lands for
             // whoever is reading it. Spell the local equivalent out rather than
-            // leaving the user to do the offset arithmetic. Absent (null) unless
-            // the event is pinned somewhere other than here.
+            // leaving the user to do the offset arithmetic. Absent unless the
+            // event is pinned somewhere other than here.
             // Keyed rather than recomputed: this sits in the same Column as the
             // title field, so it would otherwise re-parse the zone on every
             // keystroke.
-            val localTimes = remember(form.timezone, form.start, form.end, form.isAllDay) {
-                form.timesIn(TimeZone.currentSystemDefault())
+            val pinnedAway = remember(form.timezone, form.isAllDay, deviceZone) {
+                form.isPinnedAwayFrom(deviceZone)
             }
-            localTimes?.let { (localStart, localEnd) ->
+            if (pinnedAway) {
                 Spacer(Modifier.height(2.dp))
                 Text(
                     text = stringResource(
                         R.string.event_edit_timezone_local_time,
-                        formatTimeRange(localStart, localEnd, locale),
+                        formatTimeRange(startAt, endAt, deviceZone, locale),
                     ),
                     style = MaterialTheme.typography.bodySmall,
                     color = MaterialTheme.colorScheme.onSurfaceVariant,
@@ -769,7 +978,7 @@ private fun EventEditContent(
                                 timeZoneOptionOf(
                                     id,
                                     locale,
-                                    at = form.start.toInstant(zone).toJavaInstant(),
+                                    at = form.startInstant(zone).toJavaInstant(),
                                     regionOf = ::icuTimeZoneRegion,
                                 )
                             }
@@ -2091,7 +2300,7 @@ private fun ColorPickerDialog(
     onClear: () -> Unit,
     onDismiss: () -> Unit,
 ) {
-    val dark = isSystemInDarkTheme()
+    val dark = LocalFloretDarkTheme.current
     FullScreenPicker(
         title = stringResource(R.string.event_edit_color),
         onDismiss = onDismiss,
@@ -2251,18 +2460,23 @@ private fun EditCard(
 }
 
 /**
- * "2:00 PM – 3:00 PM", honouring the user's 12/24-hour setting. Collapses to one
- * time when both land on the same minute (an instant event shouldn't read as a
- * range against itself). Dates are deliberately absent — the rows above carry
- * them.
+ * "2:00 PM – 3:00 PM" in [zone], honouring the user's 12/24-hour setting. Collapses
+ * to one time for an instant event, which shouldn't read as a range against
+ * itself. Dates are deliberately absent — the rows above carry them.
  */
 @Composable
-private fun formatTimeRange(start: LocalDateTime, end: LocalDateTime, locale: Locale): String {
+private fun formatTimeRange(start: Instant, end: Instant, zone: TimeZone, locale: Locale): String {
     val use24Hour = LocalUse24HourFormat.current
-    val timeFormat = remember(locale, use24Hour) { timeOfDayFormatter(use24Hour, locale) }
-    val from = timeFormat.format(start.time.toJavaLocalTime())
-    val to = timeFormat.format(end.time.toJavaLocalTime())
-    return if (from == to) from else "$from – $to"
+    return remember(start, end, zone, locale, use24Hour) {
+        val timeFormat = timeOfDayFormatter(use24Hour, locale)
+        fun format(at: Instant) = withRepeatedHourZone(
+            timeFormat.format(at.toLocalDateTime(zone).time.toJavaLocalTime()),
+            at,
+            zone,
+            locale,
+        )
+        if (start == end) format(start) else "${format(start)} – ${format(end)}"
+    }
 }
 
 /**
@@ -2344,6 +2558,8 @@ private fun firstLineHeight(
 private fun ScheduleRow(
     label: String,
     dateTime: LocalDateTime,
+    instant: Instant,
+    zone: TimeZone,
     isAllDay: Boolean,
     locale: Locale,
     onDateClick: () -> Unit,
@@ -2385,8 +2601,11 @@ private fun ScheduleRow(
                 .padding(vertical = 8.dp, horizontal = 6.dp),
         )
         if (!isAllDay) {
+            val time = remember(dateTime, instant, zone, locale, timeFormat) {
+                withRepeatedHourZone(timeFormat.format(dateTime.time.toJavaLocalTime()), instant, zone, locale)
+            }
             Text(
-                text = timeFormat.format(dateTime.time.toJavaLocalTime()),
+                text = time,
                 style = MaterialTheme.typography.titleMedium,
                 color = valueColor,
                 modifier = Modifier

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

@@ -77,6 +77,11 @@ sealed interface SaveUiState {
     data object Gone : SaveUiState
     data object Saving : SaveUiState
     data object Saved : SaveUiState
+    /** The event was deleted from the form (#178). */
+    data object Deleted : SaveUiState
+    data object DeleteFailed : SaveUiState
+    /** WRITE_CALENDAR was revoked before a delete from the form. */
+    data object DeleteDenied : SaveUiState
     /** WRITE_CALENDAR was revoked between the tap and the provider call. */
     data object NeedsPermission : SaveUiState
     data object Failed : SaveUiState

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

@@ -1,5 +1,6 @@
 package de.jeanlucmakiola.calendula.ui.edit
 
+import android.net.Uri
 import android.util.Log
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
@@ -7,8 +8,10 @@ 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
+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
@@ -18,14 +21,28 @@ 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
+import de.jeanlucmakiola.calendula.domain.startInstant
+import de.jeanlucmakiola.calendula.domain.withEnd
+import de.jeanlucmakiola.calendula.domain.withStart
+import de.jeanlucmakiola.calendula.domain.withTimes
+import de.jeanlucmakiola.calendula.domain.withTimezone
 import de.jeanlucmakiola.calendula.domain.EventFormField
 import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
+import de.jeanlucmakiola.calendula.domain.atOccurrence
 import de.jeanlucmakiola.calendula.domain.isEventTarget
 import de.jeanlucmakiola.calendula.domain.populatedFields
 import de.jeanlucmakiola.calendula.domain.problems
 import de.jeanlucmakiola.calendula.domain.toEditSnapshot
 import de.jeanlucmakiola.calendula.ui.detail.EventDetailViewModel.Companion.NO_OCCURRENCE_TIME
+import de.jeanlucmakiola.calendula.ui.common.DeleteOutcome
+import de.jeanlucmakiola.calendula.ui.common.tryDeleteEvent
+import de.jeanlucmakiola.calendula.ui.common.stageEventShare
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
@@ -132,9 +149,15 @@ class EventEditViewModel @Inject constructor(
     private val repository: CalendarRepository,
     private val prefs: CalendarPrefs,
     private val settingsPrefs: SettingsPrefs,
+    private val icsExporter: IcsExporter,
     @IoDispatcher private val io: CoroutineDispatcher,
+    private val zoneSource: ZoneSource,
 ) : ViewModel() {
 
+    /** The zone the form's unpinned times are read in, for the screen to show them in too. */
+    val zone: StateFlow<TimeZone> = zoneSource.zone
+        .stateIn(viewModelScope, SharingStarted.Eagerly, zoneSource.current())
+
     private val _form = MutableStateFlow<EventForm?>(null)
     private val _saveState = MutableStateFlow<SaveUiState>(SaveUiState.Idle)
     // Problems stay hidden until the first save attempt, so a half-filled
@@ -156,6 +179,11 @@ class EventEditViewModel @Inject constructor(
     // A one-time offer, raised when a .ics import opens, to replace the file's
     // reminders with the settings default (#49). Null while there's nothing to ask.
     private val _importReminderPrompt = MutableStateFlow<ImportReminderPrompt?>(null)
+    // The form as the user received it: the loaded event, or a new form with its
+    // prefill and auto-applied defaults. Anything else is an unsaved change.
+    private val _baseline = MutableStateFlow<EventForm?>(null)
+    // Bumped by reset(), so work started for a closed form never lands on the next.
+    private var session = 0
 
     /** True when the event to edit couldn't be loaded; the screen closes itself. */
     val loadFailed: StateFlow<Boolean> = _loadFailed.asStateFlow()
@@ -176,6 +204,8 @@ class EventEditViewModel @Inject constructor(
         val beginMillis: Long,
         val endMillis: Long,
         val zone: TimeZone,
+        /** The event as loaded, on the tapped occurrence's times — what Share exports. */
+        val detail: EventDetail,
     ) {
         val original: EventForm get() = snapshot.form
     }
@@ -289,7 +319,11 @@ class EventEditViewModel @Inject constructor(
         EventEditUiState(
             form = resolved,
             calendars = pickerCalendars,
-            problems = if (local.showProblems) resolved.problems() else emptySet(),
+            problems = if (local.showProblems) {
+                resolved.problems(zoneSource.current())
+            } else {
+                emptySet()
+            },
             saveState = local.saveState,
             visibleFields = visibleFields,
             hiddenFields = (offerableFields - visibleFields).sorted(),
@@ -311,6 +345,14 @@ class EventEditViewModel @Inject constructor(
             initialValue = null,
         )
 
+    /**
+     * Whether leaving now would lose something the user did (#178): the form
+     * differs from how it opened, counting the defaults it applied itself.
+     */
+    val hasUnsavedChanges: StateFlow<Boolean> = combine(_form, _baseline) { form, baseline ->
+        form != null && form != baseline
+    }.stateIn(viewModelScope, SharingStarted.Eagerly, false)
+
     /**
      * First day of the week for ordering the recurrence weekday toggles — the
      * app's "week starts on" preference, matching the calendar views (Auto
@@ -329,22 +371,32 @@ class EventEditViewModel @Inject constructor(
      */
     fun openNew(date: LocalDate, startMinutes: Int? = null) {
         if (_form.value != null) return
-        val zone = TimeZone.currentSystemDefault()
+        val zone = zoneSource.current()
         val now = Clock.System.now()
-        val start = when {
+        val startAt = when {
             startMinutes != null ->
-                LocalDateTime(date, LocalTime(startMinutes / 60, startMinutes % 60))
-            date == now.toLocalDateTime(zone).date -> {
-                // Today: the next full hour (may roll into tomorrow before midnight).
-                val hourMillis = 3_600_000L
-                val rounded = (now.toEpochMilliseconds() / hourMillis + 1) * hourMillis
-                Instant.fromEpochMilliseconds(rounded).toLocalDateTime(zone)
-            }
-            else -> LocalDateTime(date, LocalTime(9, 0))
+                LocalDateTime(date, LocalTime(startMinutes / 60, startMinutes % 60)).toInstant(zone)
+            date == now.toLocalDateTime(zone).date -> nextFullHour(now)
+            else -> LocalDateTime(date, LocalTime(9, 0)).toInstant(zone)
         }
-        val end = (start.toInstant(zone) + SettingsPrefs.DEFAULT_EVENT_DURATION.minutes)
-            .toLocalDateTime(zone)
-        _form.value = EventForm(calendarId = null, start = start, end = end)
+        val endAt = startAt + SettingsPrefs.DEFAULT_EVENT_DURATION.minutes
+        open(EventForm(calendarId = null, start = startAt.toFormTime(zone), end = endAt.toFormTime(zone)))
+        applyDefaultReminder()
+        applyDefaultDuration()
+    }
+
+    /**
+     * Initialise a fresh form for a block drafted on the timeline (#153), from
+     * [start] to [end]. These are the instants the block shows, so a time in the
+     * fall-back hour's repeat, or one moved out of the spring-forward gap, opens
+     * as drawn (#387). The user chose the length, so the default length doesn't
+     * apply. No-op when a form is already open, as [openNew].
+     */
+    fun openDraft(start: Instant, end: Instant) {
+        if (_form.value != null) return
+        val zone = zoneSource.current()
+        open(EventForm(calendarId = null, start = start.toFormTime(zone), end = end.toFormTime(zone)))
+        _durationTouched.value = true
         applyDefaultReminder()
         applyDefaultDuration()
     }
@@ -377,7 +429,7 @@ class EventEditViewModel @Inject constructor(
     fun openImported(form: EventForm, source: ImportSource) {
         if (_form.value != null || _editTarget.value != null) return
         _revealed.value = form.populatedFields()
-        _form.value = form
+        open(form)
         if (source.ownsDuration) _durationTouched.value = true else applyDefaultDuration()
         when (source) {
             ImportSource.Insert, ImportSource.InsertOpenEnded ->
@@ -402,16 +454,18 @@ class EventEditViewModel @Inject constructor(
      */
     private fun applyDefaultReminder(calendarId: Long? = null) {
         if (_editTarget.value != null || _remindersTouched.value) return
+        val opened = session
         viewModelScope.launch {
             val defaults = reminderDefaults()
             val targetId = calendarId ?: resolvedCalendarId.first()
             // Re-check after suspending: bail if the form closed or the user edited.
+            if (opened != session) return@launch
             val form = _form.value ?: return@launch
             if (_editTarget.value != null || _remindersTouched.value) return@launch
             val reminders = defaults.resolveFor(targetId, form.isAllDay)
-            // Write through update(): the duration default resolves in parallel,
-            // so both must compose onto the current form, not a pre-suspend copy.
-            update { it.copy(reminders = reminders) }
+            // The duration default resolves in parallel, so both must compose
+            // onto the current form, not a pre-suspend copy.
+            applyDefault { it.copy(reminders = reminders) }
             // Surface the section so an auto-applied default is visible and
             // removable, even when Reminders isn't a default-shown field.
             if (reminders.isNotEmpty()) {
@@ -440,6 +494,7 @@ class EventEditViewModel @Inject constructor(
      */
     private fun applyDefaultDuration(calendarId: Long? = null) {
         if (_editTarget.value != null || _durationTouched.value) return
+        val opened = session
         viewModelScope.launch {
             val global = settingsPrefs.defaultEventDurationMinutes.first()
             val overrides = settingsPrefs.perCalendarEventDuration.first()
@@ -451,14 +506,14 @@ class EventEditViewModel @Inject constructor(
                 else -> calendarId ?: resolvedCalendarId.first()
             }
             // Re-check after suspending: bail if the form closed or the user edited.
+            if (opened != session) return@launch
             if (_editTarget.value != null || _durationTouched.value) return@launch
             if (_form.value?.isAllDay != false) return@launch
             val duration = resolveDefaultEventDuration(global, overrides, targetId)
-            val zone = TimeZone.currentSystemDefault()
-            update { form ->
-                form.copy(
-                    end = (form.start.toInstant(zone) + duration.minutes).toLocalDateTime(zone),
-                )
+            applyDefault { form ->
+                val zone = form.resolvedZone(zoneSource.current())
+                val start = form.startInstant(zone)
+                form.withTimes(start, start + duration.minutes, zone)
             }
         }
     }
@@ -471,10 +526,12 @@ class EventEditViewModel @Inject constructor(
      * configured and it isn't already exactly what the file carried.
      */
     private fun maybePromptImportedReminderDefault(form: EventForm) {
+        val opened = session
         viewModelScope.launch {
             val targetId = resolvedCalendarId.first()
             val default = reminderDefaults().resolveFor(targetId, form.isAllDay)
             // Bail if the form closed or became an edit while we resolved.
+            if (opened != session) return@launch
             val current = _form.value ?: return@launch
             if (_editTarget.value != null) return@launch
             if (default.isEmpty() || default == current.reminders) return@launch
@@ -490,7 +547,7 @@ class EventEditViewModel @Inject constructor(
         val prompt = _importReminderPrompt.value ?: return
         _importReminderPrompt.value = null
         // Already frozen as touched by openImported; this just swaps the values.
-        update { it.copy(reminders = prompt.defaultReminders) }
+        edit { it.copy(reminders = prompt.defaultReminders) }
         _revealed.value = _revealed.value + EventFormField.Reminders
     }
 
@@ -510,31 +567,35 @@ class EventEditViewModel @Inject constructor(
      */
     fun openForEdit(eventId: Long, beginMillis: Long, endMillis: Long) {
         if (_form.value != null || _editTarget.value != null) return
+        val opened = session
         viewModelScope.launch {
             val detail = try {
                 repository.eventDetail(eventId)
             } catch (e: CancellationException) {
                 throw e
             } catch (e: Exception) {
-                _loadFailed.value = true
+                if (opened == session) _loadFailed.value = true
                 return@launch
             }
-            val zone = TimeZone.currentSystemDefault()
+            if (opened != session) return@launch
+            val zone = zoneSource.current()
             val begin = beginMillis.takeUnless { it == NO_OCCURRENCE_TIME }
                 ?: detail.instance.start.toEpochMilliseconds()
             val end = endMillis.takeUnless { it == NO_OCCURRENCE_TIME }
                 ?: detail.instance.end.toEpochMilliseconds()
             val snapshot = detail.toEditSnapshot(begin, end, zone)
-            _editTarget.value = EditTarget(eventId, snapshot, begin, end, zone)
+            _editTarget.value = EditTarget(eventId, snapshot, begin, end, zone, detail.atOccurrence(begin, end))
             // Sections holding data must show even when not in the defaults.
             _revealed.value = snapshot.form.populatedFields()
-            _form.value = snapshot.form
+            open(snapshot.form)
         }
     }
 
     /** Forget the open form; the next [openNew]/[openForEdit] starts clean. */
     fun reset() {
+        session++
         _form.value = null
+        _baseline.value = null
         _saveState.value = SaveUiState.Idle
         _showProblems.value = false
         _revealed.value = emptySet()
@@ -553,24 +614,28 @@ class EventEditViewModel @Inject constructor(
     // The title field wraps (multi-line) so long titles stay visible (#33), but
     // a title is one logical line: drop any newline the IME's Enter key or a
     // paste would introduce, so it never reaches the provider's TITLE column.
-    fun setTitle(value: String) = update {
+    fun setTitle(value: String) = edit {
         val cleaned = value.replace("\n", "").replace("\r", "")
         it.copy(title = capLength(cleaned, it.title))
     }
     // The location wraps too (#273) but is likewise one logical line. A pasted
     // multi-line address joins the way the contact picker's does (#146), so it
     // never runs together into "12 Main St10115 Berlin".
-    fun setLocation(value: String) = update {
+    fun setLocation(value: String) = edit {
         val cleaned = value.replace(LINE_BREAK, ", ")
         it.copy(location = capLength(cleaned, it.location))
     }
-    fun setDescription(value: String) = update { it.copy(description = value) }
+    fun setDescription(value: String) = edit { it.copy(description = value) }
     fun setAllDay(value: Boolean) {
         // Going all-day drops any pinned zone: the times become bare dates that
         // the provider stores UTC-anchored, so a zone could only misrepresent
         // them. Coming back out of all-day leaves the event on the device zone,
         // which is the same thing a fresh event gets.
-        update { it.copy(isAllDay = value, timezone = if (value) null else it.timezone) }
+        // A kept pass of a repeated hour stays, so switching back out of all-day
+        // lands where the event was — unless dropping the pin changed the zone.
+        edit {
+            if (value) it.withTimezone(null, zoneSource.current()).copy(isAllDay = true) else it.copy(isAllDay = false)
+        }
         // The default reminder differs for all-day vs timed; re-apply the
         // type-appropriate default unless the user has hand-edited it (guarded).
         applyDefaultReminder()
@@ -585,7 +650,7 @@ class EventEditViewModel @Inject constructor(
      * time — only real picks are remembered, not the device fallback.
      */
     fun setTimezone(zoneId: String?) {
-        update { it.copy(timezone = zoneId) }
+        edit { it.withTimezone(zoneId, zoneSource.current()) }
         if (zoneId != null) {
             viewModelScope.launch { withContext(io) { settingsPrefs.addRecentTimeZone(zoneId) } }
         }
@@ -597,35 +662,35 @@ class EventEditViewModel @Inject constructor(
      * The event falls back to the new calendar's colour until re-picked.
      */
     fun setCalendar(id: Long) {
-        update { it.copy(calendarId = id, colorKey = null, color = null) }
+        edit { it.copy(calendarId = id, colorKey = null, color = null) }
         // A fresh event re-inherits the new calendar's default reminder and
         // length unless the user has already hand-edited them (guarded inside).
         applyDefaultReminder(id)
         applyDefaultDuration(id)
     }
-    fun setAvailability(value: Availability) = update { it.copy(availability = value) }
-    fun setAccessLevel(value: AccessLevel) = update { it.copy(accessLevel = value) }
+    fun setAvailability(value: Availability) = edit { it.copy(availability = value) }
+    fun setAccessLevel(value: AccessLevel) = edit { it.copy(accessLevel = value) }
 
     /** Pick a palette colour (round-trips via its key); [argb] is its swatch. */
-    fun setColorKey(key: String, argb: Int) = update { it.copy(colorKey = key, color = argb) }
+    fun setColorKey(key: String, argb: Int) = edit { it.copy(colorKey = key, color = argb) }
 
     /** Pick a raw colour (local / opted-in calendars), clearing any palette key. */
-    fun setColorRaw(argb: Int) = update { it.copy(colorKey = null, color = argb) }
+    fun setColorRaw(argb: Int) = edit { it.copy(colorKey = null, color = argb) }
 
     /** Clear the colour so the event inherits its calendar's. */
-    fun clearColor() = update { it.copy(colorKey = null, color = null) }
+    fun clearColor() = edit { it.copy(colorKey = null, color = null) }
 
     /** Bare RRULE value from the recurrence picker; null = does not repeat. */
-    fun setRecurrence(rrule: String?) = update { it.copy(rrule = rrule) }
+    fun setRecurrence(rrule: String?) = edit { it.copy(rrule = rrule) }
 
     fun addReminder(minutes: Int) {
         _remindersTouched.value = true
-        update { it.copy(reminders = (it.reminders + minutes).distinct().sorted()) }
+        edit { it.copy(reminders = (it.reminders + minutes).distinct().sorted()) }
     }
 
     fun removeReminder(minutes: Int) {
         _remindersTouched.value = true
-        update { it.copy(reminders = it.reminders - minutes) }
+        edit { it.copy(reminders = it.reminders - minutes) }
     }
 
     /**
@@ -636,7 +701,7 @@ class EventEditViewModel @Inject constructor(
     fun addAttendee(email: String, name: String = "", optional: Boolean = false) {
         val trimmed = email.trim()
         if (trimmed.isEmpty()) return
-        update { form ->
+        edit { form ->
             val attendee = EventAttendee(email = trimmed, name = name.trim(), optional = optional)
             val rest = form.attendees.filterNot { it.email.equals(trimmed, ignoreCase = true) }
             form.copy(attendees = rest + attendee)
@@ -644,10 +709,10 @@ class EventEditViewModel @Inject constructor(
     }
 
     fun removeAttendee(attendee: EventAttendee) =
-        update { it.copy(attendees = it.attendees.filterNot { a -> a.email.equals(attendee.email, ignoreCase = true) }) }
+        edit { it.copy(attendees = it.attendees.filterNot { a -> a.email.equals(attendee.email, ignoreCase = true) }) }
 
     /** Flip a guest between required and optional (the per-row role toggle). */
-    fun setAttendeeOptional(attendee: EventAttendee, optional: Boolean) = update { form ->
+    fun setAttendeeOptional(attendee: EventAttendee, optional: Boolean) = edit { form ->
         form.copy(
             attendees = form.attendees.map { a ->
                 if (a.email.equals(attendee.email, ignoreCase = true)) a.copy(optional = optional) else a
@@ -663,12 +728,12 @@ class EventEditViewModel @Inject constructor(
     // default duration, so a later calendar switch keeps their span (#54).
     fun setEndDate(date: LocalDate) {
         _durationTouched.value = true
-        update { it.copy(end = LocalDateTime(date, it.end.time)) }
+        moveEnd { LocalDateTime(date, it.time) }
     }
 
     fun setEndTime(time: LocalTime) {
         _durationTouched.value = true
-        update { it.copy(end = LocalDateTime(it.end.date, time)) }
+        moveEnd { LocalDateTime(it.date, time) }
     }
 
     /**
@@ -681,7 +746,7 @@ class EventEditViewModel @Inject constructor(
         val current = state.value ?: return
         if (current.saveState == SaveUiState.Saving) return
         val form = current.form
-        if (form.problems().isNotEmpty()) {
+        if (form.problems(zoneSource.current()).isNotEmpty()) {
             _showProblems.value = true
             return
         }
@@ -726,8 +791,13 @@ class EventEditViewModel @Inject constructor(
         ignoreConflict: Boolean = false,
     ) {
         val target = _editTarget.value
+        val opened = session
+        // A form closed mid-save drops the result rather than handing it to the next one.
+        fun settle(result: SaveUiState) {
+            if (opened == session) _saveState.value = result
+        }
         viewModelScope.launch {
-            _saveState.value = SaveUiState.Saving
+            settle(SaveUiState.Saving)
             // No locking (plan 03, decision 5): right before writing, re-read
             // the event and compare against what the form loaded. An external
             // change parks the save in a conflict dialog instead of silently
@@ -739,18 +809,18 @@ class EventEditViewModel @Inject constructor(
                 } catch (e: CancellationException) {
                     throw e
                 } catch (e: NoSuchEventException) {
-                    _saveState.value = SaveUiState.Gone
+                    settle(SaveUiState.Gone)
                     return@launch
                 } catch (e: Exception) {
                     // Can't verify — proceed; a real problem fails the write itself.
                     null
                 }
                 if (fresh != null && fresh != target.snapshot) {
-                    _saveState.value = SaveUiState.AwaitingConflict(scope)
+                    settle(SaveUiState.AwaitingConflict(scope))
                     return@launch
                 }
             }
-            _saveState.value = try {
+            val result = try {
                 if (target == null) {
                     repository.createEvent(form)
                     prefs.setLastUsedCalendarId(requireNotNull(form.calendarId))
@@ -801,6 +871,37 @@ class EventEditViewModel @Inject constructor(
                 Log.w(TAG, "Save failed (scope=$scope, eventId=${target?.eventId})", e)
                 SaveUiState.Failed
             }
+            settle(result)
+        }
+    }
+
+    /** Whether the event being edited recurs; null while not editing. */
+    fun editedEventRecurs(): Boolean? = _editTarget.value?.let { !it.detail.rrule.isNullOrBlank() }
+
+    /** The form as it stands, as a fresh one-off event — Duplicate in the edit form (#178). */
+    fun duplicateForm(): EventForm? = state.value?.form?.copy(rrule = null)
+
+    /** A staged `.ics` of the event as saved, or null when it can't be built. */
+    suspend fun shareUri(): Uri? {
+        val detail = _editTarget.value?.detail ?: return null
+        return withContext(io) { icsExporter.stageEventShare(detail) }
+    }
+
+    /** Delete the event being edited, as far as [scope] reaches; result lands in [saveState]. */
+    fun delete(scope: RecurringWriteScope) {
+        val target = _editTarget.value ?: return
+        if (_saveState.value == SaveUiState.Saving) return
+        val opened = session
+        _saveState.value = SaveUiState.Saving
+        viewModelScope.launch {
+            val outcome = repository.tryDeleteEvent(target.eventId, target.beginMillis, scope)
+            if (opened != session) return@launch
+            _saveState.value = when (outcome) {
+                // Already gone is what a delete wants anyway.
+                DeleteOutcome.Deleted, DeleteOutcome.Gone -> SaveUiState.Deleted
+                DeleteOutcome.NeedsPermission -> SaveUiState.DeleteDenied
+                DeleteOutcome.Failed -> SaveUiState.DeleteFailed
+            }
         }
     }
 
@@ -809,15 +910,34 @@ class EventEditViewModel @Inject constructor(
         _saveState.value = SaveUiState.Idle
     }
 
-    private fun moveStart(transform: (LocalDateTime) -> LocalDateTime) = update { form ->
-        val zone = TimeZone.currentSystemDefault()
-        val newStart = transform(form.start)
-        val duration = form.end.toInstant(zone) - form.start.toInstant(zone)
-        val newEnd = (newStart.toInstant(zone) + duration).toLocalDateTime(zone)
-        form.copy(start = newStart, end = newEnd)
+    private fun moveStart(transform: (LocalDateTime) -> LocalDateTime) = edit { form ->
+        form.withStart(transform(form.start.dateTime), form.resolvedZone(zoneSource.current()), opened(form)?.start)
     }
 
-    private inline fun update(block: (EventForm) -> EventForm) {
+    private fun moveEnd(transform: (LocalDateTime) -> LocalDateTime) = edit { form ->
+        form.withEnd(transform(form.end.dateTime), form.resolvedZone(zoneSource.current()), opened(form)?.end)
+    }
+
+    /**
+     * The event as it was opened, while its times still mean the same instants:
+     * picking one of them again keeps its pass of a repeated hour (#387).
+     */
+    private fun opened(form: EventForm): EventForm? =
+        _editTarget.value?.original?.takeIf { it.timezone == form.timezone && !it.isAllDay }
+
+    private fun open(form: EventForm) {
+        _form.value = form
+        _baseline.value = form
+    }
+
+    /** A default the form applied itself; it moves the baseline too, so it's no unsaved change. */
+    private inline fun applyDefault(block: (EventForm) -> EventForm) {
+        _form.value = _form.value?.let(block)
+        _baseline.value = _baseline.value?.let(block)
+    }
+
+    /** A change the user made. */
+    private inline fun edit(block: (EventForm) -> EventForm) {
         _form.value = _form.value?.let(block)
     }
 }

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

@@ -24,6 +24,7 @@ import de.jeanlucmakiola.calendula.ui.common.morphEvent
 import de.jeanlucmakiola.calendula.ui.common.morphPageActive
 import de.jeanlucmakiola.calendula.ui.common.jumpToPage
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarPageSpec
+import de.jeanlucmakiola.floret.identity.LocalFloretDarkTheme
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.drop
 import androidx.compose.animation.ExperimentalSharedTransitionApi
@@ -46,7 +47,6 @@ import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.gestures.awaitEachGesture
 import androidx.compose.foundation.gestures.awaitFirstDown
-import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.BoxWithConstraints
@@ -589,7 +589,7 @@ private const val MONTH_SETTLE_TIMEOUT_MILLIS = 450L
 @Composable
 private fun MonthDragOverlay(controller: MonthDragController) {
     var origin by remember { mutableStateOf(Offset.Zero) }
-    val dark = isSystemInDarkTheme()
+    val dark = LocalFloretDarkTheme.current
     val density = LocalDensity.current
     val timeChipWidth = rememberMonthTimeChipWidth()
     val reduceMotion = rememberReduceMotion()
@@ -1722,7 +1722,7 @@ internal fun SplitMonthGrid(
     onSelectDay: (LocalDate) -> Unit,
     modifier: Modifier = Modifier,
 ) {
-    val dark = isSystemInDarkTheme()
+    val dark = LocalFloretDarkTheme.current
     val month = state.month
     val hasToday = state.today.year == month.year && state.today.month == month.month
     val ripple = rememberTodayRipple(active = hasToday)
@@ -2231,7 +2231,7 @@ private fun MonthWeekRow(
      */
     selected: LocalDate? = null,
 ) {
-    val dark = isSystemInDarkTheme()
+    val dark = LocalFloretDarkTheme.current
     val todayCol = week.days.indexOf(today).takeIf { it >= 0 && inMonth(today) }
     val ripple = rememberTodayRipple(active = todayCol != null)
     val overflowRow = rememberOverflowRowHeight()

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

@@ -8,7 +8,6 @@ import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.animation.AnimatedContent
 import androidx.compose.animation.animateColorAsState
 import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -83,6 +82,7 @@ import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
 import de.jeanlucmakiola.calendula.domain.SearchHit
 import de.jeanlucmakiola.calendula.domain.SearchMonth
 import de.jeanlucmakiola.calendula.domain.isDeclined
+import de.jeanlucmakiola.floret.identity.LocalFloretDarkTheme
 import de.jeanlucmakiola.floret.identity.animateItemMotion
 import de.jeanlucmakiola.floret.identity.fadeThrough
 import de.jeanlucmakiola.floret.identity.predictiveBack
@@ -513,7 +513,7 @@ private fun SearchResultRow(
     // Spans are empty for a blank title — the query never matches the
     // placeholder — so marking the substitute is safe.
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
-    val dark = isSystemInDarkTheme()
+    val dark = LocalFloretDarkTheme.current
     val soften = LocalSoftenColors.current
     // On a picked row the headline is already recoloured for the secondary
     // container, so the match is carried by weight alone there.

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

@@ -215,13 +215,13 @@ internal fun AppearanceScreen(
             selected = state.themeMode,
             label = { themeLabel(it) },
             summary = { mode ->
-                if (mode == ThemeMode.SYSTEM) {
-                    stringResource(
+                when (mode) {
+                    ThemeMode.SYSTEM -> stringResource(
                         R.string.settings_theme_system_summary,
                         themeLabel(if (systemDark) ThemeMode.DARK else ThemeMode.LIGHT),
                     )
-                } else {
-                    null
+                    ThemeMode.BLACK -> stringResource(R.string.settings_theme_black_summary)
+                    ThemeMode.LIGHT, ThemeMode.DARK -> null
                 }
             },
             onSelect = viewModel::setThemeMode,
@@ -258,6 +258,7 @@ private fun themeLabel(mode: ThemeMode): String = stringResource(
         ThemeMode.SYSTEM -> R.string.settings_theme_system
         ThemeMode.LIGHT -> R.string.settings_theme_light
         ThemeMode.DARK -> R.string.settings_theme_dark
+        ThemeMode.BLACK -> R.string.settings_theme_black
     },
 )
 

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

@@ -47,6 +47,8 @@ data class SettingsUiState(
     val todayButtonInToolbar: Boolean = false,
     /** Whether events can be dragged to another slot to reschedule them (#68, #173). */
     val dragToReschedule: Boolean = true,
+    /** Whether tapping an event opens the edit form instead of the detail screen (#178). */
+    val tapOpensEditor: Boolean = false,
     /** How far ahead the in-app Agenda screen shows events (v2.11). */
     val agendaScreenRange: AgendaRange = AgendaRange.Month,
     /** How far ahead the agenda widget shows events (v2.11). */

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

@@ -148,13 +148,16 @@ class SettingsViewModel @Inject constructor(
                     prefs.softenCalendarColors,
                     combine(
                         prefs.todayButtonInToolbar,
-                        prefs.dragToReschedule,
+                        combine(prefs.dragToReschedule, prefs.tapOpensEditor, ::Pair),
                         prefs.multiDayCount,
                         ::Triple,
                     ),
-                ) { hourLines, weekNumbers, showToday, soften, (todayInToolbar, dragToMove, multiDay) ->
+                ) { hourLines, weekNumbers, showToday, soften, (todayInToolbar, gestures, multiDay) ->
                     DisplayToggles(
-                        hourLines, weekNumbers, showToday, soften, todayInToolbar, dragToMove, multiDay,
+                        hourLines, weekNumbers, showToday, soften, todayInToolbar,
+                        dragToReschedule = gestures.first,
+                        tapOpensEditor = gestures.second,
+                        multiDayCount = multiDay,
                     )
                 },
             ) { view, screenRange, widgetRange, timeFormat, toggles ->
@@ -166,6 +169,7 @@ class SettingsViewModel @Inject constructor(
                     softenColors = toggles.softenColors,
                     todayButtonInToolbar = toggles.todayButtonInToolbar,
                     dragToReschedule = toggles.dragToReschedule,
+                    tapOpensEditor = toggles.tapOpensEditor,
                     multiDayCount = toggles.multiDayCount,
                 )
             },
@@ -202,6 +206,7 @@ class SettingsViewModel @Inject constructor(
                 softenColors = views.softenColors,
                 todayButtonInToolbar = views.todayButtonInToolbar,
                 dragToReschedule = views.dragToReschedule,
+                tapOpensEditor = views.tapOpensEditor,
                 multiDayCount = views.multiDayCount,
                 agendaShowRangeBar = misc.showRangeBar,
                 autofocusEventTitle = misc.autofocusEventTitle,
@@ -305,6 +310,7 @@ class SettingsViewModel @Inject constructor(
         val softenColors: Boolean,
         val todayButtonInToolbar: Boolean,
         val dragToReschedule: Boolean,
+        val tapOpensEditor: Boolean,
         val multiDayCount: Int,
     )
 
@@ -315,6 +321,7 @@ class SettingsViewModel @Inject constructor(
         val softenColors: Boolean,
         val todayButtonInToolbar: Boolean,
         val dragToReschedule: Boolean,
+        val tapOpensEditor: Boolean,
         val multiDayCount: Int,
     )
 
@@ -562,6 +569,10 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch { prefs.setDragToReschedule(enabled) }
     }
 
+    fun setTapOpensEditor(enabled: Boolean) {
+        viewModelScope.launch { prefs.setTapOpensEditor(enabled) }
+    }
+
     /**
      * Switch the launcher label (#44). The card highlights at once, then settles
      * on what the component state reports; the writes are binder round-trips and

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

@@ -74,6 +74,7 @@ internal fun ViewsScreen(
     var showDefaultView by remember { mutableStateOf(false) }
     var showWeekStart by remember { mutableStateOf(false) }
     var showTimeFormat by remember { mutableStateOf(false) }
+    var showTapOpens by remember { mutableStateOf(false) }
     var showPastEvents by remember { mutableStateOf(false) }
     var showAgendaScreenRange by remember { mutableStateOf(false) }
     var showTimelineScale by remember { mutableStateOf(false) }
@@ -125,7 +126,7 @@ internal fun ViewsScreen(
         GroupedRow(
             title = stringResource(R.string.settings_dim_completed),
             summary = stringResource(R.string.settings_dim_completed_summary),
-            position = Position.Middle,
+            position = Position.Bottom,
             trailing = {
                 Switch(
                     checked = state.dimCompletedEvents,
@@ -134,6 +135,17 @@ internal fun ViewsScreen(
             },
             onClick = { viewModel.setDimCompletedEvents(!state.dimCompletedEvents) },
         )
+
+        Spacer(Modifier.height(8.dp))
+
+        // How events respond to a tap and a long press (#178, #141).
+        SectionHeader(stringResource(R.string.settings_events_header))
+        GroupedRow(
+            title = stringResource(R.string.settings_tap_opens),
+            summary = tapOpensLabel(state.tapOpensEditor),
+            position = Position.Top,
+            onClick = { showTapOpens = true },
+        )
         GroupedRow(
             title = stringResource(R.string.settings_drag_to_reschedule),
             summary = stringResource(R.string.settings_drag_to_reschedule_summary),
@@ -387,6 +399,18 @@ internal fun ViewsScreen(
             onDismiss = { showTimeFormat = false },
         )
     }
+    if (showTapOpens) {
+        OptionPicker(
+            title = stringResource(R.string.settings_tap_opens),
+            header = { PickerDescription(stringResource(R.string.settings_tap_opens_hint)) },
+            predictiveBack = true,
+            options = listOf(false, true),
+            selected = state.tapOpensEditor,
+            label = { tapOpensLabel(it) },
+            onSelect = viewModel::setTapOpensEditor,
+            onDismiss = { showTapOpens = false },
+        )
+    }
     if (showPastEvents) {
         PastEventsPicker(
             selected = state.pastEventDisplay,
@@ -522,6 +546,11 @@ internal fun weekStartLabel(pref: WeekStartPref): String = when (pref) {
         .getDisplayName(JavaTextStyle.FULL, currentLocale())
 }
 
+@Composable
+private fun tapOpensLabel(editor: Boolean): String = stringResource(
+    if (editor) R.string.settings_tap_opens_editor else R.string.settings_tap_opens_details,
+)
+
 @Composable
 private fun timeFormatLabel(pref: TimeFormatPref): String = stringResource(
     when (pref) {

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

@@ -16,13 +16,15 @@ import de.jeanlucmakiola.floret.identity.FloretExpressiveTheme
  *
  * The mechanics live in floret-kit's identity module; the look stays here, so a
  * sibling app reuses the same theming without inheriting Calendula's palette.
- * The Settings screen overrides darkTheme, dynamicColor and typography; the bare
- * defaults (used by the crash screen) just follow the system.
+ * The Settings screen overrides darkTheme, dynamicColor, pureBlack (the
+ * AMOLED theme, #181) and typography; the bare defaults (used by the crash
+ * screen) just follow the system.
  */
 @Composable
 fun CalendulaTheme(
     darkTheme: Boolean = isSystemInDarkTheme(),
     dynamicColor: Boolean = true,
+    pureBlack: Boolean = false,
     typography: Typography = CalendulaTypography,
     content: @Composable () -> Unit,
 ) {
@@ -31,6 +33,7 @@ fun CalendulaTheme(
         darkScheme = CalendulaDarkFallback,
         darkTheme = darkTheme,
         dynamicColor = dynamicColor,
+        pureBlack = pureBlack,
         typography = typography,
         content = content,
     )

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

@@ -0,0 +1,45 @@
+package de.jeanlucmakiola.calendula.ui.theme
+
+import android.content.Context
+import androidx.annotation.ColorRes
+import androidx.core.content.edit
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
+
+/**
+ * A synchronous copy of the theme choice, for the window backdrop drawn before
+ * the first Compose frame. The real setting lives in DataStore, which only
+ * answers asynchronously — too late for onCreate, so a Light, Dark or Black
+ * override flashed the night-qualifier backdrop on a cold start or a
+ * recreation (#181). MainActivity mirrors every stored value here and reads it
+ * back before setContent.
+ */
+internal object WindowThemeCache {
+
+    private const val FILE = "window_theme"
+    private const val KEY_THEME_MODE = "theme_mode"
+
+    /** The last mirrored theme choice, or null before the first mirror. */
+    fun read(context: Context): ThemeMode? =
+        context.getSharedPreferences(FILE, Context.MODE_PRIVATE)
+            .getString(KEY_THEME_MODE, null)
+            ?.let { name -> ThemeMode.entries.firstOrNull { it.name == name } }
+
+    fun write(context: Context, mode: ThemeMode) {
+        val prefs = context.getSharedPreferences(FILE, Context.MODE_PRIVATE)
+        if (prefs.getString(KEY_THEME_MODE, null) == mode.name) return
+        prefs.edit { putString(KEY_THEME_MODE, mode.name) }
+    }
+}
+
+/**
+ * The window backdrop matching this theme choice's Compose background, or null
+ * for [ThemeMode.SYSTEM], whose night-qualified theme default already matches.
+ */
+@ColorRes
+internal fun ThemeMode.windowBackgroundRes(): Int? = when (this) {
+    ThemeMode.SYSTEM -> null
+    ThemeMode.LIGHT -> R.color.window_background_light
+    ThemeMode.DARK -> R.color.window_background_dark
+    ThemeMode.BLACK -> R.color.window_background_black
+}

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

@@ -20,12 +20,12 @@ import de.jeanlucmakiola.calendula.ui.common.rememberCalendarPageSpec
 import de.jeanlucmakiola.calendula.ui.common.rememberViewSwitchSpec
 import de.jeanlucmakiola.calendula.ui.common.jumpToPage
 import de.jeanlucmakiola.calendula.ui.common.pagedHeight
+import de.jeanlucmakiola.floret.identity.LocalFloretDarkTheme
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.drop
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.BoxWithConstraints
 import androidx.compose.foundation.layout.Column
@@ -52,6 +52,7 @@ import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.key
@@ -64,6 +65,15 @@ import androidx.compose.ui.hapticfeedback.HapticFeedbackType
 import androidx.compose.ui.platform.LocalHapticFeedback
 import androidx.compose.ui.zIndex
 import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.toArgb
+import de.jeanlucmakiola.calendula.ui.common.draftBlock
+import de.jeanlucmakiola.calendula.ui.common.draftEvent
+import de.jeanlucmakiola.calendula.ui.common.draftStartMin
+import de.jeanlucmakiola.calendula.ui.common.isDraft
+import de.jeanlucmakiola.calendula.ui.common.rememberDragSurface
+import de.jeanlucmakiola.calendula.ui.common.rememberWriteGate
+import de.jeanlucmakiola.calendula.ui.common.OutOfViewEdges
+import de.jeanlucmakiola.calendula.ui.common.wallClockInstant
 import de.jeanlucmakiola.calendula.ui.common.PickUp
 import de.jeanlucmakiola.calendula.ui.common.SelectionBarClearance
 import de.jeanlucmakiola.calendula.ui.common.ResizeEdge
@@ -90,6 +100,7 @@ import androidx.compose.runtime.SideEffect
 import de.jeanlucmakiola.calendula.ui.common.laneSlot
 import de.jeanlucmakiola.calendula.ui.common.LaneColumn
 import kotlin.math.roundToInt
+import kotlin.time.Instant
 import androidx.compose.ui.unit.Constraints
 import androidx.compose.ui.layout.Layout
 import androidx.compose.ui.draw.alpha
@@ -239,6 +250,7 @@ fun TimelineScreen(
     onOpenDay: (LocalDate) -> Unit,
     onEventClick: (EventInstance) -> Unit,
     onCreateEvent: (LocalDate, Int?) -> Unit,
+    onCreateDraft: (Instant, Instant) -> Unit,
     modifier: Modifier = Modifier,
     weekViewModel: WeekViewModel = hiltViewModel(),
     multiDayViewModel: MultiDayViewModel = hiltViewModel(),
@@ -253,6 +265,7 @@ fun TimelineScreen(
         onOpenDay = onOpenDay,
         onEventClick = onEventClick,
         onCreateEvent = onCreateEvent,
+        onCreateDraft = onCreateDraft,
         modifier = modifier,
     )
 }
@@ -299,6 +312,12 @@ internal val CalendarView.timelineKind: TimelineKind
         else -> TimelineKind.Week
     }
 
+/**
+ * The zone the shown timeline is laid out in, so its blocks, drags and drops all
+ * read the same wall clock (#387).
+ */
+internal val LocalTimelineZone = staticCompositionLocalOf { TimeZone.currentSystemDefault() }
+
 /** How long a switch waits for the view it goes to before resizing into it without its events. */
 private const val MORPH_DATA_WAIT_MS = 150L
 
@@ -310,6 +329,7 @@ private fun PagedTimelineScreen(
     onOpenDay: (LocalDate) -> Unit,
     onEventClick: (EventInstance) -> Unit,
     onCreateEvent: (LocalDate, Int?) -> Unit,
+    onCreateDraft: (Instant, Instant) -> Unit,
     modifier: Modifier,
 ) {
     // The view on screen, which trails [view] while the columns resize into it.
@@ -342,6 +362,7 @@ private fun PagedTimelineScreen(
     val grid = position.grid
     val anchorPage = position.page
     val dimCompleted by key(viewModel) { viewModel.dimCompletedEvents.collectAsStateWithLifecycle() }
+    val draftMinutes by key(viewModel) { viewModel.defaultEventDuration.collectAsStateWithLifecycle() }
     // The instant before which an event counts as completed, or null when dimming
     // is off. derivedStateOf keeps the per-minute "now" from recomposing the
     // screen while the setting is off (it stays null regardless of the tick).
@@ -435,7 +456,8 @@ private fun PagedTimelineScreen(
 
     // Off the ticking clock rather than the loaded page, so it turns over at
     // midnight; derived, so the per-minute tick doesn't recompose the screen.
-    val zone = remember { TimeZone.currentSystemDefault() }
+    // The timeline's own zone, so "today" agrees with the blocks and drops (#387).
+    val zone by viewModel.zone.collectAsStateWithLifecycle()
     val today by remember(zone) { derivedStateOf { nowState.value.toLocalDateTime(zone).date } }
     val isOnCurrentWeek = state !is WeekUiState.Success || (today >= weekStart && today <= weekEnd)
 
@@ -476,7 +498,10 @@ private fun PagedTimelineScreen(
     )
 
     ScreenBody(modifier = modifier) { innerPadding ->
-        CompositionLocalProvider(LocalDimCutoff provides dimCutoff) {
+        CompositionLocalProvider(
+            LocalDimCutoff provides dimCutoff,
+            LocalTimelineZone provides zone,
+        ) {
             WeekContent(
                 state = state,
                 today = today,
@@ -490,6 +515,8 @@ private fun PagedTimelineScreen(
                 onEventClick = onEventClick,
                 onOpenDay = onOpenDay,
                 onCreateAt = { d, minutes -> onCreateEvent(d, minutes) },
+                onCreateDraft = onCreateDraft,
+                draftMinutes = draftMinutes,
                 modifier = Modifier
                     .padding(innerPadding)
                     .fillMaxSize(),
@@ -512,6 +539,8 @@ private fun WeekContent(
     onEventClick: (EventInstance) -> Unit,
     onOpenDay: (LocalDate) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
+    onCreateDraft: (Instant, Instant) -> Unit,
+    draftMinutes: Int,
     modifier: Modifier = Modifier,
 ) {
     val fadeSpec = rememberCalendarFadeSpec()
@@ -526,33 +555,39 @@ private fun WeekContent(
     // Above the pager: a page change mid-drag would strand the floating block
     // inside the outgoing page.
     val dragController = rememberTimelineDragController()
+    SideEffect { dragController.draftMinutes = draftMinutes }
     val move = LocalEventMove.current
-    val zone = remember { TimeZone.currentSystemDefault() }
-    val onDrop: (TimelineDrop) -> Unit = { drop ->
+    val zone = LocalTimelineZone.current
+    val onDrop: (TimelineDrop) -> Unit = drop@{ drop ->
+        val start = drop.startInstant(zone)
+        val moved = drop.event.copy(start = start, end = start + (drop.event.end - drop.event.start))
+        // A draft has nothing to write, so it stays selected where it landed (#153).
+        if (drop.event.isDraft) {
+            dragController.select(moved)
+            return@drop
+        }
         // A selected event stays selected where it landed (#141).
         if (dragController.selection?.event?.instanceId == drop.event.instanceId) {
-            val start = drop.startInstant(zone)
-            dragController.select(
-                drop.event.copy(start = start, end = start + (drop.event.end - drop.event.start)),
-                moved = true,
-            )
+            dragController.select(moved, moved = true)
         }
         move?.move(
             MoveRequest(
                 eventId = drop.event.eventId,
                 beginMillis = drop.event.start.toEpochMilliseconds(),
                 endMillis = drop.event.end.toEpochMilliseconds(),
-                target = MoveTarget.Start(drop.startInstant(zone)),
+                target = MoveTarget.Start(start),
             ),
         )
     }
 
     // A resize keeps its event selected, at its new length (#141).
-    val onResize: (TimelineResizeDrop) -> Unit = { drop ->
-        dragController.select(
-            drop.event.copy(start = drop.start, end = drop.end),
-            moved = true,
-        )
+    val onResize: (TimelineResizeDrop) -> Unit = resize@{ drop ->
+        val resized = drop.event.copy(start = drop.start, end = drop.end)
+        if (drop.event.isDraft) {
+            dragController.select(resized)
+            return@resize
+        }
+        dragController.select(resized, moved = true)
         move?.move(
             MoveRequest(
                 eventId = drop.event.eventId,
@@ -563,6 +598,13 @@ private fun WeekContent(
         )
     }
 
+    // A drafted block (#153) opens the new-event form at its own instants: the
+    // end it is drawn to differs on a DST change (#387).
+    val createDraft: (EventInstance) -> Unit = { draft ->
+        dragController.deselect()
+        onCreateDraft(draft.start, draft.end)
+    }
+
     // Selection (#141) ends on back, a page or view change, or any tap.
     val selection = dragController.selection
     PublishSelection(
@@ -570,10 +612,15 @@ private fun WeekContent(
         busy = dragController.isDragging,
         compact = dragController.selectionCovered,
         onDismiss = dragController::deselect,
+        onCreate = selection?.event?.takeIf { it.isDraft }?.let { draft -> { createDraft(draft) } },
     )
     BackHandler(enabled = selection != null) { dragController.deselect() }
     LaunchedEffect(pagerState, dragController) {
-        snapshotFlow { pagerState.currentPage }.drop(1).collect { dragController.deselect() }
+        snapshotFlow { pagerState.currentPage }.drop(1).collect {
+            // Deselecting would delete a draft mid-drag, so it stays until it lands.
+            val draftInFlight = dragController.isDragging && dragController.selection?.event?.isDraft == true
+            if (!draftInFlight) dragController.deselect()
+        }
     }
     LaunchedEffect(morph != null) { if (morph != null) dragController.deselect() }
     LaunchedEffect(selection, dragController.settling, dragController.isDragging, dragController.selectedCandidates.size) {
@@ -587,9 +634,14 @@ private fun WeekContent(
         delay(SELECTION_ORPHAN_GRACE_MILLIS)
         dragController.deselect()
     }
+    val requireWrite = rememberWriteGate()
     val openEvent: (EventInstance) -> Unit = { event ->
-        dragController.deselect()
-        onEventClick(event)
+        if (event.isDraft) {
+            requireWrite { createDraft(event) }
+        } else {
+            dragController.deselect()
+            onEventClick(event)
+        }
     }
 
     Box(modifier = modifier) {
@@ -1136,7 +1188,7 @@ private fun AllDayStrip(
     animatedHeight: (() -> Dp)? = null,
     onEventClick: (EventInstance) -> Unit,
 ) {
-    val dark = isSystemInDarkTheme()
+    val dark = LocalFloretDarkTheme.current
 
     Row(
         modifier = Modifier
@@ -1243,7 +1295,7 @@ private fun Timeline(
     onResize: (TimelineResizeDrop) -> Unit,
 ) {
     val fullViewportHeight = remember(geometry) { intArrayOf(-1) }
-    val dark = isSystemInDarkTheme()
+    val dark = LocalFloretDarkTheme.current
     val zoom = LocalTimelineZoom.current
     val density = LocalDensity.current
     val isRtl = LocalLayoutDirection.current == LayoutDirection.Rtl
@@ -1369,10 +1421,16 @@ private fun DayColumnCard(
     val hourPx = with(density) { hourHeight.toPx() }
     val morphing = LocalViewMorph.current != null
     val showHourGrid = LocalShowHourGrid.current
-    val zone = remember { TimeZone.currentSystemDefault() }
+    val zone = LocalTimelineZone.current
+    // A block drafted on an empty slot (#153), drawn over the part of it on this day.
+    val draft by remember(dragController) {
+        derivedStateOf { dragController.selection?.event?.takeIf { it.isDraft } }
+    }
+    val draftPiece = remember(draft, date, zone) { draft?.let { draftBlock(it, date, zone) } }
+    val shown = remember(blocks, draftPiece) { if (draftPiece == null) blocks else blocks + draftPiece }
     // Tells a settled drop when this column has caught up with it.
-    LaunchedEffect(blocks, dragController.settling) {
-        dragController.noteGrid(date, blocks)
+    LaunchedEffect(shown, dragController.settling) {
+        dragController.noteGrid(date, shown)
     }
     // The tap detector outlives the composition that installed it — a pinch or a
     // Settings change moves the hour height without restarting it — so it reads
@@ -1382,6 +1440,7 @@ private fun DayColumnCard(
     val currentOnCreateAt = rememberUpdatedState(onCreateAt)
     val edges = rememberOutOfViewEdges(blocks, scrollState, hourPx)
     val currentEdges = rememberUpdatedState(edges)
+    val draftSurface = rememberDraftSurface(date, edges, hourPx, dragController, onDrop)
     Card(
         // Plain rectangular columns — the soft corners come from the outer
         // rounded scroll viewport, so inner rounding would look odd at the edges.
@@ -1420,14 +1479,17 @@ private fun DayColumnCard(
                             tappedMinuteOfDay(offset.y, currentHourPx.value),
                         )
                     }
-                },
+                }
+                // Inside the tap detector, which consumes every down, so only a
+                // block or handle on top can claim the press first.
+                .then(draftSurface),
         ) {
             val minEventHeight = hourHeight * MIN_EVENT_FRACTION
             // Keyed by event, so a block that changes time or lane is the *same*
             // composable afterwards and tweens there. The ordinal disambiguates
             // a column holding two occurrences of one series.
             val ordinals = mutableMapOf<Long, Int>()
-            blocks.forEach { block ->
+            shown.forEach { block ->
                 val ordinal = ordinals.merge(block.event.eventId, 1, Int::plus)!! - 1
                 key(block.event.eventId, ordinal) {
                     val top = hourHeight * (block.startMin / 60f)
@@ -1438,6 +1500,7 @@ private fun DayColumnCard(
                         widthFraction = 1f / block.laneCount,
                         y = top,
                         height = height,
+                        landing = dragController.ghosts(block),
                     )
                     // Where this block is cut at midnight, which decides both
                     // its shape and the half-gap it gives up to the hour cells.
@@ -1524,8 +1587,10 @@ private fun EventBlock(
     val title = block.event.title.ifBlank { stringResource(R.string.event_untitled) }
     val use24Hour = LocalUse24HourFormat.current
     val locale = currentLocale()
+    val zone = LocalTimelineZone.current
+    val labelEndMin = remember(block, date, zone) { block.labelEndMin(date, zone) }
     val timeLabel = "${minToHm(block.startMin, use24Hour, locale)}–" +
-        minToHm(block.endMin, use24Hour, locale)
+        minToHm(labelEndMin, use24Hour, locale)
     val density = LocalDensity.current
     val metrics = rememberBlockTextMetrics(height)
     // Only full-width (non-overlapping) blocks that are tall enough show the
@@ -1539,7 +1604,7 @@ private fun EventBlock(
     val textWidth = width - (BLOCK_OUTER_INSET + BLOCK_TEXT_PADDING) * 2
     val shownTime = rememberBlockTimeRange(
         minToHm(block.startMin, use24Hour, locale),
-        minToHm(block.endMin, use24Hour, locale),
+        minToHm(labelEndMin, use24Hour, locale),
         textWidth,
     )
     // A short block drops the title rather than serving a horizontally sliced
@@ -1570,9 +1635,9 @@ private fun EventBlock(
     val timeMaxLines = if (showTime) blockTimeLines(shownTime, textWidth, spare) else 1
     val dimCutoff = LocalDimCutoff.current
     val dimmed = dimCutoff != null && block.event.isPastOn(date, dimCutoff)
-    val zone = remember { TimeZone.currentSystemDefault() }
     val moveAction = eventMoveAction(block.event)
-    val draggable = eventDragAllowed(block.event)
+    val draft = block.event.isDraft
+    val draggable = draft || eventDragAllowed(block.event)
     val selectable = eventSelectAllowed()
     val selected = dragController.isSelected(block)
     val haptics = LocalHapticFeedback.current
@@ -1591,6 +1656,7 @@ private fun EventBlock(
                 dragController.begin(
                     block = block,
                     clipOffsetMin = clipOffset,
+                    zone = zone,
                     titleLines = if (showTitle) titleMaxLines else 0,
                     pointerInRoot = pointer,
                     // Measured off the block's placement rather than off where the
@@ -1614,7 +1680,12 @@ private fun EventBlock(
     // Released in place, the block takes over the copy's lift without a dip.
     val takesOverLift = selected && dragController.selection?.fromLift == true
     val ghostFade = ghostAlpha(lifted)
-    val ghost = if (takesOverLift && !lifted) 1f else ghostFade
+    val ghost = when {
+        takesOverLift && !lifted -> 1f
+        // A draft leaves no ghost behind, and the copy it lands under is identical.
+        draft -> if (lifted) 0f else 1f
+        else -> ghostFade
+    }
     val raise = selectionLift(selected, snap = takesOverLift)
     // Tells the action bar to fold when it would cover the bottom handle.
     val revealExtraPx = with(density) { (ResizeHandleTarget / 2).toPx() }
@@ -1689,9 +1760,10 @@ private fun EventBlock(
                 }
             }
             val end = { dragController.finishResize(zone)?.let(onResize) }
+            // No bounce: an overshoot reads as the block's ends jumping.
             val handleIn by animateFloatAsState(
                 targetValue = if (handlesShown) 1f else 0f,
-                animationSpec = MaterialTheme.motionScheme.fastSpatialSpec(),
+                animationSpec = MaterialTheme.motionScheme.fastEffectsSpec(),
                 label = "handles",
             )
             val handleAlpha = Modifier.graphicsLayer {
@@ -1731,6 +1803,63 @@ private fun EventBlock(
     }
 }
 
+/**
+ * A long press on an empty stretch of [date]'s column (#153): drafts a block of
+ * the default length from the slot under the finger and lifts it, as a long
+ * press on an event does. Presses on a block or handle are left to them.
+ */
+@Composable
+private fun rememberDraftSurface(
+    date: LocalDate,
+    edges: OutOfViewEdges,
+    hourPx: Float,
+    dragController: TimelineDragController,
+    onDrop: (TimelineDrop) -> Unit,
+): Modifier {
+    val currentDrop by rememberUpdatedState(onDrop)
+    val title = stringResource(R.string.event_edit_new_title)
+    val color = MaterialTheme.colorScheme.primary.toArgb()
+    val zone = LocalTimelineZone.current
+    val currentEdges by rememberUpdatedState(edges)
+    // The draft this gesture lifted, selected again on release after the cancel.
+    val lifted = remember { arrayOfNulls<EventInstance>(1) }
+    val currentHourPx by rememberUpdatedState(hourPx)
+    return rememberDragSurface(
+        enabled = eventSelectAllowed(),
+        key = date,
+        skipClaimedDown = true,
+        // A press on a block or handle was consumed by it and never gets here.
+        onPickUp = { local, pointer, node, _ ->
+            val hour = currentHourPx
+            if (hour <= 0f || currentEdges.covers(local.y)) return@rememberDragSurface false
+            val startMin = draftStartMin(local.y / hour * 60f)
+            val event = draftEvent(
+                title = title,
+                color = color,
+                start = wallClockInstant(date, startMin, zone),
+                minutes = dragController.draftMinutes,
+            )
+            val block = draftBlock(event, date, zone) ?: return@rememberDragSurface false
+            lifted[0] = event
+            dragController.beginDraft(
+                block = block,
+                zone = zone,
+                pointerInRoot = pointer,
+                blockInRoot = node + Offset(0f, startMin / 60f * hour),
+            )
+            true
+        },
+        onMove = dragController::move,
+        onDrop = { dragController.finish()?.let(currentDrop) },
+        // An abandoned pickup leaves no draft behind; a release selects it again below.
+        onCancel = {
+            dragController.cancel()
+            if (dragController.selection?.event?.isDraft == true) dragController.deselect()
+        },
+        onRelease = { lifted[0]?.let { dragController.select(it, fromLift = true) } },
+    )
+}
+
 private const val SELECTION_ORPHAN_GRACE_MILLIS = 500L
 
 /** How far in from the block's side a resize handle's centre sits. */

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

@@ -8,6 +8,7 @@ import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import de.jeanlucmakiola.calendula.data.time.TodaySource
+import de.jeanlucmakiola.calendula.data.time.ZoneSource
 import de.jeanlucmakiola.calendula.data.time.currentDate
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventInstance
@@ -34,7 +35,10 @@ import kotlinx.coroutines.flow.stateIn
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
+import kotlinx.datetime.FixedOffsetTimeZone
 import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toKotlinUtcOffset
+import kotlinx.datetime.toJavaZoneId
 import kotlinx.datetime.atStartOfDayIn
 import kotlinx.datetime.atTime
 import kotlinx.datetime.daysUntil
@@ -44,6 +48,8 @@ import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
 import java.util.Locale
 import kotlin.time.Instant
+import kotlin.time.toKotlinDuration
+import kotlin.time.toKotlinInstant
 import javax.inject.Inject
 import kotlin.math.abs
 
@@ -76,12 +82,18 @@ abstract class PagedTimelineViewModel(
     private val repository: CalendarRepository,
     settingsPrefs: SettingsPrefs,
     todaySource: TodaySource,
+    zoneSource: ZoneSource,
     private val io: CoroutineDispatcher,
     gridRule: Flow<(LocalDate) -> PageGrid>,
     initialRule: (LocalDate) -> PageGrid,
 ) : ViewModel() {
 
-    private val zone = TimeZone.currentSystemDefault()
+    /**
+     * The zone every page is laid out in; drags and drops resolve in it too, and
+     * pages lay out again when the device moves zones (#387).
+     */
+    val zone: StateFlow<TimeZone> = zoneSource.zone
+        .stateIn(viewModelScope, SharingStarted.Eagerly, zoneSource.current())
 
     /** Whether to fade events that have already finished (display concern only). */
     val dimCompletedEvents: StateFlow<Boolean> = settingsPrefs.dimCompletedEvents
@@ -91,6 +103,14 @@ abstract class PagedTimelineViewModel(
             initialValue = false,
         )
 
+    /** How long a block drafted on an empty slot starts out (#153). */
+    val defaultEventDuration: StateFlow<Int> = settingsPrefs.defaultEventDurationMinutes
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = SettingsPrefs.DEFAULT_EVENT_DURATION,
+        )
+
     private val todayDate: LocalDate
         get() = currentDate()
 
@@ -152,12 +172,14 @@ abstract class PagedTimelineViewModel(
                 abs(cached.start.daysUntil(requested.start)) <= SPAN_CACHE_DAYS
         },
     ) { span ->
-        combine(
-            repository.calendars(),
-            repository.instances(spanRange(span.start, span.count, zone)),
-            today,
-        ) { calendars, instances, today ->
-            buildState(span, calendars, instances, today)
+        zone.flatMapLatest { zone ->
+            combine(
+                repository.calendars(),
+                repository.instances(spanRange(span.start, span.count, zone)),
+                today,
+            ) { calendars, instances, today ->
+                buildState(span, calendars, instances, today, zone)
+            }
         }
             .catch { emit(WeekUiState.Failure(FailureReason.ProviderUnavailable)) }
             .flowOn(io)
@@ -192,6 +214,7 @@ abstract class PagedTimelineViewModel(
         calendars: List<CalendarSource>,
         instances: List<EventInstance>,
         today: LocalDate,
+        zone: TimeZone,
     ): WeekUiState {
         calendarListFailure(calendars)?.let { return WeekUiState.Failure(it) }
         val days = (0 until span.count).map { span.start.plus(it, DateTimeUnit.DAY) }
@@ -213,11 +236,13 @@ class WeekViewModel @Inject constructor(
     repository: CalendarRepository,
     settingsPrefs: SettingsPrefs,
     todaySource: TodaySource,
+    zoneSource: ZoneSource,
     @IoDispatcher io: CoroutineDispatcher,
 ) : PagedTimelineViewModel(
     repository = repository,
     settingsPrefs = settingsPrefs,
     todaySource = todaySource,
+    zoneSource = zoneSource,
     io = io,
     gridRule = settingsPrefs.weekStart.map { pref ->
         val grid = WeekGrid(pref.resolveFirstDay(Locale.getDefault()))
@@ -237,11 +262,13 @@ class MultiDayViewModel @Inject constructor(
     repository: CalendarRepository,
     settingsPrefs: SettingsPrefs,
     todaySource: TodaySource,
+    zoneSource: ZoneSource,
     @IoDispatcher io: CoroutineDispatcher,
 ) : PagedTimelineViewModel(
     repository = repository,
     settingsPrefs = settingsPrefs,
     todaySource = todaySource,
+    zoneSource = zoneSource,
     io = io,
     gridRule = settingsPrefs.multiDayCount.map { count ->
         { anchor: LocalDate -> DaysGrid.startingAt(anchor, count) }
@@ -255,11 +282,13 @@ class DayViewModel @Inject constructor(
     repository: CalendarRepository,
     settingsPrefs: SettingsPrefs,
     todaySource: TodaySource,
+    zoneSource: ZoneSource,
     @IoDispatcher io: CoroutineDispatcher,
 ) : PagedTimelineViewModel(
     repository = repository,
     settingsPrefs = settingsPrefs,
     todaySource = todaySource,
+    zoneSource = zoneSource,
     io = io,
     gridRule = flowOf { _: LocalDate -> DayGrid },
     initialRule = { DayGrid },
@@ -331,6 +360,64 @@ internal fun spanRange(start: LocalDate, count: Int, zone: TimeZone): ClosedRang
     return from..to
 }
 
+/**
+ * This instant's wall-clock time as minutes past [day]'s midnight in [zone] —
+ * negative before that day, past 1440 after it. Elapsed time since midnight would
+ * put everything after a DST change an hour off on that day's grid (#387).
+ */
+internal fun Instant.minutesPast(day: LocalDate, zone: TimeZone): Int {
+    val local = toLocalDateTime(zone)
+    val days = (local.date.toEpochDays() - day.toEpochDays()).toInt()
+    return days * MINUTES_PER_DAY + local.time.toSecondOfDay() / 60
+}
+
+/** [instant]'s [minutesPast] clamped to [day]. */
+internal fun wallClockMinutes(instant: Instant, day: LocalDate, zone: TimeZone): Int =
+    instant.minutesPast(day, zone).coerceIn(0, MINUTES_PER_DAY)
+
+/**
+ * Where a run from [start] to [end] that begins at [startMin] ends on [day]'s
+ * wall clock. A run that began before the fall-back hour's repeat and ends
+ * inside it is drawn to where that hour ends (03:00 in Berlin), since its own
+ * wall-clock end reads earlier than its real length (#387).
+ */
+internal fun wallClockEndMinutes(
+    startMin: Int,
+    start: Instant,
+    end: Instant,
+    day: LocalDate,
+    zone: TimeZone,
+): Int {
+    val wall = end.minutesPast(day, zone)
+    if (end <= start) return maxOf(wall, startMin)
+    val drawn = repeatedHourEndMinutes(start, end, day, zone) ?: wall
+    return if (drawn > startMin) drawn else startMin + (end - start).inWholeMinutes.toInt()
+}
+
+/**
+ * Where the fall-back hour's repeat [end] falls in ends, as minutes past [day]'s
+ * midnight: the wall clock the zone fell back from (03:00 in Berlin). Null unless
+ * [end] is in that repeat and [start] before it.
+ */
+private fun repeatedHourEndMinutes(start: Instant, end: Instant, day: LocalDate, zone: TimeZone): Int? {
+    // Just past [end], so an end on the transition itself still finds it.
+    val after = java.time.Instant.ofEpochMilli(end.toEpochMilliseconds() + 1)
+    val transition = zone.toJavaZoneId().rules.previousTransition(after)
+        ?.takeIf { it.isOverlap } ?: return null
+    val fellBack = transition.instant.toKotlinInstant()
+    if (start >= fellBack || end >= fellBack + transition.duration.abs().toKotlinDuration()) return null
+    // The moment it fell back, read on the clock it fell back from.
+    return fellBack.minutesPast(day, FixedOffsetTimeZone(transition.offsetBefore.toKotlinUtcOffset()))
+}
+
+/**
+ * The end a block's time label names on [day]: its event's own wall-clock end,
+ * which for one ending in the fall-back hour's repeat is earlier than the
+ * [TimedBlock.endMin] it is drawn to (#387).
+ */
+internal fun TimedBlock.labelEndMin(day: LocalDate, zone: TimeZone): Int =
+    minOf(endMin, wallClockMinutes(event.end, day, zone))
+
 /** True if this event overlaps the calendar [day] in [zone] (any portion). */
 internal fun EventInstance.coversDay(day: LocalDate, zone: TimeZone): Boolean {
     if (isAllDay) {
@@ -384,14 +471,14 @@ internal fun layoutDay(
             if (ev.start == ev.end) {
                 // Instant event: keep only if the point falls inside this day.
                 if (ev.start < dayStart || ev.start >= dayEnd) return@mapNotNull null
-                val m = (ev.start - dayStart).inWholeMinutes.toInt().coerceIn(0, MINUTES_PER_DAY)
+                val m = wallClockMinutes(ev.start, day, zone)
                 Raw(ev, m, m)
             } else {
                 val s = maxOf(ev.start, dayStart)
                 val e = minOf(ev.end, dayEnd)
                 if (e <= s) return@mapNotNull null
-                val startMin = (s - dayStart).inWholeMinutes.toInt().coerceIn(0, MINUTES_PER_DAY)
-                val endMin = (e - dayStart).inWholeMinutes.toInt().coerceIn(startMin, MINUTES_PER_DAY)
+                val startMin = wallClockMinutes(s, day, zone)
+                val endMin = wallClockEndMinutes(startMin, s, e, day, zone).coerceAtMost(MINUTES_PER_DAY)
                 Raw(ev, startMin, endMin)
             }
         }

app/src/main/res/values-night/colors.xml

@@ -2,5 +2,5 @@
     <!-- Dark-scheme window backdrop, matching the Compose dark background/surface
          (#101316) so activity recreation (e.g. language switch) doesn't flash a
          lighter grey. See values/colors.xml. -->
-    <color name="window_background">#FF101316</color>
+    <color name="window_background">@color/window_background_dark</color>
 </resources>

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

@@ -6,5 +6,10 @@
     <!-- Window backdrop shown during activity recreation (e.g. on a language
          switch). Matches the Compose light scheme background/surface so the
          recreation is seamless; overridden for dark in values-night. -->
-    <color name="window_background">#FFFBFCFE</color>
+    <color name="window_background">@color/window_background_light</color>
+    <!-- The same backdrops pinned for an in-app theme override, which the night
+         qualifier can't see. MainActivity applies one before the first frame. -->
+    <color name="window_background_light">#FFFBFCFE</color>
+    <color name="window_background_dark">#FF101316</color>
+    <color name="window_background_black">#FF000000</color>
 </resources>

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

@@ -102,6 +102,8 @@
     <string name="event_selection_actions">Event actions</string>
     <string name="event_selection_hide">Hide event actions</string>
     <string name="event_selection_close">Deselect event</string>
+    <string name="event_draft_create">Create event</string>
+    <string name="event_draft_discard">Discard new event</string>
     <string name="event_action_load_failed">Couldn\'t open the event</string>
     <string name="event_move_undo">Undo</string>
     <string name="event_move_undone">Move undone</string>
@@ -116,6 +118,11 @@
     <!-- Event form (v1.2 create) -->
     <string name="event_edit_new_title">New event</string>
     <string name="event_edit_close">Close</string>
+    <string name="event_edit_more_actions">More actions</string>
+    <string name="event_edit_unsaved_title">Unsaved changes</string>
+    <string name="event_edit_unsaved_save">Save changes</string>
+    <string name="event_edit_unsaved_discard">Discard changes</string>
+    <string name="event_edit_unsaved_keep">Keep editing</string>
     <string name="event_edit_save">Save</string>
     <string name="event_edit_title_hint">Add title</string>
     <!-- %1$s is the managing calendar's name, e.g. "Birthdays". -->
@@ -447,6 +454,8 @@
     <string name="settings_theme_system">System</string>
     <string name="settings_theme_light">Light</string>
     <string name="settings_theme_dark">Dark</string>
+    <string name="settings_theme_black">Black</string>
+    <string name="settings_theme_black_summary">Dark with pure black backgrounds, for AMOLED screens</string>
     <string name="settings_theme_hint">Whether the app is light or dark. The choice applies immediately.</string>
     <!-- %1$s is the theme the system currently resolves to, e.g. "Dark". -->
     <string name="settings_theme_system_summary">Currently %1$s</string>
@@ -516,6 +525,11 @@
     <string name="settings_dim_completed_summary">Fade events that have already ended in month and week view</string>
     <string name="settings_drag_to_reschedule">Drag to reschedule</string>
     <string name="settings_drag_to_reschedule_summary">Move an event by dragging it to another day or time</string>
+    <string name="settings_events_header">Events</string>
+    <string name="settings_tap_opens">Tapping an event opens</string>
+    <string name="settings_tap_opens_details">Details</string>
+    <string name="settings_tap_opens_editor">Edit form</string>
+    <string name="settings_tap_opens_hint">Events you can\'t edit and reminder notifications always open the details.</string>
     <string name="settings_past_events">Past events</string>
     <string name="settings_past_events_show">Show</string>
     <string name="settings_past_events_dim">Dim</string>
@@ -832,6 +846,9 @@
     <string name="shortcut_new_event_short">New event</string>
     <string name="shortcut_new_event_long">Create a new event</string>
 
+    <!-- Text-selection menu entry -->
+    <string name="process_text_create_event">Create event</string>
+
     <!-- Quick Settings tile -->
     <string name="qs_tile_new_event_label">New event</string>
     <string name="settings_qs_tile">Add Quick Settings tile</string>

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

@@ -11,6 +11,7 @@ import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.FormTime
 import de.jeanlucmakiola.calendula.domain.SearchCandidate
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.first
@@ -510,8 +511,8 @@ class CalendarRepositoryImplTest {
         val form = EventForm(
             calendarId = 1L,
             title = "Stand-up",
-            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 15)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 15))),
         )
 
         val id = repo.createEvent(form)
@@ -531,8 +532,8 @@ class CalendarRepositoryImplTest {
         val form = EventForm(
             calendarId = 1L,
             isAllDay = true,
-            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(0, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(0, 0)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(0, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(0, 0))),
         )
 
         repo.createEvent(form)
@@ -548,8 +549,8 @@ class CalendarRepositoryImplTest {
         val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
         val form = EventForm(
             calendarId = 1L,
-            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(10, 0)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(10, 0))),
         )
 
         try {
@@ -567,8 +568,8 @@ class CalendarRepositoryImplTest {
         val original = EventForm(
             calendarId = 1L,
             title = "Stand-up",
-            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 15)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 15))),
         )
         val updated = original.copy(title = "Daily")
 
@@ -584,8 +585,8 @@ class CalendarRepositoryImplTest {
         val original = EventForm(
             calendarId = 1L,
             title = "Stand-up",
-            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 15)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 15))),
         )
         val updated = original.copy(calendarId = 3L)
 
@@ -605,8 +606,8 @@ class CalendarRepositoryImplTest {
         val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
         val form = EventForm(
             calendarId = 1L,
-            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(10, 0)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(10, 0))),
         )
 
         try {
@@ -625,8 +626,8 @@ class CalendarRepositoryImplTest {
         val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
         val form = EventForm(
             calendarId = 1L,
-            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(10, 0)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(10, 0))),
         )
 
         try {
@@ -678,8 +679,8 @@ class CalendarRepositoryImplTest {
         val form = EventForm(
             calendarId = 1L,
             title = "Moved",
-            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(10, 0)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(10, 0))),
         )
 
         val id = repo.updateOccurrence(
@@ -701,8 +702,8 @@ class CalendarRepositoryImplTest {
         val original = EventForm(
             calendarId = 1L,
             title = "Weekly",
-            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(10, 0)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(9, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(10, 0))),
             rrule = "FREQ=WEEKLY",
         )
         val updated = original.copy(title = "Weekly, renamed")

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

@@ -5,12 +5,15 @@ import com.google.common.truth.Truth.assertThat
 import de.jeanlucmakiola.calendula.domain.AccessLevel
 import de.jeanlucmakiola.calendula.domain.Availability
 import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.FormTime
 import de.jeanlucmakiola.calendula.domain.realignRecurrence
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
+import kotlinx.datetime.UtcOffset
 import org.junit.jupiter.api.Test
 import java.time.ZoneId
+import kotlin.time.Instant
 
 class EventWriteMapperTest {
 
@@ -24,8 +27,8 @@ class EventWriteMapperTest {
     ): EventForm = EventForm(
         calendarId = 1L,
         isAllDay = isAllDay,
-        start = start,
-        end = end,
+        start = FormTime(start),
+        end = FormTime(end),
         timezone = timezone,
     )
 
@@ -154,8 +157,8 @@ class EventWriteMapperTest {
         assertThat(values).doesNotContainKey(CalendarContract.Events.EVENT_TIMEZONE)
 
         val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 30)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 30))),
         )
         assertThat(update(original, moved)[CalendarContract.Events.EVENT_TIMEZONE])
             .isEqualTo("America/New_York")
@@ -201,8 +204,8 @@ class EventWriteMapperTest {
     fun `time edit on a one-off event writes absolute times and clears recurrence columns`() {
         val original = form()
         val updated = original.copy(
-            start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 0)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 0))),
         )
         val values = update(original, updated)
         // 2026-06-11 11:00 CEST == 09:00Z.
@@ -221,8 +224,8 @@ class EventWriteMapperTest {
         val original = form().copy(rrule = "FREQ=WEEKLY")
         val updated = original.copy(
             // Pushed one hour later than the displayed occurrence.
-            start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 30)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 30))),
         )
         val values = update(original, updated)
         assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(seriesStart + 3_600_000L)
@@ -263,8 +266,8 @@ class EventWriteMapperTest {
             end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(10, 0)),
         ).copy(rrule = "FREQ=WEEKLY")
         val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(10, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(11, 0)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 7, 15), LocalTime(10, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 7, 15), LocalTime(11, 0))),
         )
 
         assertThat(update(original, moved, series)[CalendarContract.Events.DTSTART])
@@ -279,8 +282,8 @@ class EventWriteMapperTest {
             end = LocalDateTime(LocalDate(2026, 1, 7), LocalTime(10, 0)),
         ).copy(rrule = "FREQ=WEEKLY")
         val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 1, 9), LocalTime(14, 30)),
-            end = LocalDateTime(LocalDate(2026, 1, 9), LocalTime(15, 30)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 1, 9), LocalTime(14, 30))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 1, 9), LocalTime(15, 30))),
         )
 
         assertThat(update(original, moved, series)[CalendarContract.Events.DTSTART])
@@ -297,8 +300,8 @@ class EventWriteMapperTest {
             end = LocalDateTime(LocalDate(2026, 6, 8), LocalTime(10, 0)),
         ).copy(rrule = "FREQ=WEEKLY;BYDAY=MO")
         val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 6, 10), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 10), LocalTime(10, 0)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 6, 10), LocalTime(9, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 6, 10), LocalTime(10, 0))),
             rrule = realignRecurrence("FREQ=WEEKLY;BYDAY=MO", LocalDate(2026, 6, 8), LocalDate(2026, 6, 10)),
         )
 
@@ -319,8 +322,8 @@ class EventWriteMapperTest {
             end = LocalDateTime(LocalDate(2026, 1, 7), LocalTime(10, 30)),
         ).copy(rrule = "FREQ=WEEKLY")
         val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 1, 8), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 1, 8), LocalTime(10, 30)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 1, 8), LocalTime(9, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 1, 8), LocalTime(10, 30))),
         )
 
         assertThat(update(original, moved, series)[CalendarContract.Events.DURATION])
@@ -331,8 +334,8 @@ class EventWriteMapperTest {
     fun `shifting a one-off event and back again restores the original values`() {
         val original = form()
         val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(14, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(15, 0)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(14, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(15, 0))),
         )
 
         val forward = update(original, moved)
@@ -357,8 +360,8 @@ class EventWriteMapperTest {
             end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(10, 0)),
         ).copy(rrule = "FREQ=WEEKLY")
         val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(14, 30)),
-            end = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(15, 30)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(14, 30))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(15, 30))),
         )
 
         val movedAnchor = update(original, moved, series)[CalendarContract.Events.DTSTART] as Long
@@ -678,8 +681,8 @@ class EventWriteMapperTest {
 
     /** [julySeries] pushed to [hour]:00, the shift an "all events" time edit makes. */
     private fun EventForm.atHour(hour: Int): EventForm = copy(
-        start = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(hour, 0)),
-        end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(hour + 1, 0)),
+        start = FormTime(LocalDateTime(LocalDate(2026, 7, 15), LocalTime(hour, 0))),
+        end = FormTime(LocalDateTime(LocalDate(2026, 7, 15), LocalTime(hour + 1, 0))),
     )
 
     @Test
@@ -728,8 +731,8 @@ class EventWriteMapperTest {
             end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(0, 0)),
         ).copy(rrule = "FREQ=WEEKLY")
         val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0))),
         )
 
         assertThat(update(original, moved, series, "20260722")[CalendarContract.Events.EXDATE])
@@ -748,8 +751,8 @@ class EventWriteMapperTest {
             end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(0, 0)),
         ).copy(rrule = "FREQ=WEEKLY")
         val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0))),
         )
 
         val values = update(original, moved, series, "20260722T000000Z")
@@ -768,8 +771,8 @@ class EventWriteMapperTest {
             end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(0, 0)),
         ).copy(rrule = "FREQ=WEEKLY")
         val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0))),
         )
 
         val values = update(original, moved, series, "20260722T000000")
@@ -787,8 +790,8 @@ class EventWriteMapperTest {
             end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(0, 0)),
         ).copy(rrule = "FREQ=WEEKLY")
         val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0))),
         )
 
         val values = update(original, moved, series, "20260722T090000Z")
@@ -815,8 +818,8 @@ class EventWriteMapperTest {
         ).copy(rrule = "FREQ=WEEKLY")
         val timed = original.copy(
             isAllDay = false,
-            start = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(10, 0)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 7, 15), LocalTime(9, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 7, 15), LocalTime(10, 0))),
         )
         // The excluded day gains the new 09:00 Berlin time-of-day == 07:00Z.
         assertThat(update(original, timed, series, "20260722")[CalendarContract.Events.EXDATE])
@@ -898,8 +901,8 @@ class EventWriteMapperTest {
         val series = instantAt("2026-01-07T09:00", "Europe/Berlin")
         val original = julySeries()
         val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(14, 30)),
-            end = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(15, 30)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(14, 30))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(15, 30))),
         )
         val exdate = "20260722T070000Z"
 
@@ -1387,4 +1390,67 @@ class EventWriteMapperTest {
         assertThat(parent[CalendarContract.Events.DTSTART]).isEqualTo(1_780_560_000_000L)
         assertThat(parent[CalendarContract.Events.RRULE]).isEqualTo("FREQ=WEEKLY")
     }
+
+    @Test
+    fun `a time in the repeated fall-back hour is written at its own offset`() {
+        val repeated = LocalDateTime(LocalDate(2026, 10, 25), LocalTime(2, 0))
+        val times = form(start = repeated, end = repeated)
+            .copy(start = FormTime(repeated, UtcOffset(hours = 2)), end = FormTime(repeated, UtcOffset(hours = 1)))
+            .toWriteTimes(berlin)
+        assertThat(times.dtStartMillis).isEqualTo(Instant.parse("2026-10-25T00:00:00Z").toEpochMilliseconds())
+        assertThat(times.dtEndMillis).isEqualTo(Instant.parse("2026-10-25T01:00:00Z").toEpochMilliseconds())
+    }
+
+    @Test
+    fun `a move between the two repeated fall-back hours writes the new times`() {
+        // 02:30 CEST to 02:30 CET: the same wall clock, an hour later.
+        val repeated = LocalDateTime(LocalDate(2026, 10, 25), LocalTime(2, 30))
+        val original = form(start = repeated, end = repeated)
+            .copy(start = FormTime(repeated, UtcOffset(hours = 2)), end = FormTime(repeated, UtcOffset(hours = 2)))
+        val updated = original.copy(
+            start = original.start.copy(offset = UtcOffset(hours = 1)),
+            end = original.end.copy(offset = UtcOffset(hours = 1)),
+        )
+        val values = update(original, updated)
+        assertThat(values[CalendarContract.Events.DTSTART])
+            .isEqualTo(Instant.parse("2026-10-25T01:30:00Z").toEpochMilliseconds())
+        assertThat(values[CalendarContract.Events.DTEND])
+            .isEqualTo(Instant.parse("2026-10-25T01:30:00Z").toEpochMilliseconds())
+    }
+
+    @Test
+    fun `an untouched form in the repeated fall-back hour writes no times`() {
+        val repeated = LocalDateTime(LocalDate(2026, 10, 25), LocalTime(2, 30))
+        val original = form(start = repeated, end = repeated)
+            .copy(start = FormTime(repeated, UtcOffset(hours = 2)), end = FormTime(repeated, UtcOffset(hours = 1)))
+        assertThat(update(original, original.copy(title = "Renamed")))
+            .doesNotContainKey(CalendarContract.Events.DTSTART)
+    }
+
+    @Test
+    fun `a series anchored on the second repeated hour keeps it through a time edit`() {
+        // The series starts 02:30 CET on the fall-back day; an occurrence a week
+        // later gets ten more minutes.
+        val anchor = Instant.parse("2026-10-25T01:30:00Z").toEpochMilliseconds()
+        val original = form(
+            start = LocalDateTime(LocalDate(2026, 11, 1), LocalTime(2, 30)),
+            end = LocalDateTime(LocalDate(2026, 11, 1), LocalTime(3, 30)),
+        ).copy(rrule = "FREQ=WEEKLY")
+        val updated = original.copy(end = FormTime(LocalDateTime(LocalDate(2026, 11, 1), LocalTime(3, 40))))
+        val values = update(original, updated, series = anchor)
+        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(anchor)
+    }
+
+    @Test
+    fun `a series anchor moved between the repeated hours follows the form`() {
+        // Editing the anchor occurrence itself from 02:30 CEST onto 02:30 CET.
+        val repeated = LocalDateTime(LocalDate(2026, 10, 25), LocalTime(2, 30))
+        val anchor = Instant.parse("2026-10-25T00:30:00Z").toEpochMilliseconds()
+        val original = form(start = repeated, end = LocalDateTime(LocalDate(2026, 10, 25), LocalTime(4, 0)))
+            .copy(start = FormTime(repeated, UtcOffset(hours = 2)), rrule = "FREQ=WEEKLY")
+        val updated = original.copy(start = FormTime(repeated, UtcOffset(hours = 1)))
+        val values = update(original, updated, series = anchor)
+        assertThat(values[CalendarContract.Events.DTSTART])
+            .isEqualTo(Instant.parse("2026-10-25T01:30:00Z").toEpochMilliseconds())
+    }
 }

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

@@ -47,6 +47,13 @@ class SettingsPrefsTest {
         assertThat(prefs.themeMode.first()).isEqualTo(ThemeMode.DARK)
     }
 
+    @Test
+    fun `black theme mode round-trips`(@TempDir tempDir: Path) = runTest {
+        val prefs = SettingsPrefs(newDataStore(tempDir))
+        prefs.setThemeMode(ThemeMode.BLACK)
+        assertThat(prefs.themeMode.first()).isEqualTo(ThemeMode.BLACK)
+    }
+
     @Test
     fun `dynamic colour round-trips`(@TempDir tempDir: Path) = runTest {
         val prefs = SettingsPrefs(newDataStore(tempDir))

app/src/test/java/de/jeanlucmakiola/calendula/data/time/FakeZoneSource.kt

@@ -0,0 +1,12 @@
+package de.jeanlucmakiola.calendula.data.time
+
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.datetime.TimeZone
+
+/** A device zone a test sets, by default the machine's own. */
+class FakeZoneSource(zone: TimeZone = TimeZone.currentSystemDefault()) : ZoneSource {
+    override val zone: MutableStateFlow<TimeZone> = MutableStateFlow(zone)
+
+    override fun current(): TimeZone = zone.value
+}

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

@@ -5,6 +5,8 @@ import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
+import kotlinx.datetime.UtcOffset
+import kotlinx.datetime.toLocalDateTime
 import org.junit.jupiter.api.Test
 import kotlin.time.Instant
 
@@ -15,29 +17,29 @@ class EventFormTest {
         isAllDay: Boolean = false,
         start: LocalDateTime = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 0)),
         end: LocalDateTime = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 0)),
-    ): EventForm = EventForm(calendarId = calendarId, isAllDay = isAllDay, start = start, end = end)
+    ): EventForm = EventForm(calendarId = calendarId, isAllDay = isAllDay, start = FormTime(start), end = FormTime(end))
 
     @Test
     fun `valid timed form has no problems`() {
-        assertThat(form().problems()).isEmpty()
+        assertThat(form().problems(berlin)).isEmpty()
     }
 
     @Test
     fun `missing calendar is a problem`() {
-        assertThat(form(calendarId = null).problems())
+        assertThat(form(calendarId = null).problems(berlin))
             .containsExactly(EventFormProblem.NoCalendar)
     }
 
     @Test
     fun `timed end before start is a problem`() {
         val bad = form(end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(9, 0)))
-        assertThat(bad.problems()).containsExactly(EventFormProblem.EndBeforeStart)
+        assertThat(bad.problems(berlin)).containsExactly(EventFormProblem.EndBeforeStart)
     }
 
     @Test
     fun `zero-length timed event is allowed`() {
         val instant = form(end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 0)))
-        assertThat(instant.problems()).isEmpty()
+        assertThat(instant.problems(berlin)).isEmpty()
     }
 
     @Test
@@ -47,7 +49,7 @@ class EventFormTest {
             start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(0, 0)),
             end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(0, 0)),
         )
-        assertThat(allDay.problems()).isEmpty()
+        assertThat(allDay.problems(berlin)).isEmpty()
     }
 
     @Test
@@ -57,7 +59,7 @@ class EventFormTest {
             start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(0, 0)),
             end = LocalDateTime(LocalDate(2026, 6, 10), LocalTime(0, 0)),
         )
-        assertThat(bad.problems()).containsExactly(EventFormProblem.EndBeforeStart)
+        assertThat(bad.problems(berlin)).containsExactly(EventFormProblem.EndBeforeStart)
     }
 
     @Test
@@ -66,7 +68,7 @@ class EventFormTest {
             calendarId = null,
             end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(9, 0)),
         )
-        assertThat(bad.problems()).containsExactly(
+        assertThat(bad.problems(berlin)).containsExactly(
             EventFormProblem.NoCalendar,
             EventFormProblem.EndBeforeStart,
         )
@@ -76,28 +78,28 @@ class EventFormTest {
     fun `recurrence until before the first day is a problem`() {
         // Days before the start, so it parses to an earlier date in any zone.
         val bad = form().copy(rrule = "FREQ=DAILY;UNTIL=20260601T120000Z")
-        assertThat(bad.problems())
+        assertThat(bad.problems(berlin))
             .containsExactly(EventFormProblem.RecurrenceEndsBeforeStart)
     }
 
     @Test
     fun `recurrence until on or after the first day is fine`() {
         // Date-only UNTIL parses zone-independently.
-        assertThat(form().copy(rrule = "FREQ=DAILY;UNTIL=20260611").problems()).isEmpty()
-        assertThat(form().copy(rrule = "FREQ=WEEKLY").problems()).isEmpty()
+        assertThat(form().copy(rrule = "FREQ=DAILY;UNTIL=20260611").problems(berlin)).isEmpty()
+        assertThat(form().copy(rrule = "FREQ=WEEKLY").problems(berlin)).isEmpty()
     }
 
     @Test
     fun `complex rrules are not validated against the start`() {
         // The picker can't have produced this ("second Monday" ordinal BYDAY);
         // it is preserved verbatim and never flagged.
-        assertThat(form().copy(rrule = "FREQ=MONTHLY;BYDAY=2MO;UNTIL=20200101").problems()).isEmpty()
+        assertThat(form().copy(rrule = "FREQ=MONTHLY;BYDAY=2MO;UNTIL=20200101").problems(berlin)).isEmpty()
     }
 
     @Test
     fun `weekly byday rules are validated against the start`() {
         val bad = form().copy(rrule = "FREQ=WEEKLY;BYDAY=MO,FR;UNTIL=20200101")
-        assertThat(bad.problems())
+        assertThat(bad.problems(berlin))
             .containsExactly(EventFormProblem.RecurrenceEndsBeforeStart)
     }
 
@@ -150,8 +152,8 @@ class EventFormTest {
             endMillis = 1_781_164_800_000L + 90L * 60L * 1000L,
             zone = berlin,
         )
-        assertThat(prefilled.start).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 0)))
-        assertThat(prefilled.end).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 30)))
+        assertThat(prefilled.start.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 0)))
+        assertThat(prefilled.end.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(11, 30)))
         assertThat(prefilled.isAllDay).isFalse()
         assertThat(prefilled.calendarId).isEqualTo(7L)
         assertThat(prefilled.title).isEqualTo("Stand-up")
@@ -182,7 +184,7 @@ class EventFormTest {
         assertThat(prefilled.timezone).isEqualTo("America/New_York")
         // 08:00Z is 10:00 in Berlin but 04:00 in New York — the form shows the
         // event's own wall-clock, which is what a later save re-anchors to.
-        assertThat(prefilled.start).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(4, 0)))
+        assertThat(prefilled.start.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(4, 0)))
         assertThat(prefilled.populatedFields()).contains(EventFormField.Timezone)
     }
 
@@ -206,68 +208,27 @@ class EventFormTest {
         )
         // A malformed sync row must not be honoured, nor fail the open.
         assertThat(prefilled.timezone).isNull()
-        assertThat(prefilled.start).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 0)))
+        assertThat(prefilled.start.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 0)))
     }
 
     @Test
-    fun `timesIn converts a pinned event into the target zone`() {
-        val form = EventForm(
-            calendarId = 1L,
-            start = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(8, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(9, 0)),
-            timezone = "America/New_York",
-        )
-        val (start, end) = form.timesIn(berlin)!!
-        // 08:00 New York (EDT, UTC-4) is 14:00 Berlin (CEST, UTC+2).
-        assertThat(start).isEqualTo(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(14, 0)))
-        assertThat(end).isEqualTo(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(15, 0)))
-    }
-
-    @Test
-    fun `timesIn crosses the date line when the offset pushes past midnight`() {
-        val form = EventForm(
-            calendarId = 1L,
-            start = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(20, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(21, 0)),
-            timezone = "America/New_York",
-        )
-        val (start, _) = form.timesIn(berlin)!!
-        // 20:00 New York is 02:00 the NEXT day in Berlin — the date has to move
-        // with it, not just the clock.
-        assertThat(start).isEqualTo(LocalDateTime(LocalDate(2026, 7, 18), LocalTime(2, 0)))
-    }
-
-    @Test
-    fun `timesIn tracks each zone's own DST rather than a fixed offset`() {
-        // In January both are on standard time: 08:00 EST is 14:00 CET — the
-        // same six hours as July, but only because both shifted. Late March,
-        // when the US has sprung forward and Europe hasn't, the gap is five.
-        val march = EventForm(
-            calendarId = 1L,
-            start = LocalDateTime(LocalDate(2026, 3, 20), LocalTime(8, 0)),
-            end = LocalDateTime(LocalDate(2026, 3, 20), LocalTime(9, 0)),
-            timezone = "America/New_York",
-        )
-        assertThat(march.timesIn(berlin)!!.first)
-            .isEqualTo(LocalDateTime(LocalDate(2026, 3, 20), LocalTime(13, 0)))
-    }
-
-    @Test
-    fun `timesIn returns null when there is nothing to disambiguate`() {
+    fun `isPinnedAwayFrom is false when there is nothing to disambiguate`() {
         val base = EventForm(
             calendarId = 1L,
-            start = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(8, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(9, 0)),
+            start = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(8, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(9, 0))),
         )
         // Unpinned: the form's times already are the local times.
-        assertThat(base.timesIn(berlin)).isNull()
+        assertThat(base.isPinnedAwayFrom(berlin)).isFalse()
         // Pinned to the target itself: same thing.
-        assertThat(base.copy(timezone = "Europe/Berlin").timesIn(berlin)).isNull()
+        assertThat(base.copy(timezone = "Europe/Berlin").isPinnedAwayFrom(berlin)).isFalse()
         // All-day: date-anchored, so there's no zone conversion to show.
-        assertThat(base.copy(isAllDay = true, timezone = "America/New_York").timesIn(berlin))
-            .isNull()
+        assertThat(base.copy(isAllDay = true, timezone = "America/New_York").isPinnedAwayFrom(berlin))
+            .isFalse()
         // Unparseable: can't convert, mustn't throw.
-        assertThat(base.copy(timezone = "Mars/Olympus_Mons").timesIn(berlin)).isNull()
+        assertThat(base.copy(timezone = "Mars/Olympus_Mons").isPinnedAwayFrom(berlin)).isFalse()
+        // Pinned elsewhere: worth spelling out.
+        assertThat(base.copy(timezone = "America/New_York").isPinnedAwayFrom(berlin)).isTrue()
     }
 
     @Test
@@ -425,4 +386,190 @@ class EventFormTest {
         assertThat(prefilled.color).isNull()
         assertThat(prefilled.populatedFields()).doesNotContain(EventFormField.Color)
     }
+
+    @Test
+    fun `toEditForm keeps which repeated fall-back hour each end is in`() {
+        val start = Instant.parse("2026-10-25T00:00:00Z")
+        val end = Instant.parse("2026-10-25T01:00:00Z")
+        val prefilled = detail().toEditForm(start.toEpochMilliseconds(), end.toEpochMilliseconds(), berlin)
+        assertThat(prefilled.start.dateTime).isEqualTo(prefilled.end.dateTime)
+        assertThat(prefilled.startInstant(berlin)).isEqualTo(start)
+        assertThat(prefilled.endInstant(berlin)).isEqualTo(end)
+    }
+
+    @Test
+    fun `a span ending in the repeated fall-back hour is valid`() {
+        // 02:45 CEST to 02:15 CET: half an hour, though the clock reads backwards.
+        val form = form().withTimes(
+            Instant.parse("2026-10-25T00:45:00Z"),
+            Instant.parse("2026-10-25T01:15:00Z"),
+            berlin,
+        )
+        assertThat(form.end.dateTime).isLessThan(form.start.dateTime)
+        assertThat(form.problems(berlin)).isEmpty()
+        // Read as the same pass at both ends, it really does end first.
+        assertThat(form.copy(start = FormTime(form.start.dateTime), end = FormTime(form.end.dateTime)).problems(berlin))
+            .containsExactly(EventFormProblem.EndBeforeStart)
+    }
+
+    @Test
+    fun `an end picked in the repeated hour moves the way the hand did`() {
+        // 02:45 CEST to 02:15 CET.
+        val form = form().withTimes(
+            Instant.parse("2026-10-25T00:45:00Z"),
+            Instant.parse("2026-10-25T01:15:00Z"),
+            berlin,
+        )
+        // Picking the end it already has keeps its pass.
+        assertThat(form.withEnd(form.end.dateTime, berlin)).isEqualTo(form)
+        // Later on the clock: later in time, still on the second pass.
+        assertThat(form.withEnd(LocalDateTime(LocalDate(2026, 10, 25), LocalTime(2, 50)), berlin).endInstant(berlin))
+            .isEqualTo(Instant.parse("2026-10-25T01:50:00Z"))
+        // Earlier on the clock: earlier in time, not an hour earlier.
+        assertThat(form.withEnd(LocalDateTime(LocalDate(2026, 10, 25), LocalTime(2, 5)), berlin).endInstant(berlin))
+            .isEqualTo(Instant.parse("2026-10-25T01:05:00Z"))
+    }
+
+    @Test
+    fun `an end picked in the repeated hour stays after a second-pass start`() {
+        // 02:10 CET to 04:00, its end set to 02:40: only the second pass is after the start.
+        val form = form().withTimes(
+            Instant.parse("2026-10-25T01:10:00Z"),
+            Instant.parse("2026-10-25T03:00:00Z"),
+            berlin,
+        )
+        val picked = form.withEnd(LocalDateTime(LocalDate(2026, 10, 25), LocalTime(2, 40)), berlin)
+        assertThat(picked.endInstant(berlin)).isEqualTo(Instant.parse("2026-10-25T01:40:00Z"))
+        assertThat(picked.problems(berlin)).isEmpty()
+    }
+
+    @Test
+    fun `a repeated-hour end changed and changed back is the end it was`() {
+        // 01:00 CEST to 02:30 CEST, its end set to 03:00 and back.
+        val original = form().withTimes(
+            Instant.parse("2026-10-24T23:00:00Z"),
+            Instant.parse("2026-10-25T00:30:00Z"),
+            berlin,
+        )
+        val repeated = LocalDateTime(LocalDate(2026, 10, 25), LocalTime(2, 30))
+        val away = original.withEnd(LocalDateTime(LocalDate(2026, 10, 25), LocalTime(3, 0)), berlin)
+        assertThat(away.withEnd(repeated, berlin, original = original.end)).isEqualTo(original)
+        // Without the opened end to go by, coming back from 03:00 reads as the later pass.
+        assertThat(away.withEnd(repeated, berlin).endInstant(berlin))
+            .isEqualTo(Instant.parse("2026-10-25T01:30:00Z"))
+    }
+
+    @Test
+    fun `a start picked in the repeated hour keeps the length`() {
+        // 02:30 CET to 03:30, its start set back to 02:10.
+        val form = form().withTimes(
+            Instant.parse("2026-10-25T01:30:00Z"),
+            Instant.parse("2026-10-25T02:30:00Z"),
+            berlin,
+        )
+        val picked = form.withStart(LocalDateTime(LocalDate(2026, 10, 25), LocalTime(2, 10)), berlin)
+        assertThat(picked.startInstant(berlin)).isEqualTo(Instant.parse("2026-10-25T01:10:00Z"))
+        assertThat(picked.endInstant(berlin)).isEqualTo(Instant.parse("2026-10-25T02:10:00Z"))
+    }
+
+    @Test
+    fun `a pinned event's times land in the device zone`() {
+        val form = EventForm(
+            calendarId = 1L,
+            start = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(8, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(9, 0))),
+            timezone = "America/New_York",
+        )
+        val zone = form.resolvedZone(berlin)
+        // 08:00 New York (EDT, UTC-4) is 14:00 Berlin (CEST, UTC+2).
+        assertThat(form.startInstant(zone).toLocalDateTime(berlin))
+            .isEqualTo(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(14, 0)))
+        assertThat(form.endInstant(zone).toLocalDateTime(berlin))
+            .isEqualTo(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(15, 0)))
+    }
+
+    @Test
+    fun `a pinned event's local time crosses the date line with the offset`() {
+        val form = EventForm(
+            calendarId = 1L,
+            start = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(20, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 7, 17), LocalTime(21, 0))),
+            timezone = "America/New_York",
+        )
+        // 20:00 New York is 02:00 the NEXT day in Berlin.
+        assertThat(form.startInstant(form.resolvedZone(berlin)).toLocalDateTime(berlin))
+            .isEqualTo(LocalDateTime(LocalDate(2026, 7, 18), LocalTime(2, 0)))
+    }
+
+    @Test
+    fun `a pinned event's local time tracks each zone's own DST`() {
+        // Late March the US has sprung forward and Europe hasn't: five hours, not six.
+        val form = EventForm(
+            calendarId = 1L,
+            start = FormTime(LocalDateTime(LocalDate(2026, 3, 20), LocalTime(8, 0))),
+            end = FormTime(LocalDateTime(LocalDate(2026, 3, 20), LocalTime(9, 0))),
+            timezone = "America/New_York",
+        )
+        assertThat(form.startInstant(form.resolvedZone(berlin)).toLocalDateTime(berlin))
+            .isEqualTo(LocalDateTime(LocalDate(2026, 3, 20), LocalTime(13, 0)))
+    }
+
+    @Test
+    fun `offsets are kept only for a repeated hour`() {
+        val summer = form().withTimes(
+            Instant.parse("2026-06-11T08:00:00Z"),
+            Instant.parse("2026-06-11T09:00:00Z"),
+            berlin,
+        )
+        assertThat(summer.start.offset).isNull()
+        assertThat(summer.end.offset).isNull()
+        val repeated = form().withTimes(
+            Instant.parse("2026-10-25T00:45:00Z"),
+            Instant.parse("2026-10-25T01:15:00Z"),
+            berlin,
+        )
+        assertThat(repeated.start.offset).isEqualTo(UtcOffset(hours = 2))
+        assertThat(repeated.end.offset).isEqualTo(UtcOffset(hours = 1))
+    }
+
+    @Test
+    fun `an end changed and changed back is the form it was`() {
+        val original = detail().toEditForm(
+            Instant.parse("2026-06-11T08:00:00Z").toEpochMilliseconds(),
+            Instant.parse("2026-06-11T09:00:00Z").toEpochMilliseconds(),
+            berlin,
+        )
+        val back = original
+            .withEnd(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 0)), berlin)
+            .withEnd(original.end.dateTime, berlin)
+        assertThat(back).isEqualTo(original)
+    }
+
+    @Test
+    fun `a new zone drops the kept pass, the same zone keeps it`() {
+        val repeated = form().withTimes(
+            Instant.parse("2026-10-25T01:30:00Z"),
+            Instant.parse("2026-10-25T02:00:00Z"),
+            berlin,
+        )
+        assertThat(repeated.withTimezone("Europe/Berlin", berlin)).isEqualTo(repeated.copy(timezone = "Europe/Berlin"))
+        val moved = repeated.withTimezone("Africa/Lagos", berlin)
+        assertThat(moved.start.offset).isNull()
+        assertThat(moved.end.offset).isNull()
+        // Back on Berlin, a picked 02:30 takes the earlier pass, as any picked time does.
+        assertThat(moved.withTimezone(null, berlin).startInstant(berlin))
+            .isEqualTo(Instant.parse("2026-10-25T00:30:00Z"))
+    }
+
+    @Test
+    fun `an end picked in the spring-forward gap moves on as a start does`() {
+        val form = form(
+            start = LocalDateTime(LocalDate(2026, 3, 29), LocalTime(1, 0)),
+            end = LocalDateTime(LocalDate(2026, 3, 29), LocalTime(1, 30)),
+        )
+        val picked = form.withEnd(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(2, 30)), berlin)
+        assertThat(picked.end.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(3, 30)))
+        val started = form.withStart(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(2, 30)), berlin)
+        assertThat(started.start.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(3, 30)))
+    }
 }

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

@@ -308,6 +308,23 @@ class EventSearchTest {
         assertThat(snippet.text).isEqualTo("erste Zeile zweite Zeile")
     }
 
+    @Test
+    fun `an html description matches and snippets on its text, not its tags`() {
+        val html = "<div class=\"x\"><p>Raum&nbsp;<b>4.12</b></p></div>"
+        assertThat(search(candidate("Notiz", description = html), query = "div").isEmpty).isTrue()
+
+        val snippet = search(candidate("Notiz", description = html), query = "raum 4.12")
+            .allHits.single().descriptionSnippet
+        requireNotNull(snippet)
+        assertThat(snippet.text).isEqualTo("Raum 4.12")
+    }
+
+    @Test
+    fun `a link address in an html description is still searchable`() {
+        val html = "<p><a href=\"https://zoom.us/j/81234567890\">Join Zoom Meeting</a></p>"
+        assertThat(search(candidate("Call", description = html), query = "81234567890").allHits).hasSize(1)
+    }
+
     @Test
     fun `a blank query matches nothing`() {
         assertThat(search(candidate("Test"), query = "   ").isEmpty).isTrue()

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

@@ -5,8 +5,10 @@ import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
+import kotlinx.datetime.UtcOffset
 import kotlinx.datetime.toInstant
 import org.junit.jupiter.api.Test
+import kotlin.time.Instant
 
 class EventShiftTest {
 
@@ -22,8 +24,8 @@ class EventShiftTest {
         calendarId = 1L,
         title = "Standup",
         isAllDay = isAllDay,
-        start = start,
-        end = end,
+        start = FormTime(start),
+        end = FormTime(end),
         timezone = timezone,
     )
 
@@ -34,8 +36,8 @@ class EventShiftTest {
 
         val moved = original.shiftedTo(target, berlin)
 
-        assertThat(moved.start).isEqualTo(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(14, 30)))
-        assertThat(moved.end).isEqualTo(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(15, 30)))
+        assertThat(moved.start.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(14, 30)))
+        assertThat(moved.end.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(15, 30)))
     }
 
     @Test
@@ -52,8 +54,8 @@ class EventShiftTest {
         val moved = original.shiftedTo(target, berlin)
 
         assertThat(moved.timezone).isEqualTo("America/New_York")
-        assertThat(moved.start).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(9, 30)))
-        assertThat(moved.end).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 30)))
+        assertThat(moved.start.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(9, 30)))
+        assertThat(moved.end.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 30)))
     }
 
     @Test
@@ -69,10 +71,10 @@ class EventShiftTest {
 
         // Two real hours from 01:00 CET lands at 04:00 CEST: the hour in
         // between does not exist.
-        assertThat(moved.start).isEqualTo(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(1, 0)))
-        assertThat(moved.end).isEqualTo(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(4, 0)))
-        assertThat(moved.end.toInstant(berlin) - moved.start.toInstant(berlin))
-            .isEqualTo(original.end.toInstant(berlin) - original.start.toInstant(berlin))
+        assertThat(moved.start.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(1, 0)))
+        assertThat(moved.end.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(4, 0)))
+        assertThat(moved.end.dateTime.toInstant(berlin) - moved.start.dateTime.toInstant(berlin))
+            .isEqualTo(original.end.dateTime.toInstant(berlin) - original.start.dateTime.toInstant(berlin))
     }
 
     @Test
@@ -83,13 +85,15 @@ class EventShiftTest {
 
         val moved = original.shiftedTo(target, berlin)
 
-        assertThat(moved.start).isEqualTo(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(3, 30)))
+        assertThat(moved.start.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(3, 30)))
     }
 
     @Test
     fun `a zero-distance drop leaves the form untouched`() {
-        val original = form()
-        assertThat(original.shiftedTo(original.start.toInstant(berlin), berlin)).isEqualTo(original)
+        // As read from the provider, offsets and all.
+        val start = form().start.dateTime.toInstant(berlin)
+        val original = form().withTimes(start, form().end.dateTime.toInstant(berlin), berlin)
+        assertThat(original.shiftedTo(start, berlin)).isEqualTo(original)
     }
 
     @Test
@@ -99,7 +103,7 @@ class EventShiftTest {
 
         val moved = original.shiftedTo(target, newYork)
 
-        assertThat(moved.start).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 0)))
+        assertThat(moved.start.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 0)))
     }
 
     @Test
@@ -125,8 +129,8 @@ class EventShiftTest {
 
         val moved = multiDay.shiftedByDays(-2, berlin)
 
-        assertThat(moved.start).isEqualTo(LocalDateTime(LocalDate(2026, 6, 9), LocalTime(22, 0)))
-        assertThat(moved.end).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(2, 0)))
+        assertThat(moved.start.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 6, 9), LocalTime(22, 0)))
+        assertThat(moved.end.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(2, 0)))
     }
 
     @Test
@@ -140,11 +144,11 @@ class EventShiftTest {
 
         val moved = overnight.shiftedByDays(7, berlin)
 
-        assertThat(moved.start).isEqualTo(LocalDateTime(LocalDate(2026, 3, 28), LocalTime(22, 0)))
-        assertThat(moved.end.toInstant(berlin) - moved.start.toInstant(berlin))
-            .isEqualTo(overnight.end.toInstant(berlin) - overnight.start.toInstant(berlin))
+        assertThat(moved.start.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 3, 28), LocalTime(22, 0)))
+        assertThat(moved.end.dateTime.toInstant(berlin) - moved.start.dateTime.toInstant(berlin))
+            .isEqualTo(overnight.end.dateTime.toInstant(berlin) - overnight.start.dateTime.toInstant(berlin))
         // The wall-clock end therefore lands an hour later than a naive +7 days.
-        assertThat(moved.end).isEqualTo(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(5, 0)))
+        assertThat(moved.end.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(5, 0)))
     }
 
     @Test
@@ -158,10 +162,10 @@ class EventShiftTest {
         val original = form()
         val end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 30)).toInstant(berlin)
 
-        val resized = original.resizedTo(original.start.toInstant(berlin), end, berlin)
+        val resized = original.resizedTo(original.start.dateTime.toInstant(berlin), end, berlin)
 
         assertThat(resized.start).isEqualTo(original.start)
-        assertThat(resized.end).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 30)))
+        assertThat(resized.end.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 30)))
     }
 
     @Test
@@ -169,9 +173,9 @@ class EventShiftTest {
         val original = form()
         val end = LocalDateTime(LocalDate(2026, 6, 12), LocalTime(1, 0)).toInstant(berlin)
 
-        val resized = original.resizedTo(original.start.toInstant(berlin), end, berlin)
+        val resized = original.resizedTo(original.start.dateTime.toInstant(berlin), end, berlin)
 
-        assertThat(resized.end).isEqualTo(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(1, 0)))
+        assertThat(resized.end.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(1, 0)))
     }
 
     @Test
@@ -184,17 +188,79 @@ class EventShiftTest {
         // "15:30 Berlin" is 09:30 in New York.
         val start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(15, 30)).toInstant(berlin)
 
-        val resized = original.resizedTo(start, original.end.toInstant(newYork), berlin)
+        val resized = original.resizedTo(start, original.end.dateTime.toInstant(newYork), berlin)
 
-        assertThat(resized.start).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(9, 30)))
+        assertThat(resized.start.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(9, 30)))
         assertThat(resized.end).isEqualTo(original.end)
     }
 
     @Test
     fun `an all-day event ignores a resize`() {
         val allDay = form(isAllDay = true)
-        val start = allDay.start.toInstant(berlin)
+        val start = allDay.start.dateTime.toInstant(berlin)
 
         assertThat(allDay.resizedTo(start, start, berlin)).isEqualTo(allDay)
     }
+
+    // 02:00 CEST to 02:00 CET on 2026-10-25: one real hour, one wall-clock value.
+    private val repeatStart = Instant.parse("2026-10-25T00:00:00Z")
+    private val repeatEnd = Instant.parse("2026-10-25T01:00:00Z")
+
+    @Test
+    fun `moving an event in the repeated fall-back hour keeps its length`() {
+        val original = form().withTimes(repeatStart, repeatEnd, berlin)
+        val moved = original.shiftedTo(Instant.parse("2026-10-25T00:30:00Z"), berlin)
+        assertThat(moved.startInstant(berlin)).isEqualTo(Instant.parse("2026-10-25T00:30:00Z"))
+        assertThat(moved.endInstant(berlin)).isEqualTo(Instant.parse("2026-10-25T01:30:00Z"))
+    }
+
+    @Test
+    fun `a move onto the second repeated hour stays there`() {
+        val target = Instant.parse("2026-10-25T01:30:00Z")
+        val moved = form().withTimes(repeatStart, repeatEnd, berlin).shiftedTo(target, berlin)
+        assertThat(moved.start.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 10, 25), LocalTime(2, 30)))
+        assertThat(moved.startInstant(berlin)).isEqualTo(target)
+    }
+
+    @Test
+    fun `resolveIn takes the preferred offset only where the hour repeats`() {
+        val repeated = LocalDateTime(LocalDate(2026, 10, 25), LocalTime(2, 30))
+        val cet = UtcOffset(hours = 1)
+        assertThat(repeated.resolveIn(berlin, cet)).isEqualTo(Instant.parse("2026-10-25T01:30:00Z"))
+        assertThat(repeated.resolveIn(berlin, null)).isEqualTo(Instant.parse("2026-10-25T00:30:00Z"))
+        // Not one of 14:00's offsets on a summer day: ignored.
+        val summer = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(14, 0))
+        assertThat(summer.resolveIn(berlin, cet)).isEqualTo(summer.toInstant(berlin))
+    }
+
+    @Test
+    fun `a day move onto the repeated hour doesn't depend on the source's season`() {
+        // 02:30 a week after the fall-back day (CET) and in summer (CEST), both
+        // moved onto it: the earlier pass either way, as a timeline drop.
+        val first = Instant.parse("2026-10-25T00:30:00Z")
+        val november = form().withTimes(
+            Instant.parse("2026-11-01T01:30:00Z"),
+            Instant.parse("2026-11-01T02:30:00Z"),
+            berlin,
+        )
+        assertThat(november.shiftedByDays(-7, berlin).startInstant(berlin)).isEqualTo(first)
+        val summer = form(
+            start = LocalDateTime(LocalDate(2026, 10, 18), LocalTime(2, 30)),
+            end = LocalDateTime(LocalDate(2026, 10, 18), LocalTime(3, 30)),
+        )
+        assertThat(summer.shiftedByDays(7, berlin).startInstant(berlin)).isEqualTo(first)
+    }
+
+    @Test
+    fun `a day move onto the spring-forward gap keeps its wall clock`() {
+        // Saturday 02:30 to 03:30, moved onto Sunday 29 March, when 02:30 is skipped.
+        val moved = form(
+            start = LocalDateTime(LocalDate(2026, 3, 28), LocalTime(2, 30)),
+            end = LocalDateTime(LocalDate(2026, 3, 28), LocalTime(3, 30)),
+        ).shiftedByDays(1, berlin)
+        assertThat(moved.start.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 3, 29), LocalTime(2, 30)))
+        // It still means 03:30 CEST, an hour long.
+        assertThat(moved.startInstant(berlin)).isEqualTo(Instant.parse("2026-03-29T01:30:00Z"))
+        assertThat(moved.endInstant(berlin)).isEqualTo(Instant.parse("2026-03-29T02:30:00Z"))
+    }
 }

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

@@ -0,0 +1,213 @@
+package de.jeanlucmakiola.calendula.domain
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
+
+class HtmlTextTest {
+
+    @Test
+    fun `prose with angle brackets is not html`() {
+        assertThat(looksLikeHtml("I <3 this, and a < b > c")).isFalse()
+        assertThat(looksLikeHtml("Teams Meeting <https://teams.microsoft.com/l/x>")).isFalse()
+        assertThat(looksLikeHtml("Bring <cake>")).isFalse()
+    }
+
+    @Test
+    fun `common tags are html`() {
+        assertThat(looksLikeHtml("Line one<br>Line two")).isTrue()
+        assertThat(looksLikeHtml("<p class=MsoNormal>Hi</p>")).isTrue()
+        assertThat(looksLikeHtml("See <a href=\"https://x.y\">here</a>")).isTrue()
+    }
+
+    @Test
+    fun `plain text passes through untouched`() {
+        val text = "  Agenda:\n\n\n- one  \n- two"
+        assertThat(descriptionRichText(text)).isEqualTo(RichText(text))
+    }
+
+    @Test
+    fun `blocks and breaks become lines and whitespace collapses`() {
+        val html = "<div>Hello\n   world</div><div>Second<br>Third</div>"
+        assertThat(parseHtml(html).text).isEqualTo("Hello world\nSecond\nThird")
+    }
+
+    @Test
+    fun `head, styles, scripts and comments are dropped`() {
+        val html = """
+            <html><head><meta charset="utf-8"><style>p { color: red; }</style></head>
+            <body><!-- converted from text --><script>alert(1)</script><p>Body</p></body></html>
+        """.trimIndent()
+        assertThat(parseHtml(html).text).isEqualTo("Body")
+    }
+
+    @Test
+    fun `an nbsp paragraph keeps one blank line, more collapse`() {
+        val html = "<p>One</p><p>&nbsp;</p><p>&nbsp;</p><p>&nbsp;</p><p>Two</p>"
+        assertThat(parseHtml(html).text).isEqualTo("One\n\nTwo")
+    }
+
+    @Test
+    fun `entities are decoded`() {
+        assertThat(parseHtml("<p>Fish &amp; chips &lt;3 &#8364;5 &#x2013; caf&eacute; &bogus;</p>").text)
+            .isEqualTo("Fish & chips <3 €5 – café &bogus;")
+    }
+
+    @Test
+    fun `inline styles cover their text`() {
+        val rich = parseHtml("<p>A <b>bold</b> and <i>italic</i> word</p>")
+        assertThat(rich.text).isEqualTo("A bold and italic word")
+        assertThat(rich.styles).containsExactly(
+            StyleRange(2, 6, InlineStyle.Bold),
+            StyleRange(11, 17, InlineStyle.Italic),
+        )
+    }
+
+    @Test
+    fun `fonts and colours are not kept`() {
+        val rich = parseHtml("<span style=\"color:#000\"><font face=Calibri size=2>Text</font></span>")
+        assertThat(rich).isEqualTo(RichText("Text"))
+    }
+
+    @Test
+    fun `links keep their href, unsafe schemes are dropped`() {
+        val rich = parseHtml(
+            "<a href=\"https://teams.microsoft.com/l/x?a=1&amp;b=2\">Join</a> " +
+                "<a href='tel:+4930123,,456#'>Dial</a> <a href=\"javascript:alert(1)\">Bad</a>",
+        )
+        assertThat(rich.text).isEqualTo("Join Dial Bad")
+        assertThat(rich.links).containsExactly(
+            LinkRange(0, 4, "https://teams.microsoft.com/l/x?a=1&b=2"),
+            LinkRange(5, 9, "tel:+4930123,,456#"),
+        )
+    }
+
+    @Test
+    fun `lists get bullets and numbers`() {
+        val html = "<p>Agenda</p><ul><li>One</li><li>Two<ol><li>Sub</li></ol></li></ul><ol><li>A</li><li>B</li></ol>"
+        assertThat(parseHtml(html).text).isEqualTo("Agenda\n• One\n• Two\n  1. Sub\n1. A\n2. B")
+    }
+
+    @Test
+    fun `table rows become lines with cells side by side`() {
+        val html = "<table><tr><th>Time</th><th>Topic</th></tr><tr><td>9:00</td><td>Intro</td></tr>" +
+            "<tr><td>&nbsp;</td><td>Spacer row</td></tr></table>"
+        assertThat(parseHtml(html).text).isEqualTo("Time · Topic\n9:00 · Intro\nSpacer row")
+    }
+
+    @Test
+    fun `formatting on a dropped spacer cell doesn't leak onto the next`() {
+        val rich = parseHtml("<table><tr><td><b>&nbsp;</b></td><td>Plain</td></tr></table>")
+        assertThat(rich).isEqualTo(RichText("Plain"))
+    }
+
+    @Test
+    fun `pre keeps its whitespace`() {
+        assertThat(parseHtml("<pre>a  b\n  c</pre>").text).isEqualTo("a  b\n  c")
+    }
+
+    @Test
+    fun `spans shift with trimmed whitespace`() {
+        val rich = parseHtml("<p>&nbsp;</p><p>  <b>Bold</b>   </p>")
+        assertThat(rich.text).isEqualTo("Bold")
+        assertThat(rich.styles).containsExactly(StyleRange(0, 4, InlineStyle.Bold))
+    }
+
+    @Test
+    fun `broken markup stays text`() {
+        assertThat(parseHtml("<p>x < y and <b>z</p>").text).isEqualTo("x < y and z")
+        assertThat(parseHtml("<p>open <a href=\"https://a.b\">tail").links)
+            .containsExactly(LinkRange(5, 9, "https://a.b"))
+    }
+
+    @Test
+    fun `a paragraph inside a list item stays on the bullet's line`() {
+        assertThat(parseHtml("<ul><li><p>One</p></li><li><div>Two</div></li></ul>").text)
+            .isEqualTo("• One\n• Two")
+    }
+
+    @Test
+    fun `newlines are the lines when the markup sets none`() {
+        val rich = parseHtml("Agenda:\n1. Intro\n2. <a href=\"https://x.y\">Q&amp;A</a>")
+        assertThat(rich.text).isEqualTo("Agenda:\n1. Intro\n2. Q&A")
+    }
+
+    @Test
+    fun `newlines in markup with its own lines are just spaces`() {
+        assertThat(parseHtml("<p>wrapped\nsource line</p>").text).isEqualTo("wrapped source line")
+    }
+
+    @Test
+    fun `a link scheme is lower-cased`() {
+        assertThat(parseHtml("<a href=\"HTTPS://Teams.example/Join\">Join</a>").links.single().url)
+            .isEqualTo("https://Teams.example/Join")
+    }
+
+    @Test
+    fun `a query parameter is not read as an entity`() {
+        assertThat(parseHtml("<a href=\"https://x.example/?id=5&reg=eu&times=3\">x</a>").links.single().url)
+            .isEqualTo("https://x.example/?id=5&reg=eu&times=3")
+    }
+
+    @Test
+    fun `outlook cells with paragraphs still sit side by side`() {
+        val html = "<table><tr><td><p class=MsoNormal>9:00</p></td><td><p class=MsoNormal><b>Intro</b></p></td></tr>" +
+            "<tr><td><p>10:00</p></td><td><p>Talk</p></td></tr></table>"
+        val rich = parseHtml(html)
+        assertThat(rich.text).isEqualTo("9:00 · Intro\n10:00 · Talk")
+        assertThat(rich.styles).containsExactly(StyleRange(7, 12, InlineStyle.Bold))
+    }
+
+    @Test
+    fun `empty cells anywhere in a row leave no separator`() {
+        val html = "<table><tr><td>Time</td><td>&nbsp;</td><td>Topic</td><td></td></tr></table>"
+        assertThat(parseHtml(html).text).isEqualTo("Time · Topic")
+    }
+
+    @Test
+    fun `a trailing empty cell doesn't join the text after the table`() {
+        val html = "<table><tr><td>10:00</td><td>Demo</td><td></td></tr></table><p>After</p>"
+        assertThat(parseHtml(html).text).isEqualTo("10:00 · Demo\nAfter")
+    }
+
+    @Test
+    fun `an unclosed head or style doesn't swallow the description`() {
+        assertThat(parseHtml("<html><head><meta charset=utf-8><body><p>Agenda</p>").text).isEqualTo("Agenda")
+        assertThat(parseHtml("<style>p{}<p>Agenda</p>").text).contains("Agenda")
+    }
+
+    @Test
+    fun `a list in a later cell keeps its bullet clean`() {
+        val html = "<table><tr><td>Agenda</td><td><ul><li>Intro</li></ul></td></tr></table>"
+        assertThat(parseHtml(html).text).isEqualTo("Agenda\n• Intro")
+    }
+
+    @Test
+    fun `an empty trailing item doesn't pull the next paragraph into the list`() {
+        assertThat(parseHtml("<ul><li>A</li><li></li></ul><p>Next steps</p>").text).isEqualTo("• A\nNext steps")
+    }
+
+    @Test
+    fun `an ordered list honours its start`() {
+        assertThat(parseHtml("<ol start=\"3\"><li>C</li><li>D</li></ol>").text).isEqualTo("3. C\n4. D")
+    }
+
+    @Test
+    fun `every tag the renderer knows counts as html`() {
+        assertThat(looksLikeHtml("Run <code>make deploy</code>")).isTrue()
+        assertThat(looksLikeHtml("Price <del>50</del> 40")).isTrue()
+    }
+
+    @Test
+    fun `latin-1 entities decode`() {
+        assertThat(decodeEntities("Le&oacute;n, &iacute;ndice, &Aring;s, &yuml;")).isEqualTo("León, índice, Ås, ÿ")
+    }
+
+    @Test
+    fun `copied text keeps the addresses of its links`() {
+        val rich = parseHtml(
+            "<p><a href=\"https://teams.example/join\">Join</a> or <a href=\"https://x.y\">https://x.y</a>" +
+                " <a href=\"mailto:a@b.c\">Mail</a></p>",
+        )
+        assertThat(rich.copyText()).isEqualTo("Join (https://teams.example/join) or https://x.y Mail (a@b.c)")
+    }
+}

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

@@ -53,8 +53,8 @@ class InsertEventFormTest {
         )
         assertThat(form.calendarId).isNull() // resolves to last-used / first-writable
         assertThat(form.isAllDay).isFalse()
-        assertThat(form.start).isEqualTo(start)
-        assertThat(form.end).isEqualTo(end)
+        assertThat(form.start.dateTime).isEqualTo(start)
+        assertThat(form.end.dateTime).isEqualTo(end)
         assertThat(form.title).isEqualTo("Standup")
         assertThat(form.description).isEqualTo("Daily")
         assertThat(form.location).isEqualTo("Room 1")
@@ -64,8 +64,8 @@ class InsertEventFormTest {
     @Test
     fun `missing times default to the next full hour and a one-hour duration`() {
         val form = build(title = "Quick note")
-        assertThat(form.start).isEqualTo(LocalDateTime(2026, 1, 15, 11, 0))
-        assertThat(form.end).isEqualTo(LocalDateTime(2026, 1, 15, 12, 0))
+        assertThat(form.start.dateTime).isEqualTo(LocalDateTime(2026, 1, 15, 11, 0))
+        assertThat(form.end.dateTime).isEqualTo(LocalDateTime(2026, 1, 15, 12, 0))
         assertThat(form.title).isEqualTo("Quick note")
     }
 
@@ -73,8 +73,8 @@ class InsertEventFormTest {
     fun `timed event with only a start gets a one-hour end`() {
         val start = LocalDateTime(2026, 5, 2, 9, 0)
         val form = build(beginMillis = millis(start))
-        assertThat(form.start).isEqualTo(start)
-        assertThat(form.end).isEqualTo(LocalDateTime(2026, 5, 2, 10, 0))
+        assertThat(form.start.dateTime).isEqualTo(start)
+        assertThat(form.end.dateTime).isEqualTo(LocalDateTime(2026, 5, 2, 10, 0))
     }
 
     @Test
@@ -82,7 +82,7 @@ class InsertEventFormTest {
         val start = LocalDateTime(2026, 5, 2, 9, 0)
         val badEnd = LocalDateTime(2026, 5, 2, 8, 0)
         val form = build(beginMillis = millis(start), endMillis = millis(badEnd))
-        assertThat(form.end).isEqualTo(LocalDateTime(2026, 5, 2, 10, 0))
+        assertThat(form.end.dateTime).isEqualTo(LocalDateTime(2026, 5, 2, 10, 0))
     }
 
     @Test

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

@@ -0,0 +1,57 @@
+package de.jeanlucmakiola.calendula.domain
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
+
+class SharedTextTest {
+
+    @Test
+    fun `subject becomes the title and the text the description`() {
+        assertThat(sharedTextOrNull("Dinner", "Friday at Luigi's\nBring wine"))
+            .isEqualTo(SharedText("Dinner", "Friday at Luigi's\nBring wine"))
+    }
+
+    @Test
+    fun `without a subject the first line is the title and the rest the description`() {
+        assertThat(sharedTextOrNull(null, "\n  Dentist  \n\nCheck-up, room 4\n"))
+            .isEqualTo(SharedText("Dentist", "Check-up, room 4"))
+    }
+
+    @Test
+    fun `a single line is the title only`() {
+        assertThat(sharedTextOrNull("  ", " Call mum ")).isEqualTo(SharedText("Call mum", ""))
+    }
+
+    @Test
+    fun `subject without text leaves the description empty`() {
+        assertThat(sharedTextOrNull("Meeting", null)).isEqualTo(SharedText("Meeting", ""))
+    }
+
+    @Test
+    fun `a long first line is cut and the full text kept as the description`() {
+        val line = "a".repeat(300)
+        val shared = sharedTextOrNull(null, "$line\nmore")!!
+        assertThat(shared.title).isEqualTo("a".repeat(255))
+        assertThat(shared.description).isEqualTo("$line\nmore")
+    }
+
+    @Test
+    fun `a long subject is cut and kept in full above the text`() {
+        val subject = "s".repeat(300)
+        val shared = sharedTextOrNull(subject, "body")!!
+        assertThat(shared.title).hasLength(255)
+        assertThat(shared.description).isEqualTo("$subject\n\nbody")
+    }
+
+    @Test
+    fun `the cut never splits a surrogate pair`() {
+        val shared = sharedTextOrNull(null, "a".repeat(254) + "😀" + "b")!!
+        assertThat(shared.title).isEqualTo("a".repeat(254))
+    }
+
+    @Test
+    fun `nothing usable is null`() {
+        assertThat(sharedTextOrNull(null, null)).isNull()
+        assertThat(sharedTextOrNull(" ", "\n \n")).isNull()
+    }
+}

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

@@ -29,8 +29,8 @@ class ParsedIcsFormTest {
         assertThat(form.calendarId).isNull()
         assertThat(form.title).isEqualTo("Call")
         // 13:00 UTC == 15:00 Berlin (summer).
-        assertThat(form.start).isEqualTo(LocalDateTime(2026, 6, 18, 15, 0, 0))
-        assertThat(form.end).isEqualTo(LocalDateTime(2026, 6, 18, 16, 0, 0))
+        assertThat(form.start.dateTime).isEqualTo(LocalDateTime(2026, 6, 18, 15, 0, 0))
+        assertThat(form.end.dateTime).isEqualTo(LocalDateTime(2026, 6, 18, 16, 0, 0))
         assertThat(form.reminders).containsExactly(5, 10).inOrder()
         assertThat(form.rrule).isEqualTo("FREQ=WEEKLY")
     }

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

@@ -0,0 +1,68 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import com.google.common.truth.Truth.assertThat
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import org.junit.jupiter.api.Test
+
+/** A block drafted on an empty timeline slot (#153). */
+class DraftBlockTest {
+
+    private val zone = TimeZone.UTC
+    private val day = LocalDate(2026, 10, 9)
+
+    private fun draft(startMin: Int, minutes: Int) =
+        draftEvent("New event", 0, wallClockInstant(day, startMin, zone), minutes)
+
+    @Test
+    fun `a press snaps down to the slot it is in`() {
+        assertThat(draftStartMin(9 * 60 + 14f)).isEqualTo(9 * 60)
+        assertThat(draftStartMin(9 * 60 + 15f)).isEqualTo(9 * 60 + 15)
+    }
+
+    @Test
+    fun `a press at the very bottom still leaves a slot before midnight`() {
+        assertThat(draftStartMin(24 * 60f)).isEqualTo(24 * 60 - DRAG_SNAP_MINUTES)
+    }
+
+    @Test
+    fun `the draft is told apart from real events`() {
+        assertThat(draft(9 * 60, 60).isDraft).isTrue()
+    }
+
+    @Test
+    fun `a draft within its day is one block the column wide`() {
+        val block = draftBlock(draft(9 * 60, 60), day, zone)!!
+        assertThat(block.startMin).isEqualTo(9 * 60)
+        assertThat(block.endMin).isEqualTo(10 * 60)
+        assertThat(block.lane to block.laneCount).isEqualTo(0 to 1)
+    }
+
+    @Test
+    fun `a draft past midnight is cut there and carries on the next day`() {
+        val event = draft(23 * 60, 120)
+        val first = draftBlock(event, day, zone)!!
+        val second = draftBlock(event, day.plusDays(1), zone)!!
+        assertThat(first.startMin to first.endMin).isEqualTo(23 * 60 to 24 * 60)
+        assertThat(second.startMin to second.endMin).isEqualTo(0 to 60)
+    }
+
+    @Test
+    fun `a draft ending at midnight leaves the next day alone`() {
+        assertThat(draftBlock(draft(23 * 60, 60), day.plusDays(1), zone)).isNull()
+    }
+
+    @Test
+    fun `a draft misses the day before it`() {
+        assertThat(draftBlock(draft(9 * 60, 60), day.plusDays(-1), zone)).isNull()
+    }
+
+    @Test
+    fun `a draft past midnight opens the form with its end on the next day`() {
+        val span = wallClockSpan(draft(23 * 60, 120), zone)
+        assertThat(span).isEqualTo(WallClockSpan(day, 23 * 60, 25 * 60))
+        assertThat(wallClockTime(span.day, span.endMin)).isEqualTo(wallClockTime(day.plusDays(1), 60))
+    }
+
+    private fun LocalDate.plusDays(days: Int): LocalDate = LocalDate.fromEpochDays(toEpochDays() + days)
+}

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

@@ -0,0 +1,30 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import com.google.common.truth.Truth.assertThat
+import kotlinx.datetime.TimeZone
+import org.junit.jupiter.api.Test
+import java.util.Locale
+import kotlin.time.Instant
+
+/** The zone named after a time only where the fall-back hour repeats it (#387). */
+class RepeatedHourZoneTest {
+
+    private val brussels = TimeZone.of("Europe/Brussels")
+
+    @Test
+    fun `both 02 30s of the fall-back day are told apart`() {
+        val first = withRepeatedHourZone("2:30 AM", Instant.parse("2026-10-25T00:30:00Z"), brussels, Locale.UK)
+        val second = withRepeatedHourZone("2:30 AM", Instant.parse("2026-10-25T01:30:00Z"), brussels, Locale.UK)
+        assertThat(first).startsWith("2:30 AM ")
+        assertThat(second).startsWith("2:30 AM ")
+        assertThat(first).isNotEqualTo(second)
+    }
+
+    @Test
+    fun `an unambiguous time stays bare`() {
+        assertThat(withRepeatedHourZone("2:45 PM", Instant.parse("2026-10-25T13:45:00Z"), brussels, Locale.UK))
+            .isEqualTo("2:45 PM")
+        assertThat(withRepeatedHourZone("3:30 AM", Instant.parse("2026-10-25T02:30:00Z"), brussels, Locale.UK))
+            .isEqualTo("3:30 AM")
+    }
+}

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

@@ -2,6 +2,7 @@ package de.jeanlucmakiola.calendula.ui.common
 
 import androidx.datastore.preferences.core.PreferenceDataStoreFactory
 import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.data.time.FakeZoneSource
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepositoryImpl
 import de.jeanlucmakiola.calendula.data.calendar.FakeCalendarDataSource
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
@@ -93,7 +94,7 @@ class RescheduleViewModelTest {
             ),
         )
         val repo = CalendarRepositoryImpl(fake, prefs, settings, dispatcher as CoroutineDispatcher)
-        return RescheduleViewModel(repo, dispatcher)
+        return RescheduleViewModel(repo, dispatcher, FakeZoneSource())
     }
 
     private fun CoroutineScope.activate(vm: RescheduleViewModel): Job =

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

@@ -2,14 +2,18 @@ package de.jeanlucmakiola.calendula.ui.common
 
 import com.google.common.truth.Truth.assertThat
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.repeatedHourOffsetAt
 import de.jeanlucmakiola.calendula.ui.week.TimedBlock
 import de.jeanlucmakiola.calendula.ui.week.layoutDay
+import de.jeanlucmakiola.calendula.ui.week.minutesPast
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.atTime
 import kotlinx.datetime.plus
 import kotlinx.datetime.toInstant
+import kotlin.time.Duration.Companion.hours
+import kotlin.time.Instant
 import org.junit.jupiter.api.Test
 
 /**
@@ -153,4 +157,135 @@ class TimelineDropTest {
         val block = layoutDay(listOf(plain), sat, zone).single()
         assertThat(block.clipOffsetMinutes(sat, zone)).isEqualTo(0)
     }
+
+    private val brussels = TimeZone.of("Europe/Brussels")
+    private val fallBack = LocalDate(2026, 10, 25)
+
+    @Test
+    fun `a block on the fall-back day carries no clip offset`() {
+        // #387: 13:45Z is 14:45 CET, drawn and picked up at 14:45.
+        val event = overnight.copy(
+            start = Instant.parse("2026-10-25T13:45:00Z"),
+            end = Instant.parse("2026-10-25T15:45:00Z"),
+        )
+        val block = layoutDay(listOf(event), fallBack, brussels).single()
+        assertThat(block.clipOffsetMinutes(fallBack, brussels)).isEqualTo(0)
+        val drop = TimelineDrop(event, fallBack, block.startMin, clipOffsetMin = 0)
+        assertThat(drop.startInstant(brussels)).isEqualTo(event.start)
+    }
+
+    @Test
+    fun `a tail on the fall-back day is offset by wall-clock time`() {
+        val event = overnight.copy(
+            start = LocalDate(2026, 10, 24).atTime(22, 0).toInstant(brussels),
+            end = fallBack.atTime(6, 0).toInstant(brussels),
+        )
+        val tail = layoutDay(listOf(event), fallBack, brussels).single()
+        val offset = tail.clipOffsetMinutes(fallBack, brussels)
+        assertThat(offset).isEqualTo(2 * 60)
+        val drop = TimelineDrop(event, fallBack, tail.startMin, clipOffsetMin = offset)
+        assertThat(drop.startInstant(brussels)).isEqualTo(event.start)
+    }
+
+    @Test
+    fun `wall-clock span follows the clock change`() {
+        // 01:00 to 04:00 on the fall-back day is four real hours.
+        assertThat(wallClockSpanMinutes(fallBack, 60, 4.hours, brussels)).isEqualTo(3 * 60)
+        // 01:00 to 04:00 on the spring-forward day is two.
+        assertThat(wallClockSpanMinutes(LocalDate(2026, 3, 29), 60, 2.hours, brussels)).isEqualTo(3 * 60)
+        assertThat(wallClockSpanMinutes(sat, 20 * 60, 12.hours, zone)).isEqualTo(12 * 60)
+    }
+
+    @Test
+    fun `a drop in the repeated fall-back hour keeps the event's offset`() {
+        // 02:30 CET, the second 02:30 of the day, dragged 15 minutes later.
+        val event = overnight.copy(
+            start = Instant.parse("2026-10-25T01:30:00Z"),
+            end = Instant.parse("2026-10-25T02:30:00Z"),
+        )
+        val block = layoutDay(listOf(event), fallBack, brussels).single()
+        val drop = TimelineDrop(event, fallBack, block.startMin + 15, clipOffsetMin = 0)
+        assertThat(drop.startInstant(brussels)).isEqualTo(Instant.parse("2026-10-25T01:45:00Z"))
+    }
+
+    @Test
+    fun `an ambiguous time without an offset to keep takes the earlier one`() {
+        assertThat(wallClockInstant(fallBack, 2 * 60 + 45, brussels))
+            .isEqualTo(Instant.parse("2026-10-25T00:45:00Z"))
+    }
+
+    @Test
+    fun `a start in the spring-forward gap resolves an hour on`() {
+        val springForward = LocalDate(2026, 3, 29)
+        val landed = wallClockInstant(springForward, 2 * 60 + 30, brussels, kept = brussels.repeatedHourOffsetAt(overnight.start))
+        assertThat(landed.minutesPast(springForward, brussels)).isEqualTo(3 * 60 + 30)
+        assertThat(wallClockSpanMinutes(springForward, 3 * 60 + 30, 1.hours, brussels)).isEqualTo(60)
+    }
+
+    @Test
+    fun `a span ending in the repeated fall-back hour reaches that hour's end`() {
+        // 02:00 CEST plus one hour is 02:00 CET; 02:30 CEST plus one is 02:30 CET.
+        assertThat(wallClockSpanMinutes(fallBack, 2 * 60, 1.hours, brussels)).isEqualTo(60)
+        assertThat(wallClockSpanMinutes(fallBack, 2 * 60 + 30, 1.hours, brussels)).isEqualTo(30)
+    }
+
+    @Test
+    fun `a drop onto the repeated fall-back hour doesn't depend on the event's season`() {
+        val slot = 2 * 60 + 30
+        val first = Instant.parse("2026-10-25T00:30:00Z")
+        val july = Instant.parse("2026-07-01T10:00:00Z")
+        val november = Instant.parse("2026-11-10T10:00:00Z")
+        assertThat(wallClockInstant(fallBack, slot, brussels, kept = brussels.repeatedHourOffsetAt(july))).isEqualTo(first)
+        assertThat(wallClockInstant(fallBack, slot, brussels, kept = brussels.repeatedHourOffsetAt(november))).isEqualTo(first)
+        // Later the same day, after the clocks went back: still no say.
+        val evening = Instant.parse("2026-10-25T18:00:00Z")
+        assertThat(wallClockInstant(fallBack, slot, brussels, kept = brussels.repeatedHourOffsetAt(evening))).isEqualTo(first)
+    }
+
+    @Test
+    fun `a bottom resize into the repeated hour keeps a second-pass start's pass`() {
+        // 02:30 CET (the second pass) to 04:00, its end pulled up to 02:45.
+        val event = overnight.copy(
+            start = Instant.parse("2026-10-25T01:30:00Z"),
+            end = Instant.parse("2026-10-25T03:00:00Z"),
+        )
+        val drop = resizedDrop(event, ResizeEdge.Bottom, fallBack, 2 * 60 + 30, 15, brussels)
+        assertThat(drop.start).isEqualTo(event.start)
+        assertThat(drop.end).isEqualTo(Instant.parse("2026-10-25T01:45:00Z"))
+    }
+
+    @Test
+    fun `a resized edge keeps its own pass over the other edge's`() {
+        // 02:30 CEST (the first pass) to 02:15 CET (the second), the start pulled to 02:00.
+        val event = overnight.copy(
+            start = Instant.parse("2026-10-25T00:30:00Z"),
+            end = Instant.parse("2026-10-25T01:15:00Z"),
+        )
+        val drop = resizedDrop(event, ResizeEdge.Top, fallBack, 2 * 60, 60, brussels)
+        assertThat(drop.start).isEqualTo(Instant.parse("2026-10-25T00:00:00Z"))
+        assertThat(drop.end).isEqualTo(event.end)
+    }
+
+    @Test
+    fun `a bottom resize up the repeated hour shortens the event`() {
+        // 02:20 CEST to 02:10 CET is drawn 02:20 to 03:00; its end pulled up to 02:50.
+        val event = overnight.copy(
+            start = Instant.parse("2026-10-25T00:20:00Z"),
+            end = Instant.parse("2026-10-25T01:10:00Z"),
+        )
+        val drop = resizedDrop(event, ResizeEdge.Bottom, fallBack, 2 * 60 + 20, 30, brussels)
+        assertThat(drop.end).isEqualTo(Instant.parse("2026-10-25T00:50:00Z"))
+    }
+
+    @Test
+    fun `a bottom resize to a time the grid draws once lands there`() {
+        // 01:00 CEST to 04:00 CET, its end pulled up to 02:15: only the first pass
+        // is drawn at 02:15, the second would be drawn down at 03:00.
+        val event = overnight.copy(
+            start = Instant.parse("2026-10-24T23:00:00Z"),
+            end = Instant.parse("2026-10-25T03:00:00Z"),
+        )
+        val drop = resizedDrop(event, ResizeEdge.Bottom, fallBack, 60, 75, brussels)
+        assertThat(drop.end).isEqualTo(Instant.parse("2026-10-25T00:15:00Z"))
+    }
 }

app/src/test/java/de/jeanlucmakiola/calendula/ui/detail/PhoneLinksTest.kt

@@ -0,0 +1,217 @@
+package de.jeanlucmakiola.calendula.ui.detail
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
+
+/**
+ * The fitting applied on top of the platform matcher. What the matcher itself
+ * finds is covered on a device by PhoneLinksPlatformTest.
+ */
+class PhoneLinksTest {
+
+    /** Refine a match the platform found at [found] in [text]. */
+    private fun refine(text: String, found: String): List<PhoneLink> {
+        val start = text.indexOf(found)
+        return refinePhoneMatches(
+            text,
+            listOf(PhoneMatch(start, start + found.length)),
+            findWebLinks(text),
+        )
+    }
+
+    @Test
+    fun `a match keeps its span and dials only digits`() {
+        val text = "Call Anna on 0151 234-5678 before"
+        val link = refine(text, "0151 234-5678").single()
+        assertThat(link.number).isEqualTo("01512345678")
+        assertThat(text.substring(link.start, link.end)).isEqualTo("0151 234-5678")
+    }
+
+    @Test
+    fun `an international number keeps its plus`() {
+        assertThat(refine("Tel. +49 30 1234567", "+49 30 1234567").single().number)
+            .isEqualTo("+49301234567")
+    }
+
+    @Test
+    fun `the trunk zero of an international number is dropped`() {
+        assertThat(refine("+49 (0) 151 2345678", "+49 (0) 151 2345678").single().number)
+            .isEqualTo("+491512345678")
+    }
+
+    @Test
+    fun `a country code stranded before the trunk zero is pulled back in`() {
+        val text = "Mobil: +49 (0)151 2345678"
+        val link = refine(text, "151 2345678").single()
+        assertThat(link.number).isEqualTo("+491512345678")
+        assertThat(text.substring(link.start, link.end)).isEqualTo("+49 (0)151 2345678")
+    }
+
+    @Test
+    fun `a conference dial-in keeps its pauses and meeting id`() {
+        val text = "One tap mobile: +16465588656,,85012345678#,,,,*123456# (US)"
+        val link = refine(text, "+16465588656").single()
+        assertThat(link.number).isEqualTo("+16465588656,,85012345678#,,,,*123456#")
+        assertThat(text.substring(link.start, link.end))
+            .isEqualTo("+16465588656,,85012345678#,,,,*123456#")
+    }
+
+    @Test
+    fun `meeting ids and PINs are not numbers to call`() {
+        assertThat(refine("Meeting ID: 850 1234 5678", "850 1234 5678")).isEmpty()
+        assertThat(refine("Conference ID: 123 456 789#", "123 456 789")).isEmpty()
+        assertThat(refine("PIN: 123 456 789#", "123 456 789")).isEmpty()
+        assertThat(refine("Konferenz-ID: 123 456 789#", "123 456 789")).isEmpty()
+        assertThat(refine("Access code: 2345 678 9012", "2345 678 9012")).isEmpty()
+    }
+
+    @Test
+    fun `a label on an earlier line does not hide a number`() {
+        assertThat(refine("Meeting ID: 850 1234 5678\nDial +1 646 558 8656", "+1 646 558 8656"))
+            .hasSize(1)
+    }
+
+    @Test
+    fun `a label earlier on the same line does not hide a later number`() {
+        assertThat(refine("PIN 1234, call +1 646 558 8656", "+1 646 558 8656")).hasSize(1)
+    }
+
+    @Test
+    fun `a match holding a date is not a number`() {
+        assertThat(refine("Am 14.10.2026 10:00 Uhr", "14.10.2026 10")).isEmpty()
+        assertThat(refine("2026-10-14 10:00", "2026-10-14 10")).isEmpty()
+        assertThat(refine("10/14/2026 9:00", "10/14/2026 9")).isEmpty()
+        assertThat(refine("14.10.26 - 16.10.26", "14.10.26 - 16.10.26")).isEmpty()
+    }
+
+    @Test
+    fun `amounts are not numbers`() {
+        assertThat(refine("Budget 1.250.000 EUR", "1.250.000")).isEmpty()
+        assertThat(refine("Budget 1 250 000 EUR", "1 250 000")).isEmpty()
+    }
+
+    @Test
+    fun `an area code in threes is still a number`() {
+        assertThat(refine("030 123 456", "030 123 456")).hasSize(1)
+    }
+
+    @Test
+    fun `numbers in dotted pairs are not dates`() {
+        assertThat(refine("01.23.45.67.89", "01.23.45.67.89").single().number)
+            .isEqualTo("0123456789")
+        assertThat(refine("555.123.4567", "555.123.4567")).hasSize(1)
+    }
+
+    @Test
+    fun `a stray count after the number is trimmed`() {
+        val text = "Call +49 151 2345678 2 times"
+        val link = refine(text, "+49 151 2345678 2").single()
+        assertThat(link.number).isEqualTo("+491512345678")
+        assertThat(text.substring(link.start, link.end)).isEqualTo("+49 151 2345678")
+    }
+
+    @Test
+    fun `short trailing groups of a real number stay`() {
+        assertThat(refine("030 123 45 67", "030 123 45 67").single().number).isEqualTo("0301234567")
+    }
+
+    @Test
+    fun `spaced threes without a currency are a number`() {
+        assertThat(refine("Móvil 612 345 678", "612 345 678").single().number).isEqualTo("612345678")
+    }
+
+    @Test
+    fun `a trailing pair after a short group stays`() {
+        val text = "Büro 0221 1234 56"
+        val link = refine(text, "0221 1234 56").single()
+        assertThat(link.number).isEqualTo("0221123456")
+        assertThat(text.substring(link.start, link.end)).isEqualTo("0221 1234 56")
+    }
+
+    @Test
+    fun `an extension becomes a pause`() {
+        assertThat(refine("+1 212 555 1234 ext. 567", "+1 212 555 1234 ext. 567").single().number)
+            .isEqualTo("+12125551234,567")
+        assertThat(refine("+1 212 555 1234 x567", "+1 212 555 1234 x567").single().number)
+            .isEqualTo("+12125551234,567")
+    }
+
+    @Test
+    fun `postcodes and other short runs are not numbers`() {
+        assertThat(refine("Hauptstraße 12, 10115 Berlin", "10115")).isEmpty()
+        assertThat(refine("Raum 123456", "123456")).isEmpty()
+    }
+
+    @Test
+    fun `a Webex access code is not a number to call`() {
+        assertThat(refine("Meeting number (access code): 2732 123 4567", "2732 123 4567")).isEmpty()
+    }
+
+    @Test
+    fun `a conference number is a number to call`() {
+        assertThat(refine("Conference number: +49 30 1234567", "+49 30 1234567")).hasSize(1)
+        assertThat(refine("Konferenznummer: +49 30 1234567", "+49 30 1234567")).hasSize(1)
+    }
+
+    @Test
+    fun `a comma-separated list stays separate numbers`() {
+        val text = "Tel 030 1234567,0151 2345678"
+        val first = text.indexOf("030")
+        val second = text.indexOf("0151")
+        val links = refinePhoneMatches(
+            text,
+            listOf(PhoneMatch(first, first + 11), PhoneMatch(second, text.length)),
+            emptyList(),
+        )
+        assertThat(links.map { it.number }).containsExactly("0301234567", "01512345678").inOrder()
+    }
+
+    @Test
+    fun `a single-comma suffix closed by a hash is a dial-in`() {
+        assertThat(refine("+1 555 123 4567,123456#", "+1 555 123 4567").single().number)
+            .isEqualTo("+15551234567,123456#")
+    }
+
+    @Test
+    fun `labels behind invisible spacing still hide an id`() {
+        assertThat(refine("PIN: \u202A123 456 789\u202C#", "123 456 789")).isEmpty()
+        assertThat(refine("Meeting ID:\u00A0850 1234 5678", "850 1234 5678")).isEmpty()
+    }
+
+    @Test
+    fun `dotted times of day are not numbers`() {
+        assertThat(refine("Beginn 9.30 – 12.00 Uhr", "9.30 – 12.00")).isEmpty()
+        assertThat(refine("10.00-11.30", "10.00-11.30")).isEmpty()
+    }
+
+    @Test
+    fun `a trailing digit with no word after it stays`() {
+        assertThat(refine("Zentrale 030 123456 0", "030 123456 0").single().number)
+            .isEqualTo("0301234560")
+        assertThat(refine("0221 9876543 21\nnext line", "0221 9876543 21").single().number)
+            .isEqualTo("0221987654321")
+    }
+
+    @Test
+    fun `digits in a URL without its scheme are not a number`() {
+        assertThat(refine("zoom.us/j/85012345678", "85012345678")).isEmpty()
+        assertThat(refine("room?id=0301234567", "0301234567")).isEmpty()
+    }
+
+    @Test
+    fun `dotted threes without a currency are a number`() {
+        assertThat(refine("Móvil 612.345.678", "612.345.678")).hasSize(1)
+        assertThat(refine("Budget 125.000.000 €", "125.000.000")).isEmpty()
+    }
+
+    @Test
+    fun `digits inside a web link are not a number`() {
+        assertThat(refine("https://x.example/030-1234567", "030-1234567")).isEmpty()
+    }
+
+    @Test
+    fun `a number beside a web link is still found`() {
+        assertThat(refine("https://zoom.us/j/85012345678 or dial +1 646 558 8656", "+1 646 558 8656"))
+            .hasSize(1)
+    }
+}

app/src/test/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModelTest.kt

@@ -1,31 +1,42 @@
 package de.jeanlucmakiola.calendula.ui.edit
 
+import android.content.ContextWrapper
 import androidx.datastore.core.DataStore
 import androidx.datastore.preferences.core.PreferenceDataStoreFactory
 import androidx.datastore.preferences.core.Preferences
 import com.google.common.truth.Truth.assertThat
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepositoryImpl
 import de.jeanlucmakiola.calendula.data.calendar.FakeCalendarDataSource
+import de.jeanlucmakiola.calendula.data.calendar.NoSuchEventException
+import de.jeanlucmakiola.calendula.data.ics.IcsExporter
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
+import de.jeanlucmakiola.calendula.data.time.FakeZoneSource
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.FormTime
+import de.jeanlucmakiola.calendula.domain.startInstant
+import de.jeanlucmakiola.calendula.domain.problems
+import de.jeanlucmakiola.calendula.domain.endInstant
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.UnconfinedTestDispatcher
 import kotlinx.coroutines.test.advanceUntilIdle
 import kotlinx.coroutines.test.resetMain
 import kotlinx.coroutines.test.runTest
 import kotlinx.coroutines.test.setMain
 import kotlinx.coroutines.Dispatchers
+import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
 import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
@@ -59,11 +70,16 @@ class EventEditViewModelTest {
         syncsEvents = syncsEvents,
     )
 
-    private fun detail(calendarId: Long, rrule: String? = null): EventDetail = EventDetail(
+    private fun detail(
+        calendarId: Long,
+        rrule: String? = null,
+        start: Instant = Instant.fromEpochMilliseconds(beginMillis),
+        end: Instant = Instant.fromEpochMilliseconds(endMillis),
+    ): EventDetail = EventDetail(
         instance = EventInstance(
             instanceId = 42L, eventId = 42L, calendarId = calendarId, title = "Standup",
-            start = Instant.fromEpochMilliseconds(beginMillis),
-            end = Instant.fromEpochMilliseconds(endMillis),
+            start = start,
+            end = end,
             isAllDay = false, color = 0xFF000000.toInt(), location = null,
         ),
         description = null, organizer = null, attendees = emptyList(), rrule = rrule,
@@ -92,10 +108,15 @@ class EventEditViewModelTest {
         // Passed in by the tests that need to seed a setting first; a second
         // DataStore on the same file would clash, so it is built only once.
         s: SettingsPrefs = settings(tempDir),
+        zones: FakeZoneSource = FakeZoneSource(),
+        // A queued dispatcher here holds provider reads and writes until the test
+        // advances, so it can close the form while one is in flight.
+        io: CoroutineDispatcher = dispatcher,
     ): EventEditViewModel {
         val p = prefs(tempDir)
-        val repo = CalendarRepositoryImpl(fake, p, s, dispatcher as CoroutineDispatcher)
-        return EventEditViewModel(repo, p, s, dispatcher)
+        val repo = CalendarRepositoryImpl(fake, p, s, io)
+        // Only `shareUri()` touches the exporter, and nothing here shares.
+        return EventEditViewModel(repo, p, s, IcsExporter(ContextWrapper(null)), dispatcher, zones)
     }
 
     /** Keep [EventEditViewModel.state] hot so it computes while the test drives it. */
@@ -221,12 +242,12 @@ class EventEditViewModelTest {
         advanceUntilIdle()
 
         // Calendar 1 has no length of its own, so it inherits the global 30 min.
-        assertThat(vm.state.value?.form?.end).isEqualTo(LocalDateTime(2030, 1, 15, 9, 30))
+        assertThat(vm.state.value?.form?.end?.dateTime).isEqualTo(LocalDateTime(2030, 1, 15, 9, 30))
 
         vm.setCalendar(2L)
         advanceUntilIdle()
 
-        assertThat(vm.state.value?.form?.end).isEqualTo(LocalDateTime(2030, 1, 15, 17, 0))
+        assertThat(vm.state.value?.form?.end?.dateTime).isEqualTo(LocalDateTime(2030, 1, 15, 17, 0))
         job.cancel()
     }
 
@@ -246,7 +267,7 @@ class EventEditViewModelTest {
         vm.setCalendar(2L)
         advanceUntilIdle()
 
-        assertThat(vm.state.value?.form?.end).isEqualTo(LocalDateTime(2030, 1, 15, 10, 15))
+        assertThat(vm.state.value?.form?.end?.dateTime).isEqualTo(LocalDateTime(2030, 1, 15, 10, 15))
         job.cancel()
     }
 
@@ -267,7 +288,7 @@ class EventEditViewModelTest {
         advanceUntilIdle()
 
         // The file owns the length; a calendar switch must not restretch it.
-        assertThat(vm.state.value?.form?.end).isEqualTo(LocalDateTime(2030, 1, 15, 11, 30))
+        assertThat(vm.state.value?.form?.end?.dateTime).isEqualTo(LocalDateTime(2030, 1, 15, 11, 30))
         job.cancel()
     }
 
@@ -288,15 +309,15 @@ class EventEditViewModelTest {
         )
         advanceUntilIdle()
 
-        assertThat(vm.state.value?.form?.end).isEqualTo(LocalDateTime(2030, 1, 15, 9, 30))
+        assertThat(vm.state.value?.form?.end?.dateTime).isEqualTo(LocalDateTime(2030, 1, 15, 9, 30))
         job.cancel()
     }
 
     private fun importedForm(end: LocalDateTime) = EventForm(
         calendarId = null,
         title = "Imported",
-        start = LocalDateTime(2030, 1, 15, 9, 0),
-        end = end,
+        start = FormTime(LocalDateTime(2030, 1, 15, 9, 0)),
+        end = FormTime(end),
     )
 
     @Test
@@ -316,7 +337,7 @@ class EventEditViewModelTest {
         advanceUntilIdle()
 
         // Dates carry no length: the times stay where the form put them.
-        assertThat(vm.state.value?.form?.end).isEqualTo(LocalDateTime(2030, 1, 15, 10, 0))
+        assertThat(vm.state.value?.form?.end?.dateTime).isEqualTo(LocalDateTime(2030, 1, 15, 10, 0))
         job.cancel()
     }
 
@@ -407,4 +428,310 @@ class EventEditViewModelTest {
 
         assertThat(capLength(new, "")).isEqualTo("a".repeat(254))
     }
+
+    @Test
+    fun `an edit counts as unsaved only while it differs from the loaded event`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(cal(1L))
+            eventDetailResult = { detail(calendarId = 1L) }
+        }
+        val vm = viewModel(tempDir, fake)
+        val job = activate(vm)
+
+        vm.openForEdit(eventId = 42L, beginMillis = beginMillis, endMillis = endMillis)
+        advanceUntilIdle()
+        assertThat(vm.hasUnsavedChanges.value).isFalse()
+
+        vm.setTitle("Retro")
+        advanceUntilIdle()
+        assertThat(vm.hasUnsavedChanges.value).isTrue()
+
+        vm.setTitle("Standup")
+        advanceUntilIdle()
+        assertThat(vm.hasUnsavedChanges.value).isFalse()
+        job.cancel()
+    }
+
+    @Test
+    fun `a new form holding only its defaults has nothing to lose`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply { calendarsResult = listOf(cal(1L)) }
+        val vm = viewModel(tempDir, fake)
+        val job = activate(vm)
+
+        vm.openNew(LocalDate(2026, 10, 12), startMinutes = 9 * 60)
+        advanceUntilIdle()
+        assertThat(vm.hasUnsavedChanges.value).isFalse()
+
+        vm.setTitle("Lunch")
+        advanceUntilIdle()
+        assertThat(vm.hasUnsavedChanges.value).isTrue()
+
+        vm.setTitle("")
+        advanceUntilIdle()
+        assertThat(vm.hasUnsavedChanges.value).isFalse()
+        job.cancel()
+    }
+
+    @Test
+    fun `deleting from the form removes the event and reports it`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(cal(1L))
+            eventDetailResult = { detail(calendarId = 1L) }
+        }
+        val vm = viewModel(tempDir, fake)
+        val job = activate(vm)
+
+        vm.openForEdit(eventId = 42L, beginMillis = beginMillis, endMillis = endMillis)
+        advanceUntilIdle()
+        vm.delete(RecurringWriteScope.AllEvents)
+        advanceUntilIdle()
+
+        assertThat(fake.deletedEventIds).containsExactly(42L)
+        assertThat(vm.state.value?.saveState).isEqualTo(SaveUiState.Deleted)
+        job.cancel()
+    }
+
+    @Test
+    fun `deleting an event that is already gone counts as deleted`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(cal(1L))
+            eventDetailResult = { detail(calendarId = 1L) }
+        }
+        val vm = viewModel(tempDir, fake)
+        val job = activate(vm)
+
+        vm.openForEdit(eventId = 42L, beginMillis = beginMillis, endMillis = endMillis)
+        advanceUntilIdle()
+        fake.writeError = NoSuchEventException(42L)
+        vm.delete(RecurringWriteScope.AllEvents)
+        advanceUntilIdle()
+
+        assertThat(vm.state.value?.saveState).isEqualTo(SaveUiState.Deleted)
+        job.cancel()
+    }
+
+    @Test
+    fun `a delete without write access reports it as a delete`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(cal(1L))
+            eventDetailResult = { detail(calendarId = 1L) }
+        }
+        val vm = viewModel(tempDir, fake)
+        val job = activate(vm)
+
+        vm.openForEdit(eventId = 42L, beginMillis = beginMillis, endMillis = endMillis)
+        advanceUntilIdle()
+        fake.writeError = SecurityException()
+        vm.delete(RecurringWriteScope.AllEvents)
+        advanceUntilIdle()
+
+        assertThat(vm.state.value?.saveState).isEqualTo(SaveUiState.DeleteDenied)
+        job.cancel()
+    }
+
+    @Test
+    fun `a blank rrule does not make the edited event recurring`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(cal(1L))
+            eventDetailResult = { detail(calendarId = 1L, rrule = "") }
+        }
+        val vm = viewModel(tempDir, fake)
+        val job = activate(vm)
+
+        vm.openForEdit(eventId = 42L, beginMillis = beginMillis, endMillis = endMillis)
+        advanceUntilIdle()
+
+        assertThat(vm.editedEventRecurs()).isFalse()
+        job.cancel()
+    }
+
+    @Test
+    fun `accepting the default reminders for an import counts as a change`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply { calendarsResult = listOf(cal(1L)) }
+        val s = settings(tempDir)
+        s.setDefaultReminderMinutes(listOf(15))
+        val vm = viewModel(tempDir, fake, s)
+        val job = activate(vm)
+
+        vm.openImported(importedForm(end = LocalDateTime(2030, 1, 15, 10, 0)), ImportSource.File)
+        advanceUntilIdle()
+        assertThat(vm.importReminderPrompt.value).isNotNull()
+        assertThat(vm.hasUnsavedChanges.value).isFalse()
+
+        vm.applyImportedReminderDefault()
+        advanceUntilIdle()
+        assertThat(vm.hasUnsavedChanges.value).isTrue()
+        job.cancel()
+    }
+
+    @Test
+    fun `a drafted block opens at its own instants across the fall-back hour`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply { calendarsResult = listOf(cal(1L)) }
+        val vm = viewModel(tempDir, fake, zones = FakeZoneSource(berlin))
+        val job = activate(vm)
+
+        // An hour from 02:30 CEST ends at 02:30 CET, the same wall clock.
+        vm.openDraft(Instant.parse("2026-10-25T00:30:00Z"), Instant.parse("2026-10-25T01:30:00Z"))
+        advanceUntilIdle()
+
+        val form = vm.state.value!!.form!!
+        assertThat(form.startInstant(berlin)).isEqualTo(Instant.parse("2026-10-25T00:30:00Z"))
+        assertThat(form.endInstant(berlin)).isEqualTo(Instant.parse("2026-10-25T01:30:00Z"))
+        assertThat(form.problems(berlin)).isEmpty()
+        job.cancel()
+    }
+
+    @Test
+    fun `a drafted block on the second pass stays on it at its length`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply { calendarsResult = listOf(cal(1L)) }
+        val s = settings(tempDir)
+        s.setCalendarEventDuration(1L, 480)
+        val vm = viewModel(tempDir, fake, s, FakeZoneSource(berlin))
+        val job = activate(vm)
+
+        // 02:30 CET to 03:00 CET: the default length mustn't stretch it.
+        vm.openDraft(Instant.parse("2026-10-25T01:30:00Z"), Instant.parse("2026-10-25T02:00:00Z"))
+        advanceUntilIdle()
+
+        val form = vm.state.value!!.form!!
+        assertThat(form.startInstant(berlin)).isEqualTo(Instant.parse("2026-10-25T01:30:00Z"))
+        assertThat(form.endInstant(berlin)).isEqualTo(Instant.parse("2026-10-25T02:00:00Z"))
+        job.cancel()
+    }
+
+    @Test
+    fun `a time picked in the repeated hour and back keeps the opened pass`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        // Opened at 02:30 CET (the second pass) to 03:30, its start moved away and back.
+        val begin = Instant.parse("2026-10-25T01:30:00Z")
+        val end = Instant.parse("2026-10-25T02:30:00Z")
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(cal(1L))
+            eventDetailResult = { detail(calendarId = 1L, start = begin, end = end) }
+        }
+        val vm = viewModel(tempDir, fake, zones = FakeZoneSource(berlin))
+        val job = activate(vm)
+        vm.openForEdit(eventId = 1L, beginMillis = begin.toEpochMilliseconds(), endMillis = end.toEpochMilliseconds())
+        advanceUntilIdle()
+        val opened = vm.state.value!!.form!!
+
+        vm.setStartTime(LocalTime(4, 0))
+        vm.setStartTime(LocalTime(2, 30))
+
+        assertThat(vm.state.value!!.form).isEqualTo(opened)
+        job.cancel()
+    }
+
+    private val berlin = TimeZone.of("Europe/Berlin")
+
+    @Test
+    fun `all-day on and off keeps a second-pass event where it was`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val begin = Instant.parse("2026-10-25T01:30:00Z")
+        val end = Instant.parse("2026-10-25T02:30:00Z")
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(cal(1L))
+            eventDetailResult = { detail(calendarId = 1L, start = begin, end = end) }
+        }
+        val vm = viewModel(tempDir, fake, zones = FakeZoneSource(berlin))
+        val job = activate(vm)
+        vm.openForEdit(eventId = 1L, beginMillis = begin.toEpochMilliseconds(), endMillis = end.toEpochMilliseconds())
+        advanceUntilIdle()
+        val opened = vm.state.value!!.form!!
+
+        vm.setAllDay(true)
+        vm.setAllDay(false)
+        advanceUntilIdle()
+
+        assertThat(vm.state.value!!.form).isEqualTo(opened)
+        job.cancel()
+    }
+
+    @Test
+    fun `a load abandoned by closing the form never lands on the next one`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(cal(1L))
+            eventDetailResult = { id ->
+                val base = detail(calendarId = 1L)
+                base.copy(instance = base.instance.copy(eventId = id, title = "Event $id"))
+            }
+        }
+        val vm = viewModel(tempDir, fake, io = StandardTestDispatcher(testScheduler))
+        val job = activate(vm)
+
+        vm.openForEdit(eventId = 1L, beginMillis = beginMillis, endMillis = endMillis)
+        vm.reset()
+        advanceUntilIdle()
+        vm.openForEdit(eventId = 2L, beginMillis = beginMillis, endMillis = endMillis)
+        advanceUntilIdle()
+
+        assertThat(vm.state.value?.form?.title).isEqualTo("Event 2")
+        job.cancel()
+    }
+
+    @Test
+    fun `a failed load abandoned by closing the form doesn't close the next one`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(cal(1L))
+            eventDetailResult = { null }
+        }
+        val vm = viewModel(tempDir, fake, io = StandardTestDispatcher(testScheduler))
+        val job = activate(vm)
+
+        vm.openForEdit(eventId = 1L, beginMillis = beginMillis, endMillis = endMillis)
+        vm.reset()
+        advanceUntilIdle()
+        vm.openNew(LocalDate(2026, 10, 12), startMinutes = 9 * 60)
+        advanceUntilIdle()
+
+        assertThat(vm.loadFailed.value).isFalse()
+        job.cancel()
+    }
+
+    @Test
+    fun `a delete still running when the form closes doesn't report to the next one`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(cal(1L))
+            eventDetailResult = { detail(calendarId = 1L) }
+        }
+        val vm = viewModel(tempDir, fake, io = StandardTestDispatcher(testScheduler))
+        val job = activate(vm)
+
+        vm.openForEdit(eventId = 42L, beginMillis = beginMillis, endMillis = endMillis)
+        advanceUntilIdle()
+        vm.delete(RecurringWriteScope.AllEvents)
+        vm.reset()
+        vm.openNew(LocalDate(2026, 10, 12), startMinutes = 9 * 60)
+        advanceUntilIdle()
+
+        assertThat(fake.deletedEventIds).containsExactly(42L)
+        assertThat(vm.state.value?.saveState).isEqualTo(SaveUiState.Idle)
+        job.cancel()
+    }
 }

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

@@ -190,5 +190,121 @@ class WeekLayoutTest {
         assertThat(spans.all { it.lane == 0 }).isTrue()
     }
 
+    // Europe/Brussels falls back on 2026-10-25 (25 h) and springs forward on 2026-03-29 (23 h).
+    private val brussels = TimeZone.of("Europe/Brussels")
+
+    private fun brusselsEvent(date: LocalDate, from: Pair<Int, Int>, to: Pair<Int, Int>) = event(
+        date.atTime(from.first, from.second).toInstant(brussels),
+        date.atTime(to.first, to.second).toInstant(brussels),
+    )
+
+    @Test
+    fun `timed block sits at its wall-clock time on the fall-back day`() {
+        val day = LocalDate(2026, 10, 25)
+        // The event from #387: 13:45Z is 14:45 CET.
+        val ev = event(Instant.parse("2026-10-25T13:45:00Z"), Instant.parse("2026-10-25T15:45:00Z"))
+        val b = layoutDay(listOf(ev), day, brussels).single()
+        assertThat(b.startMin).isEqualTo(14 * 60 + 45)
+        assertThat(b.endMin).isEqualTo(16 * 60 + 45)
+    }
+
+    @Test
+    fun `timed block sits at its wall-clock time on the spring-forward day`() {
+        val day = LocalDate(2026, 3, 29)
+        val b = layoutDay(listOf(brusselsEvent(day, 14 to 45, 16 to 45)), day, brussels).single()
+        assertThat(b.startMin).isEqualTo(14 * 60 + 45)
+        assertThat(b.endMin).isEqualTo(16 * 60 + 45)
+    }
+
+    @Test
+    fun `late block on the fall-back day is not cut short`() {
+        val day = LocalDate(2026, 10, 25)
+        val b = layoutDay(listOf(brusselsEvent(day, 22 to 30, 23 to 59)), day, brussels).single()
+        assertThat(b.startMin).isEqualTo(22 * 60 + 30)
+        assertThat(b.endMin).isEqualTo(23 * 60 + 59)
+    }
+
+    @Test
+    fun `block running past midnight on the fall-back day reaches the day's end`() {
+        val day = LocalDate(2026, 10, 25)
+        val ev = event(
+            day.atTime(23, 0).toInstant(brussels),
+            day.plusDays(1).atTime(1, 0).toInstant(brussels),
+        )
+        val b = layoutDay(listOf(ev), day, brussels).single()
+        assertThat(b.startMin).isEqualTo(23 * 60)
+        assertThat(b.endMin).isEqualTo(MINUTES_PER_DAY)
+    }
+
+    @Test
+    fun `instant event on the fall-back day sits at its wall-clock time`() {
+        val day = LocalDate(2026, 10, 25)
+        val at = day.atTime(9, 0).toInstant(brussels)
+        val b = layoutDay(listOf(event(at, at)), day, brussels).single()
+        assertThat(b.startMin).isEqualTo(9 * 60)
+        assertThat(b.endMin).isEqualTo(9 * 60)
+    }
+
+    @Test
+    fun `block ending in the repeated fall-back hour is drawn to that hour's end`() {
+        val day = LocalDate(2026, 10, 25)
+        // 02:00 CEST to 02:00 CET: one real hour, the same wall-clock time at both ends.
+        val ev = event(Instant.parse("2026-10-25T00:00:00Z"), Instant.parse("2026-10-25T01:00:00Z"))
+        val b = layoutDay(listOf(ev), day, brussels).single()
+        assertThat(b.startMin).isEqualTo(2 * 60)
+        assertThat(b.endMin).isEqualTo(3 * 60)
+    }
+
+    @Test
+    fun `block ending in the repeated fall-back hour leaves the next hour free`() {
+        val day = LocalDate(2026, 10, 25)
+        // 02:15 CEST to 02:15 CET, then 03:00 CET: an hour apart in real time.
+        val repeat = event(Instant.parse("2026-10-25T00:15:00Z"), Instant.parse("2026-10-25T01:15:00Z"))
+        val next = event(Instant.parse("2026-10-25T02:00:00Z"), Instant.parse("2026-10-25T03:00:00Z"))
+        val blocks = layoutDay(listOf(repeat, next), day, brussels)
+        assertThat(blocks.map { it.startMin to it.endMin })
+            .containsExactly(2 * 60 + 15 to 3 * 60, 3 * 60 to 4 * 60)
+        assertThat(blocks.all { it.lane == 0 && it.laneCount == 1 }).isTrue()
+    }
+
+    @Test
+    fun `minutesPast reads wall clock either side of the day`() {
+        val day = LocalDate(2026, 10, 25)
+        assertThat(Instant.parse("2026-10-24T21:00:00Z").minutesPast(day, brussels)).isEqualTo(-60)
+        assertThat(Instant.parse("2026-10-25T13:45:00Z").minutesPast(day, brussels)).isEqualTo(14 * 60 + 45)
+        assertThat(Instant.parse("2026-10-25T23:30:00Z").minutesPast(day, brussels))
+            .isEqualTo(MINUTES_PER_DAY + 30)
+    }
+
+    @Test
+    fun `a block ending in the repeated fall-back hour is labelled with its own end`() {
+        val day = LocalDate(2026, 10, 25)
+        // 02:30 CEST to 02:30 CET: drawn to the repeated hour's end, but it ends at 02:30.
+        val ev = event(Instant.parse("2026-10-25T00:30:00Z"), Instant.parse("2026-10-25T01:30:00Z"))
+        val b = layoutDay(listOf(ev), day, brussels).single()
+        assertThat(b.endMin).isEqualTo(3 * 60)
+        assertThat(b.labelEndMin(day, brussels)).isEqualTo(2 * 60 + 30)
+    }
+
+    @Test
+    fun `an ordinary block is labelled with its drawn end`() {
+        val day = LocalDate(2026, 10, 25)
+        val b = layoutDay(listOf(brusselsEvent(day, 14 to 45, 16 to 45)), day, brussels).single()
+        assertThat(b.labelEndMin(day, brussels)).isEqualTo(b.endMin)
+    }
+
     private fun LocalDate.plusDays(n: Int): LocalDate = plus(n, DateTimeUnit.DAY)
+
+    @Test
+    fun `a longer run into the repeated fall-back hour is drawn no shorter`() {
+        val day = LocalDate(2026, 10, 25)
+        // 02:10 CEST to 02:05 CET (55 min) and to 02:20 CET (70 min): both to 03:00.
+        val shorter = event(Instant.parse("2026-10-25T00:10:00Z"), Instant.parse("2026-10-25T01:05:00Z"))
+        val longer = event(Instant.parse("2026-10-25T00:10:00Z"), Instant.parse("2026-10-25T01:20:00Z"), id = 2L)
+        assertThat(layoutDay(listOf(shorter), day, brussels).single().endMin).isEqualTo(3 * 60)
+        assertThat(layoutDay(listOf(longer), day, brussels).single().endMin).isEqualTo(3 * 60)
+        // A run that starts on the second pass reads its plain wall clock.
+        val second = event(Instant.parse("2026-10-25T01:10:00Z"), Instant.parse("2026-10-25T01:40:00Z"))
+        assertThat(layoutDay(listOf(second), day, brussels).single().endMin).isEqualTo(2 * 60 + 40)
+    }
 }

docs/ARCHITECTURE.md

@@ -119,7 +119,11 @@ gesture finishes from its scaled preview.
   switch only changes what they say.
 A tapped reminder notification routes through `MainActivity` (`singleTop` +
 `onNewIntent`) as an external detail key that `CalendarHost` consumes
-exactly like an event tap.
+like an event tap. With the "tapping an event opens" setting on the edit form
+(#178), a tap in the views or search opens the edit overlay directly for events
+in writable calendars; notifications and widgets always open the detail. The
+edit form guards its own back: unsaved changes ask to save, discard or keep
+editing.
 
 ### First-launch wizard