Keep timeline events in the right repeated hour on DST fall-back day (#387)

On the day the clocks go back, 02:00–03:00 happens twice. Event times now
remember which of the two they mean, so moving, resizing, editing and saving
keep them in the right one.

- The week and day timeline place blocks by clock time, so events after a DST
  change no longer sit an hour off.
- An event ending in the repeated hour is drawn up to the end of that hour,
  and its label shows its real end time.
- Drags, drops and resizes keep the event's real length across a clock
  change; a resize only changes the edge being dragged.
- A drop onto a repeated time lands on the first one, unless the event is
  already in the second one.
- The editor, event details and the "local time" line add the zone
  abbreviation to a repeated time so the two can be told apart.
- Saving checks and writes the real start and end times, so a span ending in
  the repeated hour is valid and switching between the two is saved.

Closes #387

CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### 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]).
+- **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]).
+
+### Fixed
+- **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]).
+
+## [2.22.5] — 2026-10-07
+
+### Fixed
+- **Reopening the app the next morning shows the right day.** The month view used to mark yesterday as today and keep the day you picked the evening before selected, so you had to tap today to see its events. Every view now moves on to the new day at midnight and when you come back to the app. A view you browsed to another date stays where it is ([#373]).
+
 ## [2.22.4] — 2026-10-07
 
 ### Fixed
@@ -1843,3 +1856,6 @@ automatically, with zero telemetry and no internet permission.
 [#361]: https://codeberg.org/jlmakiola/calendula/issues/361
 [#363]: https://codeberg.org/jlmakiola/calendula/issues/363
 [#364]: https://codeberg.org/jlmakiola/calendula/issues/364
+[#367]: https://codeberg.org/jlmakiola/calendula/issues/367
+[#373]: https://codeberg.org/jlmakiola/calendula/issues/373
+[#141]: https://codeberg.org/jlmakiola/calendula/issues/141

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 = 2220499
-        versionName = "2.22.4"
+        versionCode = 2230002
+        versionName = "2.23.0-beta.2"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

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

@@ -1,5 +1,7 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
+import de.jeanlucmakiola.calendula.domain.resolveIn
+import kotlinx.datetime.toKotlinTimeZone
 import android.provider.CalendarContract
 import de.jeanlucmakiola.calendula.domain.AccessLevel
 import de.jeanlucmakiola.calendula.domain.Availability
@@ -48,8 +50,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.resolveIn(writeZone.toKotlinTimeZone(), startOffset).toEpochMilliseconds(),
+        dtEndMillis = end.resolveIn(writeZone.toKotlinTimeZone(), endOffset).toEpochMilliseconds(),
         timezone = writeZone.id,
     )
 }
@@ -181,12 +183,14 @@ 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 only the resolved instants tell apart (#387).
     val timesChanged = updated.start != original.start ||
         updated.end != original.end ||
         updated.isAllDay != original.isAllDay ||
         updated.rrule != original.rrule ||
-        updated.timezone != original.timezone
+        updated.timezone != original.timezone ||
+        updated.toWriteTimes(zone) != original.toWriteTimes(zone)
     if (!timesChanged) return@buildMap
 
     val newTimes = updated.toWriteTimes(zone)

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

@@ -20,6 +20,8 @@ import de.jeanlucmakiola.calendula.data.contacts.ContactSpecialDatesDataSource
 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.TodaySource
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import javax.inject.Singleton
@@ -61,6 +63,12 @@ abstract class DataBindModule {
     abstract fun bindSpecialDatesCalendarSpec(
         impl: AndroidSpecialDatesCalendarSpec,
     ): SpecialDatesCalendarSpec
+
+    @Binds
+    @Singleton
+    abstract fun bindTodaySource(
+        impl: AndroidTodaySource,
+    ): TodaySource
 }
 
 @Module

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

@@ -0,0 +1,63 @@
+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.ExperimentalCoroutinesApi
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.onStart
+import kotlinx.coroutines.flow.transformLatest
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
+import javax.inject.Inject
+import kotlin.time.Clock
+
+/** The current local date, re-emitted whenever it changes (#373). */
+interface TodaySource {
+    val today: Flow<LocalDate>
+}
+
+/**
+ * Re-reads the date on every minute boundary while collected, and at once on the
+ * system's date, time and zone broadcasts, which can arrive late or not at all.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+class AndroidTodaySource @Inject constructor(
+    @ApplicationContext private val context: Context,
+) : TodaySource {
+
+    override val today: Flow<LocalDate> = callbackFlow {
+        val receiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context, intent: Intent) {
+                trySend(Unit)
+            }
+        }
+        val filter = IntentFilter().apply {
+            addAction(Intent.ACTION_DATE_CHANGED)
+            addAction(Intent.ACTION_TIME_CHANGED)
+            addAction(Intent.ACTION_TIMEZONE_CHANGED)
+        }
+        ContextCompat.registerReceiver(context, receiver, filter, ContextCompat.RECEIVER_NOT_EXPORTED)
+        awaitClose { context.unregisterReceiver(receiver) }
+    }
+        .onStart { emit(Unit) }
+        .transformLatest {
+            while (true) {
+                emit(currentDate())
+                delay(MINUTE_MILLIS - Clock.System.now().toEpochMilliseconds() % MINUTE_MILLIS)
+            }
+        }
+        .distinctUntilChanged()
+}
+
+private const val MINUTE_MILLIS = 60_000L
+
+fun currentDate(): LocalDate = Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()).date

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

@@ -4,7 +4,8 @@ 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.offsetAt
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Instant
 
@@ -36,6 +37,13 @@ data class EventForm(
      * (see [EventFormField.Timezone] and the data layer's UTC-midnight rule).
      */
     val timezone: String? = null,
+    /**
+     * The UTC offsets [start]/[end] were read at, when they came from real
+     * instants. Only a wall-clock time the fall-back hour repeats needs them:
+     * both of its instants share one [LocalDateTime] (#387).
+     */
+    val startOffset: UtcOffset? = null,
+    val endOffset: UtcOffset? = null,
     val location: String = "",
     val description: String = "",
     /** Reminder lead times in minutes before the start, deduplicated. */
@@ -145,16 +153,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))
     } else {
-        Instant.fromEpochMilliseconds(beginMillis).toLocalDateTime(formZone) to
-            Instant.fromEpochMilliseconds(endMillis).toLocalDateTime(formZone)
+        begin.toLocalDateTime(formZone) to finish.toLocalDateTime(formZone)
     }
     return EventForm(
         calendarId = instance.calendarId,
@@ -163,6 +170,8 @@ fun EventDetail.toEditForm(beginMillis: Long, endMillis: Long, zone: TimeZone):
         start = start,
         end = end,
         timezone = pinnedZone,
+        startOffset = if (instance.isAllDay) null else formZone.offsetAt(begin),
+        endOffset = if (instance.isAllDay) null else formZone.offsetAt(finish),
         location = instance.location.orEmpty(),
         description = description.orEmpty(),
         reminders = reminders.map { it.minutes }.distinct().sorted(),
@@ -221,20 +230,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 +261,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.
@@ -265,3 +282,20 @@ fun EventForm.problems(): Set<EventFormProblem> = buildSet {
         add(EventFormProblem.RecurrenceEndsBeforeStart)
     }
 }
+
+/**
+ * A create form seeded from this occurrence, to save a copy as a new,
+ * independent event (#52). The recurrence is dropped — a duplicate is a single
+ * event. The source calendar is kept only when [canModify], otherwise the id is
+ * cleared so the create resolves to a writable calendar, which lets a read-only
+ * event be copied into an editable one. [instance]'s own times carry over.
+ */
+fun EventDetail.toDuplicateForm(canModify: Boolean, zone: TimeZone): EventForm =
+    toEditForm(
+        beginMillis = instance.start.toEpochMilliseconds(),
+        endMillis = instance.end.toEpochMilliseconds(),
+        zone = zone,
+    ).copy(
+        rrule = null,
+        calendarId = instance.calendarId.takeIf { canModify },
+    )

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

@@ -3,10 +3,14 @@ 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.toJavaZoneId
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Instant
+import kotlin.time.toJavaInstant
 
 /**
  * The zone this form's wall-clock times mean, matching what the data layer
@@ -15,6 +19,43 @@ 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 {
+    val kept = preferred?.let { toInstant(it) }
+    return kept?.takeIf { it.toLocalDateTime(zone) == this } ?: toInstant(zone)
+}
+
+/** 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.getValidOffsets(java.time.LocalDateTime.ofInstant(toJavaInstant(), zid)).size > 1
+}
+
+/** The form's start as an instant in [zone], keeping its [EventForm.startOffset]. */
+fun EventForm.startInstant(zone: TimeZone): Instant = start.resolveIn(zone, startOffset)
+
+/** The form's end as an instant in [zone], keeping its [EventForm.endOffset]. */
+fun EventForm.endInstant(zone: TimeZone): Instant = end.resolveIn(zone, endOffset)
+
+/** The form's timed span set to these instants, read in [zone] with their offsets. */
+fun EventForm.withTimes(start: Instant, end: Instant, zone: TimeZone): EventForm = copy(
+    start = start.toLocalDateTime(zone),
+    end = end.toLocalDateTime(zone),
+    startOffset = zone.offsetAt(start),
+    endOffset = zone.offsetAt(end),
+)
+
+/**
+ * The form with its end picked by hand. A picked wall-clock time can't say which
+ * pass of a repeated hour it means, so it drops [EventForm.endOffset] and takes
+ * the earlier — unless it is the end the form already has.
+ */
+fun EventForm.withEnd(end: LocalDateTime): EventForm =
+    if (end == this.end) this else copy(end = end, endOffset = null)
+
 /**
  * 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 +67,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)
 }
 
 /**
@@ -48,6 +86,13 @@ fun EventForm.shiftedByDays(days: Int, deviceZone: TimeZone): EventForm {
         )
     }
     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 = newStart.resolveIn(zone, startOffset)
+    return withTimes(startAt, startAt + span, 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
+    return withTimes(newStart, newEnd, resolvedZone(deviceZone))
 }

app/src/main/java/de/jeanlucmakiola/calendula/domain/InsertEventForm.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.offsetAt
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Duration.Companion.hours
 import kotlin.time.Instant
@@ -35,7 +35,15 @@ fun buildInsertEventForm(
     zone: TimeZone,
     now: Instant,
 ): EventForm {
-    val (start, end) = if (isAllDay) {
+    val timed = if (isAllDay) {
+        null
+    } else {
+        val startAt = beginMillis?.let(Instant::fromEpochMilliseconds) ?: nextFullHour(now)
+        val endAt = endMillis?.let(Instant::fromEpochMilliseconds)?.takeIf { it >= startAt }
+            ?: (startAt + 1.hours)
+        startAt to endAt
+    }
+    val (start, end) = if (timed == null) {
         // All-day provider times are UTC midnights with an exclusive end; show
         // the last covered day and keep placeholder wall-clock times in case the
         // user switches the event to timed (mirrors EventDetail.toEditForm).
@@ -48,14 +56,7 @@ fun buildInsertEventForm(
             ?: startDate
         LocalDateTime(startDate, LocalTime(9, 0)) to 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
+        timed.first.toLocalDateTime(zone) to timed.second.toLocalDateTime(zone)
     }
     return EventForm(
         calendarId = null,
@@ -63,6 +64,8 @@ fun buildInsertEventForm(
         isAllDay = isAllDay,
         start = start,
         end = end,
+        startOffset = timed?.let { zone.offsetAt(it.first) },
+        endOffset = timed?.let { zone.offsetAt(it.second) },
         location = location.orEmpty(),
         description = description.orEmpty(),
         // Bare RRULE value (Events.RRULE convention); tolerate a leading "RRULE:"
@@ -71,8 +74,7 @@ fun buildInsertEventForm(
     )
 }
 
-private fun nextFullHour(now: Instant, zone: TimeZone): LocalDateTime {
+private 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)
 }

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

@@ -157,12 +157,18 @@ fun timeZoneOptionOf(
  * the offset isn't stated twice in ICU's spelling and ours.
  */
 fun zoneDescriptor(option: TimeZoneOption): String {
+    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 {
     val abbrev = option.shortName
-    return when {
-        abbrev == "UTC" -> "UTC"
-        abbrev.startsWith("GMT") -> formatGmtOffset(option.offsetMinutes)
-        else -> "$abbrev · ${formatGmtOffset(option.offsetMinutes)}"
-    }
+    return if (abbrev.startsWith("GMT")) formatGmtOffset(option.offsetMinutes) else abbrev
 }
 
 /**

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

@@ -5,6 +5,7 @@ import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
+import kotlinx.datetime.offsetAt
 import kotlinx.datetime.toLocalDateTime
 
 /**
@@ -34,6 +35,8 @@ fun ParsedIcsEvent.toEventForm(zone: TimeZone): EventForm {
         isAllDay = isAllDay,
         start = start,
         end = end,
+        startOffset = if (isAllDay) null else zone.offsetAt(this.start),
+        endOffset = if (isAllDay) null else zone.offsetAt(this.end),
         location = location.orEmpty(),
         description = description.orEmpty(),
         reminders = semanticReminderMinutes(),

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

@@ -55,7 +55,11 @@ import de.jeanlucmakiola.floret.identity.fadeThrough
 import de.jeanlucmakiola.floret.identity.predictiveBackExit
 import de.jeanlucmakiola.floret.identity.rememberReduceMotion
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.EventActionsViewModel
 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.EventMoveScope
 import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
 import de.jeanlucmakiola.calendula.ui.common.LocalManageCalendars
@@ -146,14 +150,27 @@ fun CalendarHost(
         mutableStateOf(listOf(defaultView))
     }
     var navigationVersion by remember { mutableIntStateOf(0) }
+    // True after backing out of a day opened from the view now shown, so the
+    // agenda returns to where it was instead of today (#367).
+    var returnedFromDay by remember { mutableStateOf(false) }
     val view = viewStack.last()
     // The date every view opens on and carries along (#184); tapping a day
     // anywhere focuses it and opens the day view there.
     val focus = rememberSaveable(saver = ViewFocusSaver) { ViewFocus(localToday()) }
+    // A focus still on yesterday follows the date over, so the next view opened
+    // doesn't land on the old day (#373); one moved elsewhere stays put.
+    val today = viewModel.today.collectAsStateWithLifecycle().value
+    var focusToday by rememberSaveable { mutableStateOf(today.toString()) }
+    LaunchedEffect(today) {
+        val old = LocalDate.parse(focusToday)
+        if (old != today && focus.date == old) focus.date = today
+        focusToday = today.toString()
+    }
 
     val switchScope = rememberCoroutineScope()
     val switchTo: ((List<CalendarView>) -> List<CalendarView>) -> Unit = { move ->
         navigationVersion++
+        returnedFromDay = false
         viewStack = move(viewStack)
     }
     val onSelectView: (CalendarView) -> Unit = { target -> switchTo { it.selectView(target) } }
@@ -313,7 +330,10 @@ fun CalendarHost(
     // [requestedDetailKey]. Date/event opens root the stack in the widget's own
     // view so backing out returns there (then home), not to the default.
     LaunchedEffect(widgetNavRequest) {
-        if (widgetNavRequest != null) navigationVersion++
+        if (widgetNavRequest != null) {
+            navigationVersion++
+            returnedFromDay = false
+        }
         when (val req = widgetNavRequest) {
             is WidgetNavRequest.OpenDate -> {
                 // Drill the day view in over the widget's view: drop any overlay
@@ -370,6 +390,9 @@ fun CalendarHost(
     // survives view switches; the calendar surfaces read it out of LocalEventMove.
     val reschedule: RescheduleViewModel = hiltViewModel()
     val movableCalendarIds by reschedule.movableCalendarIds.collectAsStateWithLifecycle()
+    val eventActions: EventActionsViewModel = hiltViewModel()
+    val moveOutcome by reschedule.outcome.collectAsStateWithLifecycle()
+    val selectionFailure by eventActions.failure.collectAsStateWithLifecycle()
     val onEditEvent: (EventInstance) -> Unit = { event ->
         val key = longArrayOf(
             event.eventId,
@@ -415,11 +438,14 @@ fun CalendarHost(
     if (reduceMotion) {
         BackHandler(enabled = viewBackEnabled) {
             navigationVersion++
+            returnedFromDay = viewStack.last() == CalendarView.Day
             viewStack = viewStack.dropLast(1)
         }
     } else {
         PredictiveBackHandler(enabled = viewBackEnabled) { events ->
             val previous = viewStack[viewStack.size - 2]
+            // Set before the seek, which already composes the previous view.
+            returnedFromDay = viewStack.last() == CalendarView.Day
             try {
                 events.collect { viewTransition.seekTo(it.progress, targetState = previous) }
                 navigationVersion++
@@ -508,7 +534,25 @@ fun CalendarHost(
                     showTodayButton = todayInToolbar,
                 )
             },
-            floatingActionButton = { CalendarFab(chromeHost, todayInToolbar) },
+            floatingActionButton = {
+                // While an event is selected the FAB is its action bar's toggle (#141).
+                val fabSelection = rememberFabSelection(
+                    host = chromeHost,
+                    viewModel = eventActions,
+                    onEdit = onEditEvent,
+                    onDuplicate = { form ->
+                        // A fresh event, like a duplicate from the detail screen (#52).
+                        importFormSource = ImportSource.Insert
+                        importForm = form
+                    },
+                    chipShown = moveOutcome != null || selectionFailure != null,
+                    onDismissChip = {
+                        reschedule.consumeOutcome()
+                        eventActions.consumeFailure()
+                    },
+                )
+                CalendarFab(chromeHost, todayInToolbar, fabSelection)
+            },
         ) { innerPadding ->
         SharedTransitionLayout(
             Modifier
@@ -551,6 +595,7 @@ fun CalendarHost(
                     onEventClick = onEventClick,
                     onCreateEvent = onCreateEvent,
                     quickSwitchViews = quickSwitchViews,
+                    restorePosition = returnedFromDay,
                 )
             }
             }
@@ -562,7 +607,15 @@ fun CalendarHost(
 
         // Scope prompt + confirmation/undo snackbar for a dropped event, declared
         // right after the calendar views so later overlays cover it.
-        EventMoveHost(reschedule, modifier = Modifier.fillMaxSize())
+        EventMoveHost(
+            reschedule,
+            modifier = Modifier.fillMaxSize(),
+            actionFailure = eventActionFailureMessage(selectionFailure),
+            onActionFailureShown = eventActions::consumeFailure,
+        )
+
+        // The delete prompt and failure chip of a selected event's actions (#141).
+        EventSelectionHost(host = chromeHost, viewModel = eventActions)
 
         // Search overlay — below detail/edit in the Box so a tapped result's
         // detail screen draws on top, and closing it returns to the results.

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

@@ -4,12 +4,15 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
+import de.jeanlucmakiola.calendula.data.time.TodaySource
+import de.jeanlucmakiola.calendula.data.time.currentDate
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
+import kotlinx.datetime.LocalDate
 import javax.inject.Inject
 
 /**
@@ -21,8 +24,16 @@ import javax.inject.Inject
 @HiltViewModel
 class CalendarHostViewModel @Inject constructor(
     prefs: SettingsPrefs,
+    todaySource: TodaySource,
 ) : ViewModel() {
 
+    /** Today, kept current across midnight so the shared focus can follow it (#373). */
+    val today: StateFlow<LocalDate> = todaySource.today.stateIn(
+        scope = viewModelScope,
+        started = SharingStarted.WhileSubscribed(5_000L),
+        initialValue = currentDate(),
+    )
+
     val defaultView: StateFlow<CalendarView?> = prefs.defaultView.stateIn(
         scope = viewModelScope,
         started = SharingStarted.WhileSubscribed(5_000L),

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

@@ -5,7 +5,6 @@ import de.jeanlucmakiola.calendula.ui.common.ScreenActions
 import de.jeanlucmakiola.calendula.ui.common.ScreenBody
 import de.jeanlucmakiola.calendula.ui.common.ScreenChrome
 import de.jeanlucmakiola.calendula.ui.common.LocalViewFocus
-import de.jeanlucmakiola.calendula.ui.common.EnterOnFocus
 import kotlinx.coroutines.flow.drop
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.setValue
@@ -38,7 +37,16 @@ import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableIntState
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.input.nestedscroll.NestedScrollConnection
+import androidx.compose.ui.input.nestedscroll.NestedScrollSource
+import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -53,7 +61,7 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.domain.hasEnded
+import de.jeanlucmakiola.calendula.ui.common.isPastOn
 import de.jeanlucmakiola.calendula.ui.common.AgendaRangePicker
 import de.jeanlucmakiola.calendula.ui.common.AppBarSpacing
 import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
@@ -82,11 +90,23 @@ fun AgendaScreen(
     onCreateEvent: (LocalDate, Int?) -> Unit,
     quickSwitchViews: List<CalendarView> = IMPLEMENTED_VIEWS,
     modifier: Modifier = Modifier,
+    restorePosition: Boolean = false,
     viewModel: AgendaViewModel = hiltViewModel(),
 ) {
-    // Opens on the focused date and hands back the day scrolled to the top.
+    // Opens on today, not on the day another view was on (#367). Backing out of
+    // a day opened from here, or a recreated screen, returns to the day last at
+    // the top. The top day still goes back to the shared focus.
     val focus = LocalViewFocus.current
-    EnterOnFocus(viewModel) { if (it != viewModel.anchor.value) viewModel.goToDate(it) }
+    val opened = rememberSaveable { mutableStateOf(false) }
+    val restoreTop = remember(viewModel) {
+        if (restorePosition || opened.value) {
+            viewModel.lastTopDate
+        } else {
+            viewModel.goToToday()
+            null
+        }
+    }
+    SideEffect { opened.value = true }
     val state by viewModel.state.collectAsStateWithLifecycle()
     val anchor by viewModel.anchor.collectAsStateWithLifecycle()
     val pastDisplay by viewModel.pastEventDisplay.collectAsStateWithLifecycle()
@@ -106,20 +126,19 @@ fun AgendaScreen(
     // list scroll, not an anchor change — "today" has to bring the list back to
     // the top as well, and stay offered while it is scrolled away (#305).
     val listState = rememberLazyListState()
+    // Past days load above the anchor (#367), so the anchor's row counts as the
+    // start of the list.
+    val anchorIndex = remember { mutableIntStateOf(0) }
     val scrolledAway by remember {
         derivedStateOf {
-            listState.firstVisibleItemIndex > 0 || listState.firstVisibleItemScrollOffset > 0
+            listState.firstVisibleItemIndex != anchorIndex.intValue ||
+                listState.firstVisibleItemScrollOffset > 0
         }
     }
-    // A new window is rendered from its first day, so the list belongs at the
-    // top. Keyed on the anchor the days arrived with, not the one just
-    // requested: scrolling before the new rows compose leaves the list keyed to
-    // a row that reappears further down, and it follows it there.
-    LaunchedEffect(successState?.anchor) { listState.scrollToItem(0) }
     val jumpToToday: () -> Unit = {
-        // Off today, moving the anchor is what resets the list (above); on today
+        // Off today, moving the anchor is what repositions the list; on today
         // the window doesn't change, so the scroll back is the whole action.
-        if (isOnToday) scope.launch { listState.animateScrollToItem(0) }
+        if (isOnToday) scope.launch { listState.animateScrollToItem(anchorIndex.intValue) }
         viewModel.goToToday()
         (state as? AgendaUiState.Success)?.today?.let { focus?.date = it }
     }
@@ -188,11 +207,17 @@ fun AgendaScreen(
                 pastDisplay = pastDisplay,
                 showToday = showToday,
                 listState = listState,
+                anchorIndex = anchorIndex,
+                initialTopDate = restoreTop,
+                onLoadEarlier = viewModel::loadEarlier,
                 onRetry = viewModel::goToToday,
                 onEventClick = onEventClick,
                 onOpenDay = onOpenDay,
                 onTopDay = if (successState?.anchor == anchor) {
-                    { focus?.date = it }
+                    {
+                        focus?.date = it
+                        viewModel.rememberTopDay(it)
+                    }
                 } else null,
                 modifier = Modifier
                     .weight(1f)
@@ -294,6 +319,9 @@ internal fun AgendaContent(
     onOpenDay: (LocalDate) -> Unit,
     modifier: Modifier = Modifier,
     listState: LazyListState = rememberLazyListState(),
+    anchorIndex: MutableIntState = remember { mutableIntStateOf(0) },
+    initialTopDate: LocalDate? = null,
+    onLoadEarlier: () -> Unit = {},
     onTopDay: ((LocalDate) -> Unit)? = null,
 ) {
     when (state) {
@@ -308,28 +336,34 @@ internal fun AgendaContent(
             // away (or fade) as they end while the screen stays open.
             val filtered = if (pastDisplay == PastEventDisplay.HIDE) {
                 state.days.mapNotNull { day ->
-                    val remaining = day.events.filterNot { it.hasEnded(now) }
+                    val remaining = day.events.filterNot { it.isPastOn(day.date, now, state.zone) }
                     if (remaining.isEmpty()) null else day.copy(events = remaining)
                 }
             } else {
                 state.days
             }
             // Anchor today with a "nothing left today" placeholder — but only when
-            // the window actually starts on today; a jumped-to date has no today in
-            // it, so anchoring there would be misleading (#35).
+            // the agenda actually opens on today; a jumped-to date has no today
+            // in it, so anchoring there would be misleading (#35).
             val days = anchorTodayIfMissing(
                 days = filtered,
                 today = state.today,
                 enabled = showToday && state.anchor == state.today,
             )
-            if (days.isEmpty()) {
+            // Past days alone don't count as anything coming up.
+            if (days.none { it.date >= state.anchor }) {
                 // Nothing to scroll: drop the position a previous list left, so
                 // the today FAB doesn't linger over an empty screen.
                 LaunchedEffect(Unit) { listState.scrollToItem(0) }
+                SideEffect { anchorIndex.intValue = 0 }
                 AgendaEmpty(modifier)
             } else {
                 AgendaList(
                     days = days,
+                    anchor = state.anchor,
+                    anchorIndex = anchorIndex,
+                    initialTopDate = initialTopDate,
+                    onLoadEarlier = onLoadEarlier,
                     today = state.today,
                     zone = state.zone,
                     listState = listState,
@@ -349,6 +383,10 @@ internal fun AgendaContent(
 @Composable
 private fun AgendaList(
     days: List<AgendaDay>,
+    anchor: LocalDate,
+    anchorIndex: MutableIntState,
+    initialTopDate: LocalDate?,
+    onLoadEarlier: () -> Unit,
     today: LocalDate,
     zone: TimeZone,
     listState: LazyListState,
@@ -359,19 +397,49 @@ private fun AgendaList(
     onTopDay: ((LocalDate) -> Unit)?,
     modifier: Modifier = Modifier,
 ) {
+    val itemDates = agendaItemDates(days)
+    val anchorRow = itemDates.indexOfFirst { it >= anchor }.coerceAtLeast(0)
+    SideEffect { anchorIndex.intValue = anchorRow }
+    // A new anchor opens the list on its row from the first frame, with past
+    // days above. Keyed on the anchor the days arrived with, not the one just
+    // requested: scrolling before the new rows compose leaves the list keyed to
+    // a row that reappears further down, and it follows it there. The first run
+    // may restore a remembered day instead.
+    val pendingRestore = remember { arrayOf(initialTopDate) }
+    DisposableEffect(anchor) {
+        val target = pendingRestore[0]
+        pendingRestore[0] = null
+        val index = target?.let { date -> itemDates.indexOfFirst { it >= date } }
+            ?.takeIf { it >= 0 }
+            ?: anchorRow
+        listState.requestScrollToItem(index)
+        onDispose {}
+    }
+    // Scrolling up near the first loaded day loads earlier days.
+    val currentLoadEarlier by rememberUpdatedState(onLoadEarlier)
+    val loadOnScrollUp = remember(listState) {
+        object : NestedScrollConnection {
+            override fun onPreScroll(available: Offset, source: NestedScrollSource): Offset {
+                if (available.y > 0 && listState.firstVisibleItemIndex < LOAD_EARLIER_WITHIN) {
+                    currentLoadEarlier()
+                }
+                return Offset.Zero
+            }
+        }
+    }
     if (onTopDay != null) {
-        val itemDates by rememberUpdatedState(agendaItemDates(days))
+        val currentItemDates by rememberUpdatedState(itemDates)
         val currentOnTopDay by rememberUpdatedState(onTopDay)
         // The day the list opened on is where the view already is; only a
         // scroll moves it on.
         LaunchedEffect(listState) {
             snapshotFlow { listState.firstVisibleItemIndex }
                 .drop(1)
-                .collect { index -> itemDates.getOrNull(index)?.let(currentOnTopDay) }
+                .collect { index -> currentItemDates.getOrNull(index)?.let(currentOnTopDay) }
         }
     }
     LazyColumn(
-        modifier = modifier,
+        modifier = modifier.nestedScroll(loadOnScrollUp),
         state = listState,
         // Bottom inset clears the FAB stack so the last row stays tappable.
         contentPadding = PaddingValues(top = 8.dp, bottom = 96.dp),
@@ -401,7 +469,7 @@ private fun AgendaList(
                         day = day.date,
                         zone = zone,
                         position = positionOf(index, day.events.size),
-                        dimmed = dimPast && event.hasEnded(now),
+                        dimmed = dimPast && event.isPastOn(day.date, now, zone),
                         modifier = animateItemMotion().morphEvent(ViewMorphKey.event(event, day.date)),
                         onClick = { onEventClick(event) },
                     )
@@ -412,6 +480,9 @@ private fun AgendaList(
     }
 }
 
+/** How close to the first loaded row an upward scroll starts loading earlier days. */
+private const val LOAD_EARLIER_WITHIN = 10
+
 /** The day of each item [AgendaList] lays out for [days], in its order. */
 internal fun agendaItemDates(days: List<AgendaDay>): List<LocalDate> =
     days.flatMap { day ->

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

@@ -93,22 +93,21 @@ fun groupAgendaDays(
 }
 
 /**
- * Ensure [today] surfaces as the first agenda day even when it carries no
- * (remaining) events, by prepending an empty-event [AgendaDay] the agenda widget
+ * Ensure [today] surfaces in the agenda even when it carries no (remaining)
+ * events, by inserting an empty-event [AgendaDay] in date order that the agenda
  * renders as a "nothing left today" placeholder. A no-op unless [enabled], and
- * when today already has its own day in [days]. Keeps today anchored at the top
- * so a glance tells today's events apart from a future day's (issue #35).
+ * when today already has its own day in [days]. Keeps today anchored so a glance
+ * tells today's events apart from a future day's (issue #35).
  */
 fun anchorTodayIfMissing(
     days: List<AgendaDay>,
     today: LocalDate,
     enabled: Boolean,
-): List<AgendaDay> =
-    if (enabled && days.none { it.date == today }) {
-        listOf(AgendaDay(today, emptyList())) + days
-    } else {
-        days
-    }
+): List<AgendaDay> {
+    if (!enabled || days.any { it.date == today }) return days
+    val at = days.indexOfFirst { it.date > today }.let { if (it < 0) days.size else it }
+    return days.take(at) + AgendaDay(today, emptyList()) + days.drop(at)
+}
 
 /**
  * State for the Agenda view: a flat, forward-looking list of upcoming events
@@ -118,8 +117,10 @@ sealed interface AgendaUiState {
     data object Loading : AgendaUiState
     data class Failure(val reason: FailureReason) : AgendaUiState
     data class Success(
-        /** First day of the loaded window (today, or a jumped-to date). */
+        /** The day the agenda opens on (today, or a jumped-to date). */
         val anchor: LocalDate,
+        /** First loaded day, before [anchor] once past days are loaded (#367). */
+        val windowStart: LocalDate,
         val today: LocalDate,
         val days: List<AgendaDay>,
         /** The range currently in effect — the saved default or a session override. */

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

@@ -8,6 +8,8 @@ import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.firstDayOfWeek
+import de.jeanlucmakiola.calendula.data.time.TodaySource
+import de.jeanlucmakiola.calendula.data.time.currentDate
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
@@ -21,6 +23,8 @@ import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.DayOfWeek
@@ -28,10 +32,9 @@ import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.atStartOfDayIn
 import kotlinx.datetime.atTime
+import kotlinx.datetime.minus
 import kotlinx.datetime.plus
 import kotlinx.datetime.toInstant
-import kotlinx.datetime.toLocalDateTime
-import kotlin.time.Clock
 import kotlin.time.Instant
 import javax.inject.Inject
 
@@ -40,6 +43,7 @@ import javax.inject.Inject
 class AgendaViewModel @Inject constructor(
     private val repository: CalendarRepository,
     settingsPrefs: SettingsPrefs,
+    todaySource: TodaySource,
     @IoDispatcher private val io: CoroutineDispatcher,
 ) : ViewModel() {
 
@@ -84,10 +88,34 @@ class AgendaViewModel @Inject constructor(
     private val zone = TimeZone.currentSystemDefault()
 
     private val todayDate: LocalDate
-        get() = Clock.System.now().toLocalDateTime(zone).date
+        get() = currentDate()
 
-    private val _anchor = MutableStateFlow(todayDate)
-    val anchor: StateFlow<LocalDate> = _anchor
+    // The anchor and how many days before it are loaded, moved together so a
+    // jump never queries a window that pairs the new anchor with the old span.
+    private val _window = MutableStateFlow(AgendaWindow(todayDate, PAST_CHUNK_DAYS))
+    val anchor: StateFlow<LocalDate> = _window
+        .map { it.anchor }
+        .stateIn(viewModelScope, SharingStarted.Eagerly, todayDate)
+
+    /** The day last scrolled to the top, so a return to the agenda lands back on it. */
+    var lastTopDate: LocalDate? = null
+        private set
+
+    private var lastToday = todayDate
+
+    /**
+     * Today, kept current across midnight (#373). An agenda still starting on
+     * yesterday moves on to the new day; one jumped elsewhere stays put.
+     */
+    private val today: StateFlow<LocalDate> = todaySource.today
+        .onEach { date ->
+            val old = lastToday
+            lastToday = date
+            if (old != date && _window.value.anchor == old) {
+                _window.value = _window.value.copy(anchor = date)
+            }
+        }
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000L), todayDate)
 
     // A transient, in-view override of the saved agenda range. Held in memory
     // (not persisted), so it survives view switches and rotation within the
@@ -95,9 +123,17 @@ class AgendaViewModel @Inject constructor(
     private val _rangeOverride = MutableStateFlow<AgendaRange?>(null)
 
     val state: StateFlow<AgendaUiState> =
-        combine(_anchor, agendaSettings, _rangeOverride, weekStart) { anchor, settings, override, weekStart ->
+        combine(
+            _window,
+            agendaSettings,
+            _rangeOverride,
+            weekStart,
+            settingsPrefs.pastEventDisplay,
+        ) { window, settings, override, weekStart, pastDisplay ->
             AgendaParams(
-                anchor = anchor,
+                anchor = window.anchor,
+                // Hidden past events leave nothing to scroll back to (#367).
+                pastDays = if (pastDisplay == PastEventDisplay.HIDE) 0 else window.pastDays,
                 range = override ?: settings.range,
                 rangeIsOverride = override != null && override != settings.range,
                 weekStart = weekStart,
@@ -106,15 +142,16 @@ class AgendaViewModel @Inject constructor(
         }
         .flatMapLatest { params ->
             val window = agendaRange(
-                params.anchor,
-                params.range.dayCount(params.anchor, params.weekStart) - 1,
+                params.windowStart,
+                params.pastDays + params.range.dayCount(params.anchor, params.weekStart) - 1,
                 zone,
             )
             combine(
                 repository.calendars(),
                 repository.instances(window),
-            ) { calendars, instances ->
-                buildState(params, calendars, instances)
+                today,
+            ) { calendars, instances, today ->
+                buildState(params, calendars, instances, today)
             }
         }
         .catch { emit(AgendaUiState.Failure(FailureReason.ProviderUnavailable)) }
@@ -126,12 +163,30 @@ class AgendaViewModel @Inject constructor(
         )
 
     fun goToToday() {
-        _anchor.value = todayDate
+        goToDate(todayDate)
     }
 
     /** Jump the agenda window to start on a specific date (drawer jump-to-date). */
     fun goToDate(date: LocalDate) {
-        _anchor.value = date
+        if (_window.value.anchor == date) return
+        _window.value = AgendaWindow(date, PAST_CHUNK_DAYS)
+        lastTopDate = null
+    }
+
+    /**
+     * Extend the window [PAST_CHUNK_DAYS] further back (#367). Ignored while the
+     * previous extension is still loading, so a scroll that keeps asking only
+     * moves one chunk at a time.
+     */
+    fun loadEarlier() {
+        val loaded = (state.value as? AgendaUiState.Success)?.windowStart ?: return
+        val window = _window.value
+        if (loaded != window.start) return
+        _window.value = window.copy(pastDays = window.pastDays + PAST_CHUNK_DAYS)
+    }
+
+    fun rememberTopDay(date: LocalDate) {
+        lastTopDate = date
     }
 
     /** Temporarily override the agenda range for this session (the bottom-left pill). */
@@ -144,18 +199,26 @@ class AgendaViewModel @Inject constructor(
         val showBar: Boolean,
     )
 
+    private data class AgendaWindow(val anchor: LocalDate, val pastDays: Int) {
+        val start: LocalDate get() = anchor.minus(pastDays, DateTimeUnit.DAY)
+    }
+
     private data class AgendaParams(
         val anchor: LocalDate,
+        val pastDays: Int,
         val range: AgendaRange,
         val rangeIsOverride: Boolean,
         val weekStart: DayOfWeek,
         val showRangeBar: Boolean,
-    )
+    ) {
+        val windowStart: LocalDate get() = anchor.minus(pastDays, DateTimeUnit.DAY)
+    }
 
     private fun buildState(
         params: AgendaParams,
         calendars: List<CalendarSource>,
         instances: List<EventInstance>,
+        today: LocalDate,
     ): AgendaUiState {
         calendarListFailure(calendars)?.let { return AgendaUiState.Failure(it) }
         val anchor = params.anchor
@@ -163,10 +226,11 @@ class AgendaViewModel @Inject constructor(
             params.range.dayCount(anchor, params.weekStart) - 1,
             DateTimeUnit.DAY,
         )
-        val days = groupAgendaDays(anchor, rangeEnd, instances, zone)
+        val days = groupAgendaDays(params.windowStart, rangeEnd, instances, zone)
         return AgendaUiState.Success(
             anchor = anchor,
-            today = todayDate,
+            windowStart = params.windowStart,
+            today = today,
             days = days,
             range = params.range,
             rangeIsOverride = params.rangeIsOverride,
@@ -177,6 +241,9 @@ class AgendaViewModel @Inject constructor(
     }
 }
 
+/** How many days each scroll back into the past loads (#367). */
+internal const val PAST_CHUNK_DAYS = 30
+
 /** Inclusive instant range from the start of [anchor] through [days] days ahead. */
 internal fun agendaRange(anchor: LocalDate, days: Int, zone: TimeZone): ClosedRange<Instant> {
     val from = anchor.atStartOfDayIn(zone)

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

@@ -51,6 +51,7 @@ private fun sampleAgendaState(today: LocalDate, zone: TimeZone): AgendaUiState.S
     val windowEnd = today.plus(PREVIEW_WINDOW_DAYS, DateTimeUnit.DAY)
     return AgendaUiState.Success(
         anchor = today,
+        windowStart = today,
         today = today,
         days = groupAgendaDays(today, windowEnd, sampleAgendaEvents(today, zone), zone),
         range = AgendaRange.Custom(PREVIEW_WINDOW_DAYS),

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

@@ -1,5 +1,14 @@
 package de.jeanlucmakiola.calendula.ui.common
 
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.slideInVertically
+import androidx.compose.animation.slideOutVertically
+import androidx.compose.animation.togetherWith
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.scaleIn
+import androidx.compose.animation.scaleOut
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.PaddingValues
@@ -16,6 +25,9 @@ import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.setValue
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.Immutable
 import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.Stable
@@ -24,6 +36,7 @@ import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.EventInstance
 import kotlinx.datetime.LocalDate
 
 /**
@@ -53,12 +66,31 @@ class ScreenActions(
     val onCreate: () -> Unit,
 )
 
+/**
+ * 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.
+ */
+@Stable
+class EventSelection(val event: EventInstance, val dismiss: () -> Unit)
+
 /** The screen on show's [ScreenChrome] and [ScreenActions], for the host to draw. */
 @Stable
 class ChromeHost {
     var chrome by mutableStateOf<ScreenChrome?>(null)
         private set
 
+    var selection by mutableStateOf<EventSelection?>(null)
+        internal set
+
+    /** Whether the selected event is being dragged or resized right now. */
+    var selectionBusy by mutableStateOf(false)
+        internal set
+
+    /** Whether the bar would cover the selected event, and so draws compact. */
+    var selectionCompact by mutableStateOf(false)
+        internal set
+
+
     var actions: ScreenActions? = null
         private set
 
@@ -80,8 +112,35 @@ fun PublishChrome(chrome: ScreenChrome, actions: ScreenActions) {
     if (slot.current) SideEffect { slot.host.publish(chrome, actions) }
 }
 
-/** The top bar every calendar screen shares. */
-@OptIn(ExperimentalMaterial3Api::class)
+/** 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) {
+    val slot = LocalChromeSlot.current ?: return
+    val currentDismiss by rememberUpdatedState(onDismiss)
+    val selection = remember(event) { event?.let { EventSelection(it) { currentDismiss() } } }
+    val host = slot.host
+    val current = slot.current
+    DisposableEffect(host, selection, current) {
+        if (current) host.selection = selection
+        onDispose {
+            if (host.selection === selection) host.selection = null
+            // Left mid-drag, nothing else would clear these for the other views.
+            host.selectionBusy = false
+            host.selectionCompact = false
+        }
+    }
+    if (current) {
+        SideEffect {
+            host.selectionBusy = busy && selection != null
+            host.selectionCompact = compact && selection != null
+        }
+    }
+}
+
+/**
+ * The top bar every calendar screen shares — or, while an event is selected,
+ * the selection's own bar in its place (#141).
+ */
 @Composable
 fun CalendarTopBar(
     host: ChromeHost,
@@ -91,6 +150,43 @@ fun CalendarTopBar(
     onOpenDrawer: () -> Unit,
     onOpenSearch: () -> Unit,
     showTodayButton: Boolean,
+) {
+    val effects = MaterialTheme.motionScheme.fastEffectsSpec<Float>()
+    AnimatedContent(
+        targetState = host.selection,
+        contentKey = { it != null },
+        transitionSpec = {
+            (fadeIn(effects) + slideInVertically { -it / 4 })
+                .togetherWith(fadeOut(effects) + slideOutVertically { -it / 4 })
+        },
+        label = "top-bar",
+    ) { selection ->
+        if (selection != null) {
+            SelectionTopBar(selection)
+        } else {
+            ViewTopBar(
+                host = host,
+                selectedView = selectedView,
+                quickSwitchViews = quickSwitchViews,
+                onCycleView = onCycleView,
+                onOpenDrawer = onOpenDrawer,
+                onOpenSearch = onOpenSearch,
+                showTodayButton = showTodayButton,
+            )
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun ViewTopBar(
+    host: ChromeHost,
+    selectedView: CalendarView,
+    quickSwitchViews: List<CalendarView>,
+    onCycleView: () -> Unit,
+    onOpenDrawer: () -> Unit,
+    onOpenSearch: () -> Unit,
+    showTodayButton: Boolean,
 ) {
     val chrome = host.chrome
     TopAppBar(
@@ -136,16 +232,26 @@ fun CalendarTopBar(
     )
 }
 
-/** The FAB column every calendar screen shares. */
+/**
+ * The FAB column every calendar screen shares. While an event is selected the
+ * FAB is [selection]'s toggle instead, and it steps aside mid-gesture.
+ */
 @Composable
-fun CalendarFab(host: ChromeHost, todayInToolbar: Boolean) {
+fun CalendarFab(host: ChromeHost, todayInToolbar: Boolean, selection: FabSelection? = null) {
     val chrome = host.chrome ?: return
-    CalendarFabColumn(
-        todayVisible = chrome.awayFromToday && !todayInToolbar,
-        todayText = chrome.todayText,
-        onToday = { host.actions?.onToday?.invoke() },
-        onCreate = { host.actions?.onCreate?.invoke() },
-    )
+    AnimatedVisibility(
+        visible = !host.selectionBusy,
+        enter = scaleIn(MaterialTheme.motionScheme.fastSpatialSpec()) + fadeIn(),
+        exit = scaleOut(MaterialTheme.motionScheme.fastSpatialSpec()) + fadeOut(),
+    ) {
+        CalendarFabColumn(
+            todayVisible = chrome.awayFromToday && !todayInToolbar,
+            todayText = chrome.todayText,
+            onToday = { host.actions?.onToday?.invoke() },
+            onCreate = { host.actions?.onCreate?.invoke() },
+            selection = selection,
+        )
+    }
 }
 
 /**

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

@@ -1,11 +1,20 @@
 package de.jeanlucmakiola.calendula.ui.common
 
 import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.expandHorizontally
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
 import androidx.compose.animation.scaleIn
 import androidx.compose.animation.scaleOut
+import androidx.compose.animation.shrinkHorizontally
 import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.height
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
 import androidx.compose.material.icons.filled.Add
 import androidx.compose.material.icons.filled.Refresh
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
@@ -15,15 +24,38 @@ import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 
+/** The standard FAB's size, shared by the selection bar that unrolls from it (#141). */
+val FabSize = 56.dp
+
+/** What the FAB is while an event is selected (#141): the toggle for its action bar. */
+@Stable
+class FabSelection(
+    val expanded: Boolean,
+    val onToggle: () -> Unit,
+    val bar: @Composable () -> Unit,
+)
+
+
+
 /**
  * The FAB stack shared by the three calendar views: a persistent "+" to
  * create an event, with the jump-to-today pill appearing above it whenever
- * the view isn't anchored on today.
+ * the view isn't anchored on today. While an event is selected the same FAB,
+ * in the same spot, opens and folds the selection's action bar, which unrolls
+ * from it towards the start.
  */
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
@@ -32,13 +64,14 @@ fun CalendarFabColumn(
     todayText: String,
     onToday: () -> Unit,
     onCreate: () -> Unit,
+    selection: FabSelection? = null,
 ) {
     Column(
         horizontalAlignment = Alignment.End,
         verticalArrangement = Arrangement.spacedBy(16.dp),
     ) {
         AnimatedVisibility(
-            visible = todayVisible,
+            visible = todayVisible && selection == null,
             enter = scaleIn(MaterialTheme.motionScheme.fastSpatialSpec()),
             exit = scaleOut(MaterialTheme.motionScheme.fastSpatialSpec()),
         ) {
@@ -48,11 +81,71 @@ fun CalendarFabColumn(
                 text = { Text(todayText) },
             )
         }
-        FloatingActionButton(onClick = onCreate) {
-            Icon(
-                imageVector = Icons.Default.Add,
-                contentDescription = stringResource(R.string.event_edit_new_title),
+        // Held past the selection clearing, so the bar has something to fold away.
+        val heldBar = remember { mutableStateOf<(@Composable () -> Unit)?>(null) }
+        if (selection != null && heldBar.value !== selection.bar) heldBar.value = selection.bar
+        // Held at the FAB's height so the taller bar can't shift the FAB.
+        Row(
+            modifier = Modifier.height(FabSize),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            AnimatedVisibility(
+                visible = selection?.expanded == true,
+                enter = expandHorizontally(
+                    animationSpec = MaterialTheme.motionScheme.fastSpatialSpec(),
+                    expandFrom = Alignment.End,
+                ) + fadeIn(),
+                exit = shrinkHorizontally(
+                    animationSpec = MaterialTheme.motionScheme.fastSpatialSpec(),
+                    shrinkTowards = Alignment.End,
+                ) + fadeOut(),
+            ) {
+                heldBar.value?.invoke()
+            }
+            val label = stringResource(
+                when {
+                    selection == null -> R.string.event_edit_new_title
+                    selection.expanded -> R.string.event_selection_hide
+                    else -> R.string.event_selection_actions
+                },
             )
+            FloatingActionButton(
+                onClick = selection?.onToggle ?: onCreate,
+                modifier = Modifier.semantics { contentDescription = label },
+            ) {
+                FabGlyph(selecting = selection != null, expanded = selection?.expanded == true)
+            }
         }
     }
 }
+
+/** "+", or with an event selected a chevron that turns to open and fold the bar. */
+@Composable
+private fun FabGlyph(selecting: Boolean, expanded: Boolean) {
+    val spatial = MaterialTheme.motionScheme.fastSpatialSpec<Float>()
+    val swap by animateFloatAsState(if (selecting) 1f else 0f, spatial, label = "fab-swap")
+    val turn by animateFloatAsState(if (expanded) 0f else 180f, spatial, label = "fab-turn")
+    Box(contentAlignment = Alignment.Center) {
+        Icon(
+            imageVector = Icons.Default.Add,
+            contentDescription = null,
+            modifier = Modifier.graphicsLayer {
+                rotationZ = 90f * swap
+                scaleX = 1f - 0.5f * swap
+                scaleY = 1f - 0.5f * swap
+                alpha = (1f - swap).coerceIn(0f, 1f)
+            },
+        )
+        Icon(
+            imageVector = Icons.AutoMirrored.Filled.KeyboardArrowRight,
+            contentDescription = null,
+            modifier = Modifier.graphicsLayer {
+                rotationZ = turn - 90f * (1f - swap)
+                scaleX = 0.5f + 0.5f * swap
+                scaleY = 0.5f + 0.5f * swap
+                alpha = swap.coerceIn(0f, 1f)
+            },
+        )
+    }
+}

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

@@ -0,0 +1,170 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import android.Manifest
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.core.content.ContextCompat
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.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.time.Clock
+
+/**
+ * Serialise [detail] to a cache `.ics` and return a shareable content Uri for an
+ * `ACTION_SEND`, or null when the write fails. Exported as a one-off (see
+ * [toShareIcsEvent]). Blocking — call it off the main thread.
+ */
+fun IcsExporter.stageEventShare(detail: EventDetail): Uri? = runCatching {
+    val ics = IcsWriter().writeCalendar(
+        events = listOf(detail.toShareIcsEvent()),
+        dtStamp = Clock.System.now(),
+    )
+    stageShareFile(shareFileName(detail.instance.title), ics)
+}.getOrNull()
+
+/** Open the system chooser for a staged `.ics`; false when nothing could take it. */
+fun Context.sendEventShare(uri: Uri, chooserTitle: String): Boolean = runCatching {
+    val send = Intent(Intent.ACTION_SEND).apply {
+        type = "text/calendar"
+        putExtra(Intent.EXTRA_STREAM, uri)
+        addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+    }
+    startActivity(Intent.createChooser(send, chooserTitle))
+}.isSuccess
+
+/** Delete an event, or as much of its series as [scope] reaches from the occurrence at [beginMillis]. */
+suspend fun CalendarRepository.deleteEvent(
+    eventId: Long,
+    beginMillis: Long,
+    scope: RecurringWriteScope,
+) = when (scope) {
+    RecurringWriteScope.AllEvents -> deleteEvent(eventId)
+    RecurringWriteScope.ThisEvent -> deleteOccurrence(eventId, beginMillis)
+    RecurringWriteScope.ThisAndFollowing -> deleteEventFromOccurrence(eventId, beginMillis)
+}
+
+/**
+ * Runs an action that writes to the calendar, asking for `WRITE_CALENDAR` first
+ * where the install only holds read access (v1.0 installs). A grant continues
+ * straight into the action that asked for it.
+ */
+@Composable
+fun rememberWriteGate(): (() -> Unit) -> Unit {
+    val context = LocalContext.current
+    var pending by remember { mutableStateOf<(() -> Unit)?>(null) }
+    val launcher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.RequestPermission(),
+    ) { granted ->
+        if (granted) pending?.invoke()
+        pending = null
+    }
+    return { action ->
+        val granted = ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.WRITE_CALENDAR,
+        ) == PackageManager.PERMISSION_GRANTED
+        if (granted) {
+            action()
+        } else {
+            pending = action
+            launcher.launch(Manifest.permission.WRITE_CALENDAR)
+        }
+    }
+}
+
+/**
+ * Delete confirmation. Recurring events choose between cancelling just the
+ * tapped occurrence (default), truncating the series from it onwards, and
+ * removing the whole series.
+ */
+@Composable
+fun DeleteEventDialog(
+    isRecurring: Boolean,
+    onConfirm: (RecurringWriteScope) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    var scope by rememberSaveable { mutableStateOf(RecurringWriteScope.ThisEvent) }
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = {
+            Text(
+                stringResource(
+                    if (isRecurring) R.string.event_delete_recurring_title
+                    else R.string.event_delete_title,
+                ),
+            )
+        },
+        text = {
+            if (isRecurring) {
+                Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                    OptionCard(
+                        label = stringResource(R.string.event_delete_option_occurrence),
+                        onClick = { scope = RecurringWriteScope.ThisEvent },
+                        selected = scope == RecurringWriteScope.ThisEvent,
+                    )
+                    OptionCard(
+                        label = stringResource(R.string.event_delete_option_following),
+                        onClick = { scope = RecurringWriteScope.ThisAndFollowing },
+                        selected = scope == RecurringWriteScope.ThisAndFollowing,
+                    )
+                    OptionCard(
+                        label = stringResource(R.string.event_delete_option_series),
+                        onClick = { scope = RecurringWriteScope.AllEvents },
+                        selected = scope == RecurringWriteScope.AllEvents,
+                    )
+                }
+            } else {
+                Text(stringResource(R.string.event_delete_body))
+            }
+        },
+        confirmButton = {
+            TextButton(
+                onClick = { onConfirm(if (isRecurring) scope else RecurringWriteScope.AllEvents) },
+            ) {
+                Text(
+                    text = stringResource(R.string.event_detail_delete),
+                    color = MaterialTheme.colorScheme.error,
+                )
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) {
+                Text(stringResource(R.string.dialog_cancel))
+            }
+        },
+    )
+}
+
+/** A filesystem-safe `.ics` file name from an event title (or a fallback). */
+private fun shareFileName(title: String): String {
+    val base = title.trim()
+        .replace(Regex("""[^\p{L}\p{Nd} _-]"""), "")
+        .replace(' ', '_')
+        .take(40)
+        .ifBlank { "event" }
+    return "$base.ics"
+}

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

@@ -0,0 +1,131 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import android.net.Uri
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.calendar.NoSuchEventException
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
+import de.jeanlucmakiola.calendula.data.ics.IcsExporter
+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.RecurringWriteScope
+import de.jeanlucmakiola.calendula.domain.toDuplicateForm
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.datetime.TimeZone
+import kotlin.coroutines.cancellation.CancellationException
+import javax.inject.Inject
+
+/** A delete waiting on its confirmation dialog. */
+data class DeletePrompt(val event: EventInstance, val isRecurring: Boolean)
+
+/** How an action on a selected event ended, when it has something to say. */
+enum class EventActionFailure { LoadFailed, ShareFailed, DeleteFailed, WriteDenied, Gone }
+
+/** Duplicate, share and delete for a selected event (#141), loading it on demand. */
+@HiltViewModel
+class EventActionsViewModel @Inject constructor(
+    private val repository: CalendarRepository,
+    private val icsExporter: IcsExporter,
+    @IoDispatcher private val io: CoroutineDispatcher,
+) : ViewModel() {
+
+    /** Every calendar by id, for what a selected event's bar may offer. */
+    val calendars: StateFlow<Map<Long, CalendarSource>> = repository.calendars()
+        .map { list -> list.associateBy { it.id } }
+        .catch { emit(emptyMap()) }
+        .flowOn(io)
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = emptyMap(),
+        )
+
+    private val _deletePrompt = MutableStateFlow<DeletePrompt?>(null)
+    val deletePrompt: StateFlow<DeletePrompt?> = _deletePrompt.asStateFlow()
+
+    private val _failure = MutableStateFlow<EventActionFailure?>(null)
+    val failure: StateFlow<EventActionFailure?> = _failure.asStateFlow()
+
+    /** A create form copying [event], or null when it can't be read. */
+    suspend fun duplicateForm(event: EventInstance): EventForm? {
+        val detail = load(event) ?: return null
+        val canModify = calendars.value[event.calendarId]?.canModifyContents == true
+        return detail.toDuplicateForm(canModify, TimeZone.currentSystemDefault())
+    }
+
+    /** A staged `.ics` for [event], or null — reported — when it can't be built. */
+    suspend fun shareUri(event: EventInstance): Uri? {
+        val uri = load(event)?.let { withContext(io) { icsExporter.stageEventShare(it) } }
+        if (uri == null && _failure.value == null) _failure.value = EventActionFailure.ShareFailed
+        return uri
+    }
+
+    /** Ask to delete [event]; the dialog it needs depends on whether it recurs. */
+    fun requestDelete(event: EventInstance) {
+        viewModelScope.launch {
+            val detail = load(event) ?: return@launch
+            _deletePrompt.value = DeletePrompt(event, isRecurring = !detail.rrule.isNullOrBlank())
+        }
+    }
+
+    fun confirmDelete(scope: RecurringWriteScope) {
+        val prompt = _deletePrompt.value ?: return
+        _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
+            }
+        }
+    }
+
+    fun cancelDelete() {
+        _deletePrompt.value = null
+    }
+
+    /** The chooser itself couldn't open — nothing on the device takes an `.ics`. */
+    fun reportShareFailed() {
+        _failure.value = EventActionFailure.ShareFailed
+    }
+
+    fun consumeFailure() {
+        _failure.value = null
+    }
+
+    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))
+    } catch (e: CancellationException) {
+        throw e
+    } catch (e: NoSuchEventException) {
+        _failure.value = EventActionFailure.Gone
+        null
+    } catch (e: Exception) {
+        _failure.value = EventActionFailure.LoadFailed
+        null
+    }
+}

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

@@ -24,31 +24,49 @@ import androidx.compose.ui.unit.dp
 /** How far the finger may wander during the hold — well under touch slop. */
 private val PICKUP_TOLERANCE = 6.dp
 
+/** What a long press on a block turned into. */
+enum class PickUp {
+    /** Nothing to pick up; the gesture is left alone. */
+    None,
+
+    /** Lifted and following the finger. */
+    Drag,
+
+    /** Held but not movable — the gesture is swallowed until the finger lifts. */
+    Hold,
+}
+
 /**
  * Pick an event block up with a long press and drag it, without
  * `detectDragGesturesAfterLongPress`: the stock detector cancels as soon as an
  * ancestor consumes or the finger leaves the block, which a
  * `MIN_EVENT_FRACTION`-tall block loses immediately. Movement before the timeout
  * is deliberately not consumed, so a scroll starting on top of a block survives.
+ *
+ * [onRelease] is the long press that never moved: the finger lifted within touch
+ * slop of where it was picked up, or a [PickUp.Hold] ended. Without it, such a
+ * release is a drop like any other. [immediate] also lifts the block as soon as
+ * the finger moves past touch slop, with no hold — for a block already selected.
  */
 @Composable
 fun rememberEventDragSource(
     enabled: Boolean,
     key: Any?,
-    onPickUp: (pointerInRoot: Offset, blockInRoot: Offset, size: IntSize) -> Unit,
+    onPickUp: (pointerInRoot: Offset, blockInRoot: Offset, size: IntSize) -> PickUp,
     onMove: (pointerInRoot: Offset) -> Unit,
     onDrop: () -> Unit,
     onCancel: () -> Unit,
-): Modifier = rememberDragSurface(
+    onRelease: (() -> Unit)? = null,
+    immediate: Boolean = false,
+): Modifier = rememberPickUpSurface(
     enabled = enabled,
     key = key,
-    onPickUp = { _, pointerInRoot, nodeInRoot, size ->
-        onPickUp(pointerInRoot, nodeInRoot, size)
-        true
-    },
+    immediate = immediate,
+    onPickUp = { _, pointerInRoot, nodeInRoot, size -> onPickUp(pointerInRoot, nodeInRoot, size) },
     onMove = onMove,
     onDrop = onDrop,
     onCancel = onCancel,
+    onRelease = onRelease,
 )
 
 /**
@@ -65,6 +83,29 @@ fun rememberDragSurface(
     onMove: (pointerInRoot: Offset) -> Unit,
     onDrop: () -> Unit,
     onCancel: () -> Unit,
+): Modifier = rememberPickUpSurface(
+    enabled = enabled,
+    key = key,
+    immediate = false,
+    onPickUp = { local, pointer, node, size ->
+        if (onPickUp(local, pointer, node, size)) PickUp.Drag else PickUp.None
+    },
+    onMove = onMove,
+    onDrop = onDrop,
+    onCancel = onCancel,
+    onRelease = null,
+)
+
+@Composable
+private fun rememberPickUpSurface(
+    enabled: Boolean,
+    key: Any?,
+    immediate: Boolean,
+    onPickUp: (local: Offset, pointerInRoot: Offset, nodeInRoot: Offset, size: IntSize) -> PickUp,
+    onMove: (pointerInRoot: Offset) -> Unit,
+    onDrop: () -> Unit,
+    onCancel: () -> Unit,
+    onRelease: (() -> Unit)?,
 ): Modifier {
     if (!enabled) return Modifier
     val holdMillis = LocalViewConfiguration.current.longPressTimeoutMillis
@@ -74,27 +115,42 @@ fun rememberDragSurface(
     val currentMove by rememberUpdatedState(onMove)
     val currentDrop by rememberUpdatedState(onDrop)
     val currentCancel by rememberUpdatedState(onCancel)
+    val currentRelease by rememberUpdatedState(onRelease)
+    // Not a key: the pickup changes it, and a restart would cancel the drag.
+    val currentImmediate by rememberUpdatedState(immediate)
 
     return Modifier
         .onGloballyPositioned { coordinates[0] = it }
         .pointerInput(key) {
+            val slop = viewConfiguration.touchSlop
             awaitEachGesture {
                 val down = awaitFirstDown(requireUnconsumed = false)
                 val origin = down.position
-                val heldStill = withTimeoutOrNull(holdMillis) {
-                    while (true) {
+                val immediate = currentImmediate
+                // Null: held still. True: an immediate pickup past slop. False: abandoned.
+                val outcome = withTimeoutOrNull(holdMillis) {
+                    var result: Boolean? = null
+                    while (result == null) {
                         val main = awaitPointerEvent()
-                        val change = main.changes.firstOrNull { it.id == down.id } ?: break
-                        if (!change.pressed) break
-                        if (main.changes.count { it.pressed } > 1) break
-                        if ((change.position - origin).getDistance() > tolerance) break
-                        // An ancestor's claim only becomes visible once the whole
-                        // main pass has run, so look again on the final pass.
-                        val final = awaitPointerEvent(PointerEventPass.Final)
-                        if (final.changes.any { it.isConsumed }) break
+                        val change = main.changes.firstOrNull { it.id == down.id }
+                        val distance = change?.let { (it.position - origin).getDistance() } ?: 0f
+                        result = when {
+                            change == null || !change.pressed -> false
+                            main.changes.count { it.pressed } > 1 -> false
+                            immediate && distance > slop && !change.isConsumed -> {
+                                change.consume()
+                                true
+                            }
+                            !immediate && distance > tolerance -> false
+                            // An ancestor's claim only becomes visible once the
+                            // whole main pass has run, so look again on the final pass.
+                            awaitPointerEvent(PointerEventPass.Final).changes.any { it.isConsumed } -> false
+                            else -> null
+                        }
                     }
-                } == null
-                if (!heldStill) return@awaitEachGesture
+                    result
+                }
+                if (outcome == false) return@awaitEachGesture
 
                 val layout = coordinates[0]?.takeIf { it.isAttached } ?: return@awaitEachGesture
                 val took = currentPickUp(
@@ -103,8 +159,11 @@ fun rememberDragSurface(
                     layout.positionInRoot(),
                     layout.size,
                 )
-                if (!took) return@awaitEachGesture
+                if (took == PickUp.None) return@awaitEachGesture
+                // Moved already, for an immediate pickup: it can't be a release.
+                var moved = outcome == true
                 var dropped = false
+                var released = false
                 try {
                     // Driven on the initial pass, which runs parent → child: an
                     // ancestor that outranks us (the pinch) has already consumed
@@ -116,18 +175,31 @@ fun rememberDragSurface(
                         if (change.isConsumed) break
                         if (!change.pressed) {
                             change.consume()
-                            dropped = true
+                            if (took == PickUp.Hold || (!moved && currentRelease != null)) {
+                                released = true
+                            } else {
+                                dropped = true
+                            }
                             break
                         }
                         if (event.changes.count { it.pressed } > 1) break
                         change.consume()
+                        if (took == PickUp.Hold) continue
+                        if ((change.position - origin).getDistance() > slop) moved = true
                         coordinates[0]?.takeIf { it.isAttached }
                             ?.let { currentMove(it.localToRoot(change.position)) }
                     }
                 } finally {
                     // Also reached when the pointer node is disposed mid-drag —
                     // a cancel, not a drop, and must never write.
-                    if (dropped) currentDrop() else currentCancel()
+                    when {
+                        released -> {
+                            if (took == PickUp.Drag) currentCancel()
+                            currentRelease?.invoke()
+                        }
+                        dropped -> currentDrop()
+                        took == PickUp.Drag -> currentCancel()
+                    }
                 }
             }
         }

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

@@ -48,7 +48,12 @@ private val FAB_BAND = 88.dp
  * a pill on the FAB's band, leaving the calendar visible behind it.
  */
 @Composable
-fun EventMoveHost(viewModel: RescheduleViewModel, modifier: Modifier = Modifier) {
+fun EventMoveHost(
+    viewModel: RescheduleViewModel,
+    modifier: Modifier = Modifier,
+    actionFailure: String? = null,
+    onActionFailureShown: () -> Unit = {},
+) {
     val prompt by viewModel.scopePrompt.collectAsStateWithLifecycle()
     val outcome by viewModel.outcome.collectAsStateWithLifecycle()
     val undoTick by viewModel.undoStarted.collectAsStateWithLifecycle()
@@ -58,7 +63,9 @@ fun EventMoveHost(viewModel: RescheduleViewModel, modifier: Modifier = Modifier)
 
     prompt?.let { pending ->
         RecurringScopeDialog(
-            title = stringResource(R.string.event_move_recurring_title),
+            title = stringResource(
+                if (pending.resize) R.string.event_resize_recurring_title else R.string.event_move_recurring_title,
+            ),
             onSelect = viewModel::moveWithScope,
             onDismiss = viewModel::cancelScope,
             allowSeries = !pending.occurrenceOnly,
@@ -69,9 +76,17 @@ fun EventMoveHost(viewModel: RescheduleViewModel, modifier: Modifier = Modifier)
 
     val moved = outcome as? MoveOutcome.Moved
     val movedLabel = moved?.let { formatMovedTo(it.startMillis, it.isAllDay, use24Hour, locale) }
+    val resizedLabel = moved?.endMillis?.let { end ->
+        "$movedLabel–${formatTime(end, use24Hour, locale)}"
+    }
+    // A failed selection action (#141) shares the chip rather than stacking on it.
     val message = when (outcome) {
-        null -> null
-        is MoveOutcome.Moved -> stringResource(R.string.event_move_done, movedLabel.orEmpty())
+        null -> actionFailure
+        is MoveOutcome.Moved -> if (resizedLabel != null) {
+            stringResource(R.string.event_resize_done, resizedLabel)
+        } else {
+            stringResource(R.string.event_move_done, movedLabel.orEmpty())
+        }
         MoveOutcome.Undone -> stringResource(R.string.event_move_undone)
         MoveOutcome.WriteDenied -> stringResource(R.string.event_move_write_denied)
         MoveOutcome.Gone -> stringResource(R.string.event_move_gone)
@@ -96,6 +111,12 @@ fun EventMoveHost(viewModel: RescheduleViewModel, modifier: Modifier = Modifier)
         delay(if (outcome == MoveOutcome.Undone) UNDONE_CHIP_MILLIS else CHIP_MILLIS)
         viewModel.consumeOutcome()
     }
+    // A failure waits for the chip to be free, then has its own turn.
+    LaunchedEffect(actionFailure, outcome == null) {
+        if (actionFailure == null || outcome != null) return@LaunchedEffect
+        delay(CHIP_MILLIS)
+        onActionFailureShown()
+    }
 
     BoxWithConstraints(modifier = modifier.fillMaxSize()) {
         val chipMaxWidth = maxWidth - FAB_BAND
@@ -113,7 +134,7 @@ fun EventMoveHost(viewModel: RescheduleViewModel, modifier: Modifier = Modifier)
             // write anyway, so offering it would be a button that does nothing.
             val undo = content.undo?.takeIf { !writeInFlight }
             SnackChip(
-                visible = outcome != null,
+                visible = outcome != null || actionFailure != null,
                 message = content.message,
                 maxWidth = chipMaxWidth,
                 actionLabel = stringResource(R.string.event_move_undo).takeIf { undo != null },
@@ -142,3 +163,7 @@ private fun formatMovedTo(
     return localizedDateFormatter(locale, skeleton)
         .format(Instant.ofEpochMilli(startMillis).atZone(zone))
 }
+
+/** "10:30" — the end of a resized event, read in the device zone like its start. */
+private fun formatTime(millis: Long, use24Hour: Boolean, locale: Locale): String =
+    timeOfDayFormatter(use24Hour, locale).format(Instant.ofEpochMilli(millis).atZone(ZoneId.systemDefault()))

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

@@ -131,6 +131,13 @@ fun eventDragAllowed(event: EventInstance): Boolean {
     return move.dragEnabled && move.allows(event)
 }
 
+/**
+ * Whether a long press may select events at all (#141) — the gesture setting,
+ * whatever the event's calendar allows. A read-only event is selected but stays put.
+ */
+@Composable
+fun eventSelectAllowed(): Boolean = LocalEventMove.current?.dragEnabled == true
+
 /**
  * A TalkBack action that opens [event] in the edit form, so rescheduling isn't
  * pointer-only. Null when this event can't be moved.

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

@@ -0,0 +1,60 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.layout.Row
+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.ContentCopy
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material.icons.filled.Edit
+import androidx.compose.material.icons.filled.Share
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+
+/** The selected event's action bar (#141); Edit and Delete only where its calendar allows. */
+@Composable
+fun EventSelectionBar(
+    canEdit: Boolean,
+    canDelete: Boolean,
+    onEdit: () -> Unit,
+    onDuplicate: () -> Unit,
+    onShare: () -> Unit,
+    onDelete: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    // The FAB's height and colours, so the two read as one control.
+    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),
+        ) {
+            if (canEdit) BarAction(Icons.Default.Edit, R.string.event_detail_edit, onEdit)
+            BarAction(Icons.Default.ContentCopy, R.string.event_detail_duplicate, onDuplicate)
+            BarAction(Icons.Default.Share, R.string.event_detail_share, onShare)
+            if (canDelete) BarAction(Icons.Default.Delete, R.string.event_detail_delete, onDelete)
+        }
+    }
+}
+
+@Composable
+private fun BarAction(icon: ImageVector, label: Int, onClick: () -> Unit) {
+    IconButton(onClick = onClick) {
+        Icon(imageVector = icon, contentDescription = stringResource(label))
+    }
+}

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

@@ -0,0 +1,118 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.floret.components.SnackChipMargin
+import kotlinx.coroutines.launch
+
+/** The bottom band the selection bar and FAB cover, margin included. */
+val SelectionBarClearance = FabSize + SnackChipMargin
+
+/** The FAB's role while an event is selected (#141): its action bar's toggle. Null otherwise. */
+@Composable
+fun rememberFabSelection(
+    host: ChromeHost,
+    viewModel: EventActionsViewModel,
+    onEdit: (EventInstance) -> Unit,
+    onDuplicate: (EventForm) -> Unit,
+    chipShown: Boolean,
+    onDismissChip: () -> Unit,
+): FabSelection? {
+    val calendars by viewModel.calendars.collectAsStateWithLifecycle()
+    val context = LocalContext.current
+    val scope = rememberCoroutineScope()
+    val requireWrite = rememberWriteGate()
+    val chooserTitle = stringResource(R.string.event_share_chooser_title)
+
+    // What the FAB has been told for this selection, over what the coverage says.
+    var chosen by remember(host.selection?.event) { mutableStateOf<Boolean?>(null) }
+    // Folded while a chip is up, which then sits beside the FAB as usual.
+    val expanded = !chipShown && (chosen ?: !host.selectionCompact)
+
+    val currentEdit by rememberUpdatedState(onEdit)
+    val currentDuplicate by rememberUpdatedState(onDuplicate)
+    val currentDismissChip by rememberUpdatedState(onDismissChip)
+    val currentWrite by rememberUpdatedState(requireWrite)
+
+    val selection = host.selection ?: return null
+    val event = selection.event
+    val calendar = calendars[event.calendarId]
+    val canEdit = calendar?.canModifyContents == true
+    val canDelete = canEdit && calendar?.isManaged == false
+    return remember(selection, expanded, chipShown, canEdit, canDelete) {
+        FabSelection(
+            expanded = expanded,
+            onToggle = {
+                if (chipShown) currentDismissChip()
+                chosen = !expanded
+            },
+            bar = {
+                EventSelectionBar(
+                    canEdit = canEdit,
+                    canDelete = canDelete,
+                    onEdit = {
+                        currentWrite {
+                            selection.dismiss()
+                            currentEdit(event)
+                        }
+                    },
+                    onDuplicate = {
+                        currentWrite {
+                            scope.launch {
+                                val form = viewModel.duplicateForm(event) ?: return@launch
+                                selection.dismiss()
+                                currentDuplicate(form)
+                            }
+                        }
+                    },
+                    onShare = {
+                        scope.launch {
+                            val uri = viewModel.shareUri(event) ?: return@launch
+                            if (!context.sendEventShare(uri, chooserTitle)) viewModel.reportShareFailed()
+                        }
+                    },
+                    onDelete = { currentWrite { viewModel.requestDelete(event) } },
+                )
+            },
+        )
+    }
+}
+
+/** What a failed action on a selected event says, for the move host's chip to show (#141). */
+@Composable
+fun eventActionFailureMessage(failure: EventActionFailure?): String? = when (failure) {
+    null -> null
+    EventActionFailure.LoadFailed -> stringResource(R.string.event_action_load_failed)
+    EventActionFailure.ShareFailed -> stringResource(R.string.event_share_failed)
+    EventActionFailure.DeleteFailed -> stringResource(R.string.event_delete_failed)
+    EventActionFailure.WriteDenied -> stringResource(R.string.event_delete_write_denied)
+    EventActionFailure.Gone -> stringResource(R.string.event_move_gone)
+}
+
+/** The delete confirmation a selected event's Delete brings up (#141). */
+@Composable
+fun EventSelectionHost(host: ChromeHost, viewModel: EventActionsViewModel) {
+    val deletePrompt by viewModel.deletePrompt.collectAsStateWithLifecycle()
+    deletePrompt?.let { prompt ->
+        DeleteEventDialog(
+            isRecurring = prompt.isRecurring,
+            onConfirm = { writeScope ->
+                host.selection?.takeIf { it.event == prompt.event }?.dismiss()
+                viewModel.confirmDelete(writeScope)
+            },
+            onDismiss = viewModel::cancelDelete,
+        )
+    }
+}

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

@@ -19,12 +19,15 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.semantics.clearAndSetSemantics
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.ui.week.MINUTES_PER_DAY
 import de.jeanlucmakiola.floret.locale.currentLocale
 
 /** Width of the hour gutter down the start edge of the day and week timelines. */
@@ -67,7 +70,7 @@ fun HourGutter(
     val locale = currentLocale()
     // Derived: the drag is rewritten every frame, its snapped start once a slot.
     val dragStartMin by remember(dragController) {
-        derivedStateOf { dragController.drag?.startMin }
+        derivedStateOf { dragController.drag?.markerMin }
     }
     val hourAlpha by animateFloatAsState(
         targetValue = if (dragStartMin != null) DIMMED_HOUR_ALPHA else 1f,
@@ -107,12 +110,25 @@ fun HourGutter(
                 }
             }
         }
-        dragStartMin?.let { startMin ->
+        // Held while it fades, so it goes out where it was rather than blinking off.
+        val badgeMin = remember { mutableStateOf<Int?>(null) }
+        dragStartMin?.let { badgeMin.value = it }
+        val badgeIn by animateFloatAsState(
+            targetValue = if (dragStartMin != null) 1f else 0f,
+            animationSpec = MaterialTheme.motionScheme.fastEffectsSpec(),
+            label = "gutterBadge",
+        )
+        badgeMin.value?.takeIf { badgeIn > 0f }?.let { startMin ->
             val top = (hourHeight * (startMin / 60f) - BADGE_HEIGHT / 2).coerceAtLeast(0.dp)
             Box(
                 modifier = Modifier
                     .align(Alignment.TopCenter)
                     .offset(y = top)
+                    .graphicsLayer {
+                        alpha = badgeIn
+                        scaleX = 0.8f + 0.2f * badgeIn
+                        scaleY = 0.8f + 0.2f * badgeIn
+                    }
                     .height(BADGE_HEIGHT)
                     .background(MaterialTheme.colorScheme.primary, CircleShape)
                     .padding(horizontal = 4.dp)
@@ -121,7 +137,8 @@ fun HourGutter(
                 contentAlignment = Alignment.Center,
             ) {
                 Text(
-                    text = formatGutterTime(startMin, use24Hour, locale),
+                    // A resized end can sit on midnight: 00:00, not a clamped 23:59.
+                    text = formatGutterTime(startMin % MINUTES_PER_DAY, use24Hour, locale),
                     style = MaterialTheme.typography.labelSmall,
                     color = MaterialTheme.colorScheme.onPrimary,
                     maxLines = 1,

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

@@ -5,6 +5,11 @@ import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.SpanStyle
 import androidx.compose.ui.text.buildAnnotatedString
 import androidx.compose.ui.text.style.TextDecoration
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.hasEnded
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Instant
 
 /**
@@ -16,6 +21,17 @@ import kotlin.time.Instant
  */
 val LocalDimCutoff = compositionLocalOf<Instant?> { null }
 
+/**
+ * Whether [this] counts as past where it's drawn on [day]: once it has ended,
+ * or on any day before the one [now] falls in, so a multi-day event still
+ * running doesn't stay undimmed on the days already behind it.
+ */
+fun EventInstance.isPastOn(
+    day: LocalDate,
+    now: Instant,
+    zone: TimeZone = TimeZone.currentSystemDefault(),
+): Boolean = hasEnded(now) || day < now.toLocalDateTime(zone).date
+
 /** Opacity applied to a completed/past event chip when it is dimmed. */
 const val EventDimAlpha = 0.4f
 

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

@@ -15,6 +15,9 @@ import de.jeanlucmakiola.calendula.domain.allowsEventMove
 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
@@ -54,6 +57,9 @@ sealed interface MoveTarget {
      * disagree by a day over which zone the event's first day is resolved in.
      */
     data class ByDays(val days: Int) : MoveTarget
+
+    /** New start and end instants — a timeline resize, which changes the length. */
+    data class Span(val start: Instant, val end: Instant) : MoveTarget
 }
 
 /**
@@ -74,7 +80,7 @@ data class MoveRequest(
  * re-derive (`BYDAY=MO,WE`, `2TH`, …), or the shift wouldn't carry the anchor
  * across the same midnights the occurrence crossed.
  */
-data class MoveScopePrompt(val occurrenceOnly: Boolean)
+data class MoveScopePrompt(val occurrenceOnly: Boolean, val resize: Boolean = false)
 
 /** The inverse of a completed move, for the undo action. */
 data class MoveUndo(
@@ -88,12 +94,14 @@ data class MoveUndo(
 sealed interface MoveOutcome {
     /**
      * Written. [startMillis] is where the dragged occurrence now begins, for the
-     * confirmation message; [undo] is null when the write has no clean inverse.
+     * confirmation message, and [endMillis] where it ends — set only for a resize,
+     * whose message names both; [undo] is null when the write has no clean inverse.
      */
     data class Moved(
         val startMillis: Long,
         val isAllDay: Boolean,
         val undo: MoveUndo?,
+        val endMillis: Long? = null,
     ) : MoveOutcome
 
     data object Undone : MoveOutcome
@@ -226,7 +234,10 @@ class RescheduleViewModel @Inject constructor(
             } else {
                 // Still busy: the scope dialog is now the thing in flight.
                 pending = prepared
-                _scopePrompt.value = MoveScopePrompt(occurrenceOnly = !prepared.canRealign)
+                _scopePrompt.value = MoveScopePrompt(
+                    occurrenceOnly = !prepared.canRealign,
+                    resize = request.target is MoveTarget.Span,
+                )
             }
         }
         return true
@@ -313,13 +324,14 @@ class RescheduleViewModel @Inject constructor(
         val shifted = when (val target = request.target) {
             is MoveTarget.Start -> original.shiftedTo(target.instant, zone)
             is MoveTarget.ByDays -> original.shiftedByDays(target.days, zone)
+            is MoveTarget.Span -> original.resizedTo(target.start, target.end, zone)
         }
         // A zero-distance drop is not a write.
         if (shifted == original) return null
 
         // 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
         }
@@ -396,6 +408,7 @@ class RescheduleViewModel @Inject constructor(
                 startMillis = movedStartMillis(prepared),
                 isAllDay = prepared.updated.isAllDay,
                 undo = undoFor(prepared, scope),
+                endMillis = resizedEndMillis(prepared),
             )
         } catch (e: CancellationException) {
             throw e
@@ -480,6 +493,13 @@ class RescheduleViewModel @Inject constructor(
             null
         }
 
+    /** Where a resized occurrence now ends; null for a move, which keeps its length. */
+    private fun resizedEndMillis(prepared: PreparedMove): Long? {
+        if (prepared.request.target !is MoveTarget.Span) return null
+        val form = prepared.updated
+        return form.endInstant(form.resolvedZone(TimeZone.currentSystemDefault())).toEpochMilliseconds()
+    }
+
     /**
      * Where the dragged occurrence now begins, in the same anchoring the views
      * read dates back in: UTC midnight for an all-day event.
@@ -489,8 +509,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(TimeZone.currentSystemDefault())).toEpochMilliseconds()
         }
     }
 

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

@@ -0,0 +1,102 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.LayoutCoordinates
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.semantics.clearAndSetSemantics
+import androidx.compose.ui.unit.dp
+
+/** The handle's touch target, centred on the edge it moves. */
+val ResizeHandleTarget = 48.dp
+
+private val HANDLE_DOT = 16.dp
+private val HANDLE_RING = 2.dp
+
+/**
+ * A grip on one edge of a selected event (#141), dragged without a hold. No
+ * semantics: TalkBack resizes through the event's edit action.
+ */
+@Composable
+fun ResizeHandle(
+    color: Color,
+    enabled: Boolean,
+    onStart: (pointerInRoot: Offset) -> Unit,
+    onMove: (pointerInRoot: Offset) -> Unit,
+    onEnd: () -> Unit,
+    onCancel: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val coordinates = remember { arrayOfNulls<LayoutCoordinates>(1) }
+    val currentStart by rememberUpdatedState(onStart)
+    val currentMove by rememberUpdatedState(onMove)
+    val currentEnd by rememberUpdatedState(onEnd)
+    val currentCancel by rememberUpdatedState(onCancel)
+    // Not a key: turning it off mid-resize must not cancel that resize.
+    val currentEnabled by rememberUpdatedState(enabled)
+    Box(
+        contentAlignment = Alignment.Center,
+        modifier = modifier
+            .size(ResizeHandleTarget)
+            .clearAndSetSemantics { }
+            .onGloballyPositioned { coordinates[0] = it }
+            .pointerInput(Unit) {
+                awaitEachGesture {
+                    val down = awaitFirstDown()
+                    if (!currentEnabled) return@awaitEachGesture
+                    down.consume()
+                    var started = false
+                    var ended = false
+                    try {
+                        while (true) {
+                            val event = awaitPointerEvent()
+                            val change = event.changes.firstOrNull { it.id == down.id } ?: break
+                            // Claimed by an ancestor that outranks us — the pinch.
+                            if (change.isConsumed) break
+                            if (event.changes.count { it.pressed } > 1) break
+                            change.consume()
+                            if (!change.pressed) {
+                                ended = started
+                                break
+                            }
+                            val root = coordinates[0]?.takeIf { it.isAttached }
+                                ?.localToRoot(change.position) ?: break
+                            if (started) {
+                                currentMove(root)
+                            } else {
+                                started = true
+                                currentStart(root)
+                            }
+                        }
+                    } finally {
+                        when {
+                            ended -> currentEnd()
+                            started -> currentCancel()
+                        }
+                    }
+                }
+            },
+    ) {
+        Box(
+            Modifier
+                .size(HANDLE_DOT)
+                .background(color, CircleShape)
+                .border(HANDLE_RING, MaterialTheme.colorScheme.surface, CircleShape),
+        )
+    }
+}

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

@@ -0,0 +1,89 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextOverflow
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.floret.locale.currentLocale
+import de.jeanlucmakiola.floret.locale.localizedDateFormatter
+import java.time.ZoneId
+import java.util.Locale
+import kotlin.time.toJavaInstant
+
+/**
+ * The top bar while an event is selected (#141): says which, and when, with a
+ * way out — the selection otherwise only shows on the grid and in the FAB.
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun SelectionTopBar(selection: EventSelection) {
+    val event = selection.event
+    val use24Hour = LocalUse24HourFormat.current
+    val locale = currentLocale()
+    val whenText = remember(event.start, event.end, use24Hour, locale) {
+        formatSelectionWhen(event, use24Hour, locale)
+    }
+    TopAppBar(
+        navigationIcon = {
+            IconButton(onClick = selection.dismiss) {
+                Icon(
+                    imageVector = Icons.Default.Close,
+                    contentDescription = stringResource(R.string.event_selection_close),
+                )
+            }
+        },
+        title = {
+            Column {
+                Text(
+                    text = event.title.ifBlank { stringResource(R.string.event_untitled) },
+                    style = MaterialTheme.typography.titleMedium,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                )
+                Text(
+                    text = whenText,
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                )
+            }
+        },
+        // The header's own surface, as the view's bar has (#186).
+        colors = TopAppBarDefaults.topAppBarColors(
+            containerColor = MaterialTheme.colorScheme.surface,
+            scrolledContainerColor = MaterialTheme.colorScheme.surface,
+        ),
+    )
+}
+
+/**
+ * "Fri, 9 Oct · 09:00–10:00", or with both days named for an event that runs
+ * into another: "Fri, 9 Oct, 22:00 – Sat, 10 Oct, 02:00".
+ */
+private fun formatSelectionWhen(event: EventInstance, use24Hour: Boolean, locale: Locale): String {
+    val zone = ZoneId.systemDefault()
+    val start = event.start.toJavaInstant().atZone(zone)
+    val end = event.end.toJavaInstant().atZone(zone)
+    val day = localizedDateFormatter(locale, "EEEdMMM")
+    val time = timeOfDayFormatter(use24Hour, locale)
+    val endsSameDay = end.toLocalDate() == start.toLocalDate() ||
+        (end.toLocalTime().toSecondOfDay() == 0 && end.toLocalDate() == start.toLocalDate().plusDays(1))
+    return if (endsSameDay) {
+        "${day.format(start)} · ${time.format(start)}–${time.format(end)}"
+    } else {
+        "${day.format(start)}, ${time.format(start)} – ${day.format(end)}, ${time.format(end)}"
+    }
+}

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

@@ -1,7 +1,13 @@
 package de.jeanlucmakiola.calendula.ui.common
 
 import androidx.compose.runtime.staticCompositionLocalOf
+import de.jeanlucmakiola.calendula.domain.inRepeatedHour
+import de.jeanlucmakiola.calendula.domain.timeZoneOptionOf
+import de.jeanlucmakiola.calendula.domain.zoneAbbreviation
+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 +74,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 option = timeZoneOptionOf(zone.id, locale, instant.toJavaInstant(), ::icuTimeZoneRegion)
+        ?: return formatted
+    return "$formatted ${zoneAbbreviation(option)}"
+}

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

@@ -1,6 +1,7 @@
 package de.jeanlucmakiola.calendula.ui.common
 
 import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.Animatable
 import androidx.compose.animation.core.tween
 import androidx.compose.foundation.ScrollState
 import androidx.compose.foundation.MutatePriority
@@ -20,6 +21,7 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.Stable
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateListOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
@@ -27,6 +29,7 @@ import androidx.compose.runtime.withFrameNanos
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Shape
 import androidx.compose.ui.graphics.TransformOrigin
 import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.layout.LayoutCoordinates
@@ -35,14 +38,19 @@ import androidx.compose.ui.semantics.clearAndSetSemantics
 import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.layout.positionInRoot
 import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalViewConfiguration
 import androidx.compose.ui.res.stringResource
 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.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.inRepeatedHour
+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.floret.identity.rememberReduceMotion
 import de.jeanlucmakiola.floret.locale.currentLocale
 import kotlinx.coroutines.delay
@@ -50,6 +58,7 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.offsetAt
 import kotlinx.datetime.plus
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
@@ -57,6 +66,7 @@ import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
 import kotlin.math.roundToInt
+import kotlin.time.Duration
 import kotlin.time.Instant
 
 /** Start granularity a dragged block snaps to, matching the big calendar apps. */
@@ -97,11 +107,28 @@ data class TimelineDrag(
      * drop lands, so it is dropped once the gesture ends ([finish]).
      */
     val edgeOnly: Boolean = false,
+    /**
+     * The minute of its day the gutter badge names — the top edge, or for a
+     * bottom-edge resize the end being dragged (#141).
+     */
+    val markerMin: Int = startMin,
 ) {
-    /** What the snap haptics key off: one tick per changed slot, not per frame. */
-    val slot: Pair<LocalDate, Int> get() = date to startMin
+    /**
+     * What the snap haptics key off: one tick per changed slot, not per frame.
+     * Carries the length, which is all a bottom-edge resize changes.
+     */
+    val slot: Triple<LocalDate, Int, Int> get() = Triple(date, startMin, eventSpanMin)
 }
 
+/** The event a long press left selected (#141). */
+data class TimelineSelection(
+    val event: EventInstance,
+    /** Set from a move or resize of it until the grid shows where it landed. */
+    val moved: Boolean = false,
+    /** Selected by letting go of a lifted block, which then keeps that lift as it is. */
+    val fromLift: Boolean = false,
+)
+
 /**
  * One day column's share of a dragged event, ready to draw. Both halves of an
  * event crossing midnight are previewed, whichever half the finger picked up:
@@ -248,6 +275,56 @@ data class TimelineDrop(
     val clipOffsetMin: Int = 0,
 )
 
+/** 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)
+
+/**
+ * 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.
+ */
+internal fun resizedSpan(
+    edge: ResizeEdge,
+    startMin: Int,
+    endMin: Int,
+    edgeMin: Float,
+    edgeDay: Int? = null,
+): Pair<Int, Int> {
+    // An edge dragged into a day past the other end changes nothing.
+    if (edgeDay != null) {
+        val endDay = (endMin - 1).floorDiv(MINUTES_PER_DAY).coerceAtLeast(0)
+        val wrongWay = when (edge) {
+            ResizeEdge.Top -> edgeDay > endDay
+            ResizeEdge.Bottom -> edgeDay < startMin.floorDiv(MINUTES_PER_DAY)
+        }
+        if (wrongWay) return startMin to endMin
+    }
+    val snapped = (edgeMin / DRAG_SNAP_MINUTES).roundToInt() * DRAG_SNAP_MINUTES
+    return when (edge) {
+        ResizeEdge.Top -> minOf(snapped, endMin - DRAG_SNAP_MINUTES) to endMin
+        ResizeEdge.Bottom -> startMin to maxOf(snapped, startMin + DRAG_SNAP_MINUTES)
+    }
+}
+
+/** [minutes] snapped, kept at [held] until three quarters of a step away. */
+internal fun stickySnap(minutes: Float, held: Int?): Int {
+    if (held != null && kotlin.math.abs(minutes - held) < DRAG_SNAP_MINUTES * 0.75f) return held
+    return (minutes / DRAG_SNAP_MINUTES).roundToInt() * DRAG_SNAP_MINUTES
+}
+
+/** How far past its column's side the finger has to go before a resize changes day. */
+private const val COLUMN_HYSTERESIS = 0.25f
+
+/** The column under [position], kept at [held] until [COLUMN_HYSTERESIS] into another. */
+internal fun stickyColumn(position: Float, held: Int?, lastIndex: Int): Int {
+    val under = position.toInt().coerceIn(0, lastIndex)
+    if (held == null) return under
+    val stays = position >= held - COLUMN_HYSTERESIS && position < held + 1 + COLUMN_HYSTERESIS
+    return if (stays) held else under
+}
+
 /**
  * The timeline's live geometry, republished on every layout. Plain fields rather
  * than snapshot state: it changes on every scroll frame, and the drag loop reads
@@ -320,10 +397,88 @@ class TimelineDragController {
      */
     private var settledOrigin: Pair<Long, Instant>? by mutableStateOf(null)
 
+    /** The selected event, if any — see [TimelineSelection]. */
+    var selection: TimelineSelection? by mutableStateOf(null)
+        private set
+
+    fun select(event: EventInstance, moved: Boolean = false, fromLift: Boolean = false) {
+        if (selection?.event?.instanceId != event.instanceId) selectionCovered = false
+        selection = TimelineSelection(event, moved, fromLift)
+    }
+
+    fun deselect() {
+        selection = null
+        selectionCovered = false
+    }
+
+    /** The events of the blocks on screen that show the selection; none for a while ends it. */
+    val selectedCandidates = mutableStateListOf<EventInstance>()
+
+    fun noteSelectedBlock(event: EventInstance, shown: Boolean) {
+        if (shown) selectedCandidates.add(event) else selectedCandidates.remove(event)
+    }
+
+    /**
+     * Once a move of the selected event has settled, point the selection at the
+     * row it landed as. A new event id wins: a single moved occurrence is written
+     * as an exception, and another occurrence of its series may share its time.
+     */
+    fun settleMovedSelection() {
+        val current = selection?.takeIf { it.moved } ?: return
+        if (isDragging || settling != null) return
+        val landed = selectedCandidates.filter { it.instanceId != current.event.instanceId }
+        // Only the original row left: the move was abandoned, and it still stands.
+        val chosen = landed.firstOrNull { it.eventId != current.event.eventId }
+            ?: landed.firstOrNull() ?: selectedCandidates.firstOrNull() ?: return
+        selection = current.copy(event = chosen, moved = false)
+    }
+
+    /** Whether the selected block's bottom sits where the action bar would cover it. */
+    var selectionCovered: Boolean by mutableStateOf(false)
+        private set
+
+    /**
+     * Whether [block] is the selected event: by instance, by series and start, and
+     * just after a move by title and times, since a moved occurrence gets new ids.
+     */
+    fun isSelected(block: TimedBlock): Boolean {
+        val current = selection ?: return false
+        val selected = current.event
+        val event = block.event
+        return event.instanceId == selected.instanceId ||
+            (event.eventId == selected.eventId && event.start == selected.start) ||
+            (
+                current.moved &&
+                    event.calendarId == selected.calendarId &&
+                    event.title.isNotBlank() &&
+                    event.title == selected.title &&
+                    event.start == selected.start &&
+                    event.end == selected.end
+                )
+    }
+
+    /** Point the selection at [block]'s event, so the bar acts on the row now there. */
+    fun adoptSelection(block: TimedBlock) {
+        val current = selection?.takeIf { !it.moved } ?: return
+        if (current.event != block.event) selection = current.copy(event = block.event)
+    }
+
     /** Whether a finger is on a block right now — [settling] is not dragging. */
     var isDragging: Boolean by mutableStateOf(false)
         private set
 
+    /** Whether the finger has moved since the pickup; only then may the view auto-scroll. */
+    var pointerMoved: Boolean by mutableStateOf(false)
+        private set
+
+    /** Touch slop, past which the finger counts as having moved. */
+    var slopPx: Float = 0f
+
+    private var pickupPointer = Offset.Zero
+
+    /** The end a settling resize asked for, which the grid has to show before it settles. */
+    private var settledEnd: Instant? = null
+
     /**
      * Whether the grid itself now draws the settled drop at its landing slot.
      * The copy may only be handed back once this is true, or the source ghost
@@ -332,6 +487,10 @@ class TimelineDragController {
     var settledOnGrid: Boolean by mutableStateOf(false)
         private set
 
+    /** Whether the settling drop is the selected event, whose block lands still lifted. */
+    var settlingSelected: Boolean = false
+        private set
+
     /**
      * The abandoned-move counter, read at the drop so the mark can't be a
      * composition behind the tick it is compared against.
@@ -353,6 +512,8 @@ 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
 
     /** What the picked-up block drew its title over — see [TimelineDrag.titleLines]. */
     private var titleLines = 0
@@ -361,23 +522,50 @@ class TimelineDragController {
      * The slot the block already occupied when it was picked up — not the same
      * as its start, since the target snaps to the grid (09:07 lifts to 09:00).
      */
-    private var originSlot: Pair<LocalDate, Int>? = null
+    private var originSlot: Triple<LocalDate, Int, Int>? = null
+
+    /** The edge a resize is dragging, or null for a plain drag (#141). */
+    private var resizeEdge: ResizeEdge? = null
+
+    /** The day the resized event starts on; its edges are minutes from that midnight. */
+    private var resizeDay: LocalDate? = null
+    private var resizeStartMin = 0
+    private var resizeEndMin = 0
+
+    /** How far the finger sits past the edge it grabbed, so the edge doesn't jump to it. */
+    private var resizeGrabMin = 0f
+
+    /** The column the resized edge is in, held until the finger is well into another. */
+    private var resizeColumn: Int? = null
+
+    /** The slot the resized edge sits on, held against a finger trembling between two. */
+    private var resizeSlot: Int? = null
+
+    /** The day, counted from the event's start day, the finger is resizing in. */
+    private var resizeEdgeDay = 0
 
     fun begin(
         block: TimedBlock,
         clipOffsetMin: Int,
+        zone: TimeZone,
         titleLines: Int,
         pointerInRoot: Offset,
         blockInRoot: Offset,
     ) {
+        // The selected event keeps its selection through a drag; any other ends it.
+        if (!isSelected(block)) deselect()
         source = block
         this.clipOffsetMin = clipOffsetMin
+        dragZone = zone
+        dragDuration = (block.event.end - block.event.start).coerceAtLeast(Duration.ZERO)
         this.titleLines = titleLines
         settling = null
         isDragging = true
         liftedInstanceId = block.event.instanceId
         grab = pointerInRoot - blockInRoot
         pointer = pointerInRoot
+        pickupPointer = pointerInRoot
+        pointerMoved = false
         originSlot = null
         recompute()
         originSlot = drag?.slot
@@ -385,20 +573,30 @@ class TimelineDragController {
 
     fun move(pointerInRoot: Offset) {
         pointer = pointerInRoot
+        if (!pointerMoved && (pointerInRoot - pickupPointer).getDistance() > slopPx) pointerMoved = true
         recompute()
     }
 
     fun cancel() {
+        resizeEdge = null
+        resizeDay = null
+        resizeColumn = null
+        resizeSlot = null
         source = null
         clipOffsetMin = 0
+        dragZone = null
+        dragDuration = Duration.ZERO
         titleLines = 0
         isDragging = false
+        pointerMoved = false
         liftedInstanceId = null
         originSlot = null
         drag = null
         settling = null
         settledOnGrid = false
         settledOrigin = null
+        settledEnd = null
+        settlingSelected = false
     }
 
     /**
@@ -429,8 +627,11 @@ class TimelineDragController {
         val offset = (date.toEpochDays() - landed.date.toEpochDays()).toInt()
         val slice = dragSlices(landed.eventStartMin, landed.eventSpanMin, offset..offset)
             .firstOrNull() ?: return
+        val end = settledEnd
         settledOnGrid = blocks.any { block ->
             block.startMin == slice.startMin &&
+                // A resize may keep its start, so its end has to have landed too.
+                (end == null || block.event.end == end) &&
                 (
                     block.event.eventId == landed.event.eventId ||
                         (
@@ -452,6 +653,7 @@ class TimelineDragController {
         val clipOffset = clipOffsetMin
         cancel()
         if (landed == null || landed.slot == origin) 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
         // [noteGrid] can never seat it and it would sit at the top of today for
@@ -463,6 +665,162 @@ class TimelineDragController {
         return TimelineDrop(landed.event, landed.date, landed.startMin, clipOffset)
     }
 
+    /**
+     * Grab one edge of [block] to resize it (#141). The edge follows the finger
+     * across days as a drag does; the other stays where it is.
+     */
+    fun beginResize(
+        block: TimedBlock,
+        edge: ResizeEdge,
+        zone: TimeZone,
+        titleLines: Int,
+        pointerInRoot: Offset,
+    ) {
+        val start = block.event.start.toLocalDateTime(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 = wallClockEndMinutes(resizeStartMin, block.event.start, block.event.end, start.date, zone)
+        clipOffsetMin = 0
+        this.titleLines = titleLines
+        settling = null
+        isDragging = true
+        pointerMoved = true
+        liftedInstanceId = block.event.instanceId
+        pointer = pointerInRoot
+        // Measured from the edge's own column: the handle overhangs into the next.
+        val edgeDay = if (edge == ResizeEdge.Top) 0 else (resizeEndMin - 1).floorDiv(MINUTES_PER_DAY).coerceAtLeast(0)
+        val edgeIndex = geometry.days.indexOf(start.date.plus(edgeDay, DateTimeUnit.DAY))
+        resizeColumn = edgeIndex.takeIf { it >= 0 }
+            ?.let { if (geometry.isRtl) geometry.days.lastIndex - it else it }
+        resizeGrabMin = (pointerResizeMinutes() ?: 0f) -
+            if (edge == ResizeEdge.Top) resizeStartMin else resizeEndMin
+        originSlot = null
+        recompute()
+        originSlot = drag?.slot
+    }
+
+    /**
+     * End a resize, handing back the event's new span — null when it never
+     * resolved or came back to the length it started at. Settles as [finish] does.
+     */
+    fun finishResize(zone: TimeZone): TimelineResizeDrop? {
+        val landed = drag
+        val origin = originSlot
+        val edge = resizeEdge
+        cancel()
+        if (landed == null || landed.slot == origin) return null
+        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
+        // 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).
+        val drop = TimelineResizeDrop(
+            event = landed.event,
+            start = if (edge == ResizeEdge.Top) {
+                wallClockInstant(landed.date, landed.eventStartMin, zone, keepOffsetOf = landed.event.start)
+            } else {
+                landed.event.start
+            },
+            end = if (edge == ResizeEdge.Bottom) {
+                wallClockInstant(
+                    landed.date,
+                    landed.eventStartMin + landed.eventSpanMin,
+                    zone,
+                    keepOffsetOf = landed.event.end,
+                )
+            } else {
+                landed.event.end
+            },
+        )
+        settledEnd = drop.end
+        return drop
+    }
+
+    /**
+     * Where the finger is, in minutes from the resized event's start day —
+     * past 1440 in a later column, negative in an earlier one.
+     */
+    private fun pointerResizeMinutes(): Float? {
+        val grid = geometry.grid?.takeIf { it.isAttached } ?: return null
+        val day = resizeDay ?: return null
+        val hourPx = geometry.hourPx
+        val columnPx = geometry.columnWidthPx
+        val days = geometry.days
+        if (hourPx <= 0f || columnPx <= 0f || days.isEmpty()) return null
+        val origin = grid.positionInRoot()
+        val column = stickyColumn(
+            position = (pointer.x - origin.x) / columnPx,
+            held = resizeColumn,
+            lastIndex = days.lastIndex,
+        )
+        resizeColumn = column
+        val dayIndex = if (geometry.isRtl) days.lastIndex - column else column
+        val dayOffset = (days[dayIndex].toEpochDays() - day.toEpochDays()).toInt()
+        resizeEdgeDay = dayOffset
+        return dayOffset * MINUTES_PER_DAY + (pointer.y - origin.y) / hourPx * 60f
+    }
+
+    private fun recomputeResize(edge: ResizeEdge) {
+        val block = source ?: return
+        val day = resizeDay ?: return
+        val raw = pointerResizeMinutes() ?: return
+        val slot = stickySnap(raw - resizeGrabMin, resizeSlot)
+        resizeSlot = slot
+        val (start, end) = resizedSpan(edge, resizeStartMin, resizeEndMin, slot.toFloat(), resizeEdgeDay)
+        val days = geometry.days
+        val hourPx = geometry.hourPx
+        val columnPx = geometry.columnWidthPx
+        val origin = geometry.grid?.takeIf { it.isAttached }?.positionInRoot() ?: return
+        // Which column the start day sits in, possibly off either end of the view.
+        val startIndex = (day.toEpochDays() - days.first().toEpochDays()).toInt()
+        val visible = -startIndex..days.lastIndex - startIndex
+        val slices = dragSlices(start, end - start, within = visible)
+        drag = TimelineDrag(
+            event = block.event,
+            date = day,
+            startMin = start,
+            eventStartMin = start,
+            eventSpanMin = end - start,
+            titleLines = titleLines,
+            pieces = slices.map { slice ->
+                val dayIndex = startIndex + slice.dayOffset
+                val col = if (geometry.isRtl) days.lastIndex - dayIndex else dayIndex
+                val bounds = dragPieceBounds(slice, hourPx, geometry.blockInsetPx)
+                TimelineDragPiece(
+                    topLeftInRoot = Offset(x = origin.x + col * columnPx, y = origin.y + bounds.top),
+                    sizePx = IntSize(
+                        (columnPx - geometry.columnGapPx).roundToInt(),
+                        bounds.height.roundToInt(),
+                    ),
+                    continuesBefore = slice.continuesBefore,
+                    continuesAfter = slice.continuesAfter,
+                )
+            },
+            edgeOnly = slices.isEmpty(),
+            markerMin = if (edge == ResizeEdge.Top) {
+                start.mod(MINUTES_PER_DAY)
+            } else {
+                end - (end - 1).floorDiv(MINUTES_PER_DAY) * MINUTES_PER_DAY
+            },
+        )
+    }
+
+    /** Note whether the action bar would cover the selected block's bottom handle (#141). */
+    fun noteSelectedBottom(block: LayoutCoordinates, extraPx: Float, clearancePx: Float) {
+        val viewport = geometry.viewport?.takeIf { it.isAttached } ?: return
+        if (!block.isAttached) return
+        val port = viewport.boundsInRoot()
+        val bottom = block.positionInRoot().y + block.size.height + extraPx
+        val covered = bottom > port.bottom - clearancePx
+        if (covered != selectionCovered) selectionCovered = covered
+    }
+
     /**
      * Stop ghosting the source — the grid draws the drop itself by now — while
      * the copy is still dissolving. Un-ghosting at [release] instead would leave
@@ -477,6 +835,8 @@ class TimelineDragController {
     fun release() {
         settling = null
         settledOnGrid = false
+        settledEnd = null
+        settlingSelected = false
         handOver()
     }
 
@@ -486,6 +846,10 @@ class TimelineDragController {
      * no move events while auto-scroll walks the content underneath it.
      */
     fun recompute() {
+        resizeEdge?.let {
+            recomputeResize(it)
+            return
+        }
         val block = source ?: return
         val grid = geometry.grid?.takeIf { it.isAttached } ?: return
         val hourPx = geometry.hourPx
@@ -496,13 +860,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 = block.event.start
+        // 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 {
@@ -577,6 +950,7 @@ fun rememberTimelineDragController(): TimelineDragController {
     val density = LocalDensity.current
     controller.geometry.edgePx = with(density) { AUTO_SCROLL_EDGE.toPx() }
     controller.geometry.stepPx = with(density) { AUTO_SCROLL_STEP.toPx() }
+    controller.slopPx = LocalViewConfiguration.current.touchSlop
     controller.abandonedTicks = LocalEventMove.current?.abandoned
     return controller
 }
@@ -589,10 +963,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)
 }
 
 /**
@@ -613,15 +984,42 @@ fun TimedBlock.continuesAfter(day: LocalDate, zone: TimeZone): Boolean =
  * of its own; `toInstant` resolves it forward by the missing hour, and the block
  * visibly settles there.
  */
-fun TimelineDrop.startInstant(zone: TimeZone): Instant {
-    // Wall clock throughout, and past this day at either end: a block's top edge
-    // can be dragged above its midnight and a tail's below the next one, so the
-    // start is resolved as a day plus a minute of it rather than as an offset
-    // from an instant — which would shift by an hour across a DST boundary.
-    val fromMidnight = startMin - clipOffsetMin
-    val day = date.plus(fromMidnight.floorDiv(MINUTES_PER_DAY), DateTimeUnit.DAY)
-    val minute = fromMidnight.mod(MINUTES_PER_DAY)
-    return LocalDateTime(day, LocalTime(minute / 60, minute % 60)).toInstant(zone)
+fun TimelineDrop.startInstant(zone: TimeZone): Instant =
+    wallClockInstant(date, startMin - clipOffsetMin, zone, keepOffsetOf = event.start)
+
+/**
+ * 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,
+    keepOffsetOf: Instant? = null,
+): Int {
+    val start = wallClockInstant(date, startMin, zone, keepOffsetOf)
+    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
+ * [keepOffsetOf] is itself in that hour's later one: an event there stays on it
+ * (#387). An instant outside the hour 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,
+    keepOffsetOf: Instant? = null,
+): Instant {
+    val day = date.plus(minutes.floorDiv(MINUTES_PER_DAY), DateTimeUnit.DAY)
+    val minute = minutes.mod(MINUTES_PER_DAY)
+    val kept = keepOffsetOf?.takeIf { it.inRepeatedHour(zone) }?.let(zone::offsetAt)
+    return LocalDateTime(day, LocalTime(minute / 60, minute % 60)).resolveIn(zone, kept)
 }
 
 /**
@@ -660,8 +1058,10 @@ fun TimelineDragOverlay(controller: TimelineDragController, modifier: Modifier =
     // Both live here rather than beside the controller: they read [drag], which
     // changes every frame, and this composable is the one that is meant to.
     DragSnapHaptics(controller.drag?.slot)
-    LaunchedEffect(controller.isDragging) {
-        if (controller.isDragging) controller.autoScroll()
+    // Only once the finger has moved: a long press held near an edge must not
+    // scroll the drop target out from under a finger that only means to select.
+    LaunchedEffect(controller.isDragging && controller.pointerMoved) {
+        if (controller.isDragging && controller.pointerMoved) controller.autoScroll()
     }
     // Hold the landed copy until the write is done — including the time a
     // recurring drop's scope dialog is up — and then until the grid draws the
@@ -693,7 +1093,8 @@ fun TimelineDragOverlay(controller: TimelineDragController, modifier: Modifier =
         // Landed: the copy sinks back to the grid's own plane while the write runs.
         val landed = controller.drag == null
         val lift by animateFloatAsState(
-            targetValue = if (landed || reduceMotion) 0f else 1f,
+            // A selected event's block is lifted too: sinking first made it shrink, then grow back.
+            targetValue = if (reduceMotion || (landed && !controller.settlingSelected)) 0f else 1f,
             label = "drag-lift",
         )
         val copyAlpha by animateFloatAsState(
@@ -880,3 +1281,29 @@ private fun DragCopy(
         }
     }
 }
+
+/** How far a selected block is lifted, 0 to 1 (#141); [snap] takes it over at once. */
+@Composable
+fun selectionLift(selected: Boolean, snap: Boolean = false): Float {
+    val reduceMotion = rememberReduceMotion()
+    val spec = MaterialTheme.motionScheme.fastSpatialSpec<Float>()
+    val raise = remember { Animatable(if (selected) 1f else 0f) }
+    LaunchedEffect(selected) {
+        val target = if (selected) 1f else 0f
+        if (reduceMotion || (selected && snap)) raise.snapTo(target) else raise.animateTo(target, spec)
+    }
+    return raise.value
+}
+
+/**
+ * A selected block raised off the grid, the way a dragged copy is: scaled from
+ * its top edge so the text doesn't creep, with a shadow in the block's shape.
+ */
+fun Modifier.selectionLift(raise: Float, shape: Shape): Modifier = graphicsLayer {
+    transformOrigin = TransformOrigin(0.5f, 0f)
+    scaleX = 1f + 0.02f * raise
+    scaleY = 1f + 0.02f * raise
+    shadowElevation = 6.dp.toPx() * raise
+    this.shape = shape
+    clip = false
+}

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

@@ -1,13 +1,9 @@
 package de.jeanlucmakiola.calendula.ui.detail
 
-import android.Manifest
 import android.content.Context
 import android.content.Intent
-import android.content.pm.PackageManager
 import android.net.Uri
 import android.widget.Toast
-import androidx.activity.compose.rememberLauncherForActivityResult
-import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.foundation.background
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
@@ -41,7 +37,6 @@ import androidx.compose.material.icons.filled.Public
 import androidx.compose.material.icons.filled.Repeat
 import androidx.compose.material.icons.filled.Schedule
 import androidx.compose.material.icons.filled.Share
-import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
@@ -51,7 +46,6 @@ import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
@@ -67,7 +61,6 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalContext
-import androidx.core.content.ContextCompat
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.LinkAnnotation
@@ -90,13 +83,15 @@ 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.RecurringWriteScope
 import de.jeanlucmakiola.calendula.domain.Reminder
 import de.jeanlucmakiola.calendula.domain.TimeZoneOption
 import de.jeanlucmakiola.calendula.domain.timeZoneOptionOf
 import de.jeanlucmakiola.calendula.domain.zoneDescriptor
 import de.jeanlucmakiola.floret.identity.predictiveBack
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
+import de.jeanlucmakiola.calendula.ui.common.DeleteEventDialog
+import de.jeanlucmakiola.calendula.ui.common.rememberWriteGate
+import de.jeanlucmakiola.calendula.ui.common.sendEventShare
 import de.jeanlucmakiola.calendula.ui.common.FieldCopier
 import de.jeanlucmakiola.calendula.ui.common.copyOnLongPress
 import de.jeanlucmakiola.calendula.ui.common.rememberFieldCopier
@@ -104,10 +99,10 @@ import de.jeanlucmakiola.calendula.ui.common.icuTimeZoneRegion
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.eventAccent
 import de.jeanlucmakiola.calendula.ui.common.eventFill
-import de.jeanlucmakiola.floret.components.OptionCard
 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
@@ -162,43 +157,15 @@ fun EventDetailScreen(
     val onShareClick = {
         scope.launch {
             val uri = viewModel.shareUri()
-            val sent = uri != null && runCatching {
-                val send = Intent(Intent.ACTION_SEND).apply {
-                    type = "text/calendar"
-                    putExtra(Intent.EXTRA_STREAM, uri)
-                    addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
-                }
-                context.startActivity(Intent.createChooser(send, shareChooserTitle))
-            }.isSuccess
+            val sent = uri != null && context.sendEventShare(uri, shareChooserTitle)
             if (!sent) snackbarHostState.showSnackbar(shareFailedMessage)
         }
         Unit
     }
 
     // v1.0 installs only hold READ_CALENDAR; the first write asks for the
-    // upgrade in place. Granting continues straight into the tapped action —
-    // edit, delete, or duplicate — held here until the result comes back.
-    var pendingWrite by remember { mutableStateOf<(() -> Unit)?>(null) }
-    val writePermissionLauncher = rememberLauncherForActivityResult(
-        contract = ActivityResultContracts.RequestPermission(),
-    ) { granted ->
-        if (granted) pendingWrite?.invoke()
-        pendingWrite = null
-    }
-    val hasWritePermission = {
-        ContextCompat.checkSelfPermission(
-            context,
-            Manifest.permission.WRITE_CALENDAR,
-        ) == PackageManager.PERMISSION_GRANTED
-    }
-    val requireWrite: (() -> Unit) -> Unit = { action ->
-        if (hasWritePermission()) {
-            action()
-        } else {
-            pendingWrite = action
-            writePermissionLauncher.launch(Manifest.permission.WRITE_CALENDAR)
-        }
-    }
+    // upgrade in place and continues straight into the tapped action.
+    val requireWrite = rememberWriteGate()
     val onDeleteClick = { requireWrite { showDeleteDialog = true } }
     val onEditClick = { requireWrite(onEdit) }
     // Duplicate reads the loaded detail into a create form and hands it up; the
@@ -322,70 +289,6 @@ fun EventDetailScreen(
     }
 }
 
-/**
- * Delete confirmation. Recurring events choose between cancelling just the
- * tapped occurrence (default), truncating the series from it onwards, and
- * removing the whole series.
- */
-@Composable
-private fun DeleteEventDialog(
-    isRecurring: Boolean,
-    onConfirm: (RecurringWriteScope) -> Unit,
-    onDismiss: () -> Unit,
-) {
-    var scope by rememberSaveable { mutableStateOf(RecurringWriteScope.ThisEvent) }
-    AlertDialog(
-        onDismissRequest = onDismiss,
-        title = {
-            Text(
-                stringResource(
-                    if (isRecurring) R.string.event_delete_recurring_title
-                    else R.string.event_delete_title,
-                ),
-            )
-        },
-        text = {
-            if (isRecurring) {
-                Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
-                    OptionCard(
-                        label = stringResource(R.string.event_delete_option_occurrence),
-                        onClick = { scope = RecurringWriteScope.ThisEvent },
-                        selected = scope == RecurringWriteScope.ThisEvent,
-                    )
-                    OptionCard(
-                        label = stringResource(R.string.event_delete_option_following),
-                        onClick = { scope = RecurringWriteScope.ThisAndFollowing },
-                        selected = scope == RecurringWriteScope.ThisAndFollowing,
-                    )
-                    OptionCard(
-                        label = stringResource(R.string.event_delete_option_series),
-                        onClick = { scope = RecurringWriteScope.AllEvents },
-                        selected = scope == RecurringWriteScope.AllEvents,
-                    )
-                }
-            } else {
-                Text(stringResource(R.string.event_delete_body))
-            }
-        },
-        confirmButton = {
-            TextButton(
-                onClick = { onConfirm(if (isRecurring) scope else RecurringWriteScope.AllEvents) },
-            ) {
-                Text(
-                    text = stringResource(R.string.event_detail_delete),
-                    color = MaterialTheme.colorScheme.error,
-                )
-            }
-        },
-        dismissButton = {
-            TextButton(onClick = onDismiss) {
-                Text(stringResource(R.string.dialog_cancel))
-            }
-        },
-    )
-}
-
-
 @Composable
 private fun EventDetailContent(
     state: EventDetailUiState.Success,
@@ -905,12 +808,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
     }
 }

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

@@ -11,12 +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.ics.IcsWriter
-import de.jeanlucmakiola.calendula.domain.ics.toShareIcsEvent
-import de.jeanlucmakiola.calendula.domain.toEditForm
+import de.jeanlucmakiola.calendula.domain.toDuplicateForm
+import de.jeanlucmakiola.calendula.ui.common.deleteEvent
+import de.jeanlucmakiola.calendula.ui.common.stageEventShare
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.withContext
-import kotlin.time.Clock
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
@@ -113,14 +112,7 @@ class EventDetailViewModel @Inject constructor(
         viewModelScope.launch {
             _deleteState.value = DeleteUiState.Deleting
             _deleteState.value = try {
-                when (scope) {
-                    RecurringWriteScope.AllEvents ->
-                        repository.deleteEvent(target.eventId)
-                    RecurringWriteScope.ThisEvent ->
-                        repository.deleteOccurrence(target.eventId, target.beginMillis)
-                    RecurringWriteScope.ThisAndFollowing ->
-                        repository.deleteEventFromOccurrence(target.eventId, target.beginMillis)
-                }
+                repository.deleteEvent(target.eventId, target.beginMillis, scope)
                 DeleteUiState.Deleted
             } catch (e: CancellationException) {
                 throw e
@@ -144,40 +136,16 @@ class EventDetailViewModel @Inject constructor(
      */
     suspend fun shareUri(): Uri? {
         val detail = (state.value as? EventDetailUiState.Success)?.detail ?: return null
-        return runCatching {
-            withContext(io) {
-                val ics = IcsWriter().writeCalendar(
-                    events = listOf(detail.toShareIcsEvent()),
-                    dtStamp = Clock.System.now(),
-                )
-                icsExporter.stageShareFile(shareFileName(detail.instance.title), ics)
-            }
-        }.getOrNull()
+        return withContext(io) { icsExporter.stageEventShare(detail) }
     }
 
     /**
-     * Build a create form seeded from the open event so the user can save a
-     * copy as a new, independent event (#52). Returns null when nothing is
-     * loaded.
-     *
-     * The recurrence is dropped — a duplicate is a single event; anyone who
-     * wants a series can re-add one in the edit form that opens. The source
-     * calendar is kept only when it's writable, otherwise the id is cleared so
-     * the create resolves to the last-used/first-writable calendar — which lets
-     * a read-only event (a WebCal subscription, a birthday) be copied into an
-     * editable calendar. The occurrence's own times carry over unchanged.
+     * A create form seeded from the open event, to save a copy as a new event
+     * (#52) — see [toDuplicateForm]. Null when nothing is loaded.
      */
     fun duplicateForm(): EventForm? {
         val loaded = state.value as? EventDetailUiState.Success ?: return null
-        val detail = loaded.detail
-        return detail.toEditForm(
-            beginMillis = detail.instance.start.toEpochMilliseconds(),
-            endMillis = detail.instance.end.toEpochMilliseconds(),
-            zone = TimeZone.currentSystemDefault(),
-        ).copy(
-            rrule = null,
-            calendarId = detail.instance.calendarId.takeIf { loaded.canModify },
-        )
+        return loaded.detail.toDuplicateForm(loaded.canModify, TimeZone.currentSystemDefault())
     }
 
     private suspend fun loadDetail(target: Target): EventDetailUiState = try {
@@ -228,13 +196,3 @@ class EventDetailViewModel @Inject constructor(
         const val NO_OCCURRENCE_TIME: Long = Long.MIN_VALUE
     }
 }
-
-/** A filesystem-safe `.ics` file name from an event title (or a fallback). */
-private fun shareFileName(title: String): String {
-    val base = title.trim()
-        .replace(Regex("""[^\p{L}\p{Nd} _-]"""), "")
-        .replace(' ', '_')
-        .take(40)
-        .ifBlank { "event" }
-    return "$base.ics"
-}

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

@@ -116,10 +116,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 +165,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 +178,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 +187,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
@@ -662,9 +666,14 @@ private fun EventEditContent(
             },
         ) {
             Spacer(Modifier.height(4.dp))
+            val formZone = remember(form.timezone) { form.resolvedZone(TimeZone.currentSystemDefault()) }
+            val startAt = remember(form.start, form.startOffset, formZone) { form.startInstant(formZone) }
+            val endAt = remember(form.end, form.endOffset, formZone) { form.endInstant(formZone) }
             ScheduleRow(
                 label = stringResource(R.string.event_edit_starts),
                 dateTime = form.start,
+                instant = startAt,
+                zone = formZone,
                 isAllDay = form.isAllDay,
                 locale = locale,
                 onDateClick = { picker = PickerTarget.StartDate },
@@ -674,6 +683,8 @@ private fun EventEditContent(
             ScheduleRow(
                 label = stringResource(R.string.event_edit_ends),
                 dateTime = form.end,
+                instant = endAt,
+                zone = formZone,
                 isAllDay = form.isAllDay,
                 locale = locale,
                 onDateClick = { picker = PickerTarget.EndDate },
@@ -692,20 +703,14 @@ 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.
-            // 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())
-            }
-            localTimes?.let { (localStart, localEnd) ->
+            // leaving the user to do the offset arithmetic. Absent unless the
+            // event is pinned somewhere other than here.
+            if (form.isPinnedAwayFrom(TimeZone.currentSystemDefault())) {
                 Spacer(Modifier.height(2.dp))
                 Text(
                     text = stringResource(
                         R.string.event_edit_timezone_local_time,
-                        formatTimeRange(localStart, localEnd, locale),
+                        formatTimeRange(startAt, endAt, TimeZone.currentSystemDefault(), locale),
                     ),
                     style = MaterialTheme.typography.bodySmall,
                     color = MaterialTheme.colorScheme.onSurfaceVariant,
@@ -769,7 +774,7 @@ private fun EventEditContent(
                                 timeZoneOptionOf(
                                     id,
                                     locale,
-                                    at = form.start.toInstant(zone).toJavaInstant(),
+                                    at = form.startInstant(zone).toJavaInstant(),
                                     regionOf = ::icuTimeZoneRegion,
                                 )
                             }
@@ -2251,18 +2256,21 @@ 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"
+    fun format(at: Instant) = withRepeatedHourZone(
+        timeFormat.format(at.toLocalDateTime(zone).time.toJavaLocalTime()),
+        at,
+        zone,
+        locale,
+    )
+    return if (start == end) format(start) else "${format(start)} – ${format(end)}"
 }
 
 /**
@@ -2344,6 +2352,8 @@ private fun firstLineHeight(
 private fun ScheduleRow(
     label: String,
     dateTime: LocalDateTime,
+    instant: Instant,
+    zone: TimeZone,
     isAllDay: Boolean,
     locale: Locale,
     onDateClick: () -> Unit,
@@ -2386,7 +2396,7 @@ private fun ScheduleRow(
         )
         if (!isAllDay) {
             Text(
-                text = timeFormat.format(dateTime.time.toJavaLocalTime()),
+                text = withRepeatedHourZone(timeFormat.format(dateTime.time.toJavaLocalTime()), instant, zone, locale),
                 style = MaterialTheme.typography.titleMedium,
                 color = valueColor,
                 modifier = Modifier

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

@@ -19,6 +19,12 @@ import de.jeanlucmakiola.calendula.domain.EditSnapshot
 import de.jeanlucmakiola.calendula.domain.EventAttendee
 import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventForm
+import de.jeanlucmakiola.calendula.domain.endInstant
+import de.jeanlucmakiola.calendula.domain.resolveIn
+import de.jeanlucmakiola.calendula.domain.resolvedZone
+import de.jeanlucmakiola.calendula.domain.startInstant
+import de.jeanlucmakiola.calendula.domain.withEnd
+import de.jeanlucmakiola.calendula.domain.withTimes
 import de.jeanlucmakiola.calendula.domain.EventFormField
 import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
 import de.jeanlucmakiola.calendula.domain.isEventTarget
@@ -49,6 +55,7 @@ import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
+import kotlinx.datetime.offsetAt
 import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
 import kotlin.coroutines.cancellation.CancellationException
@@ -289,7 +296,11 @@ class EventEditViewModel @Inject constructor(
         EventEditUiState(
             form = resolved,
             calendars = pickerCalendars,
-            problems = if (local.showProblems) resolved.problems() else emptySet(),
+            problems = if (local.showProblems) {
+                resolved.problems(TimeZone.currentSystemDefault())
+            } else {
+                emptySet()
+            },
             saveState = local.saveState,
             visibleFields = visibleFields,
             hiddenFields = (offerableFields - visibleFields).sorted(),
@@ -331,20 +342,24 @@ class EventEditViewModel @Inject constructor(
         if (_form.value != null) return
         val zone = TimeZone.currentSystemDefault()
         val now = Clock.System.now()
-        val start = when {
+        val startAt = when {
             startMinutes != null ->
-                LocalDateTime(date, LocalTime(startMinutes / 60, startMinutes % 60))
+                LocalDateTime(date, LocalTime(startMinutes / 60, startMinutes % 60)).toInstant(zone)
             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)
+                Instant.fromEpochMilliseconds((now.toEpochMilliseconds() / hourMillis + 1) * hourMillis)
             }
-            else -> LocalDateTime(date, LocalTime(9, 0))
+            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
+        _form.value = EventForm(
+            calendarId = null,
+            start = startAt.toLocalDateTime(zone),
+            end = endAt.toLocalDateTime(zone),
+            startOffset = zone.offsetAt(startAt),
+            endOffset = zone.offsetAt(endAt),
+        )
         applyDefaultReminder()
         applyDefaultDuration()
     }
@@ -454,11 +469,10 @@ class EventEditViewModel @Inject constructor(
             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),
-                )
+                val zone = form.resolvedZone(TimeZone.currentSystemDefault())
+                val start = form.startInstant(zone)
+                form.withTimes(start, start + duration.minutes, zone)
             }
         }
     }
@@ -663,12 +677,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)) }
+        update { it.withEnd(LocalDateTime(date, it.end.time)) }
     }
 
     fun setEndTime(time: LocalTime) {
         _durationTouched.value = true
-        update { it.copy(end = LocalDateTime(it.end.date, time)) }
+        update { it.withEnd(LocalDateTime(it.end.date, time)) }
     }
 
     /**
@@ -681,7 +695,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(TimeZone.currentSystemDefault()).isNotEmpty()) {
             _showProblems.value = true
             return
         }
@@ -810,11 +824,13 @@ class EventEditViewModel @Inject constructor(
     }
 
     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)
+        val zone = form.resolvedZone(TimeZone.currentSystemDefault())
+        val duration = form.endInstant(zone) - form.startInstant(zone)
+        // A picked time can't say which pass of a repeated hour it means; only
+        // an unchanged start keeps its own (see [withEnd]).
+        val picked = transform(form.start)
+        val newStart = picked.resolveIn(zone, form.startOffset.takeIf { picked == form.start })
+        form.withTimes(newStart, newStart + duration, zone)
     }
 
     private inline fun update(block: (EventForm) -> EventForm) {

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

@@ -87,6 +87,7 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.compositionLocalOf
 import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
@@ -170,6 +171,7 @@ import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
 import de.jeanlucmakiola.calendula.ui.common.LocalDimCutoff
+import de.jeanlucmakiola.calendula.ui.common.isPastOn
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.inlineTimeLabel
@@ -197,13 +199,17 @@ import kotlinx.datetime.TimeZone
 import kotlinx.datetime.plus
 import kotlinx.datetime.YearMonth
 import kotlinx.datetime.toJavaLocalDate
-import kotlinx.datetime.toLocalDateTime
-import kotlin.time.Clock
 import kotlin.time.Instant
 import java.time.format.TextStyle as JavaTextStyle
 import java.util.Locale
 
 private val LocalTodayPulse = staticCompositionLocalOf { 0 }
+
+/** Live today for the pages, whose cached states may have been built before midnight (#373). */
+private val LocalMonthToday = compositionLocalOf<LocalDate?> { null }
+
+private fun MonthUiState.Success.withToday(today: LocalDate?): MonthUiState.Success =
+    if (today == null || today == this.today) this else copy(today = today)
 private val LocalOpenWeek = staticCompositionLocalOf<((LocalDate) -> Unit)?> { null }
 
 /** A brief push from today's full cell into its immediate neighbours. */
@@ -319,12 +325,7 @@ fun MonthScreen(
     }
     val dense = viewStyle == MonthViewStyle.Dense
 
-    // Today, from whichever state is driving; the clock only covers the first
-    // frame, before either has loaded.
-    val today = when {
-        scrolling -> (continuousState as? ContinuousMonthUiState.Success)?.today
-        else -> (state as? MonthUiState.Success)?.today
-    } ?: Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()).date
+    val today by viewModel.today.collectAsStateWithLifecycle()
 
     // The two scrolling styles index their items differently — Continuous by
     // month (which the week start can't move), Dense by week (which it can) — so
@@ -520,6 +521,7 @@ fun MonthScreen(
                 LocalDimCutoff provides dimCutoff,
                 LocalMonthDrag provides chipDrag,
                 LocalTodayPulse provides todayPulse,
+                LocalMonthToday provides today,
                 LocalOpenWeek provides onOpenWeek,
             ) {
                 if (scrolling) {
@@ -773,6 +775,7 @@ private fun MonthPage(
 ) {
     val ym = yearMonthForIndex(index)
     val state by remember(ym, weekStart) { monthState(ym, weekStart) }.collectAsStateWithLifecycle()
+    val today = LocalMonthToday.current
     val chipDrag = LocalMonthDrag.current
     val morph = LocalMonthMorph.current
     val viewMorph = LocalViewMorph.current
@@ -782,7 +785,7 @@ private fun MonthPage(
         LocalViewMorph provides viewMorph.takeIf { morphActive },
     ) {
         when (val s = state) {
-            is MonthUiState.Success -> page(index, s)
+            is MonthUiState.Success -> page(index, s.withToday(today))
             else -> loading()
         }
     }
@@ -1388,7 +1391,8 @@ private fun SplitMonthContent(
             val ym = yearMonthForIndex(index)
             val pageState by remember(ym, weekStart) { monthState(ym, weekStart) }
                 .collectAsStateWithLifecycle()
-            val page = pageState as? MonthUiState.Success ?: return@HorizontalPager
+            val page = (pageState as? MonthUiState.Success)?.withToday(LocalMonthToday.current)
+                ?: return@HorizontalPager
             // Only the settled page carries the drag and the morph tags: its
             // neighbours repeat some of its dates and would claim them.
             val active = index == pagerState.settledPage
@@ -1937,7 +1941,7 @@ private fun SplitDots(
                 modifier = Modifier
                     .morphBounds(MonthMorphKey.Event(date, event.instanceId))
                     .size(SPLIT_DOT_SIZE)
-                    .alpha(if (dimCutoff != null && event.hasEnded(dimCutoff)) EventDimAlpha else 1f)
+                    .alpha(if (dimCutoff != null && event.isPastOn(date, dimCutoff)) EventDimAlpha else 1f)
                     .background(eventAccent(event.color, dark, soften), CircleShape),
             )
         }
@@ -1951,7 +1955,7 @@ private fun SplitDots(
                 color = MaterialTheme.colorScheme.onSurfaceVariant,
                 modifier = Modifier
                     .morphBounds(MonthMorphKey.Overflow(date))
-                    .alpha(if (allEnded(hidden, dimCutoff)) EventDimAlpha else 1f),
+                    .alpha(if (allEnded(hidden, date, dimCutoff)) EventDimAlpha else 1f),
             )
         }
     }
@@ -1994,7 +1998,7 @@ private fun SplitMonthAgendaPane(
                         day = day,
                         zone = state.zone,
                         position = positionOf(index, events.size),
-                        dimmed = dimCutoff != null && event.hasEnded(dimCutoff),
+                        dimmed = dimCutoff != null && event.isPastOn(day, dimCutoff),
                         modifier = animateItemMotion().morphEvent(ViewMorphKey.event(event, day)),
                         onClick = { onEventClick(event) },
                     )
@@ -2063,7 +2067,7 @@ internal fun SplitDayPane(
                             day = day,
                             zone = zone,
                             position = positionOf(index, dayEvents.size),
-                            dimmed = dimCutoff != null && event.hasEnded(dimCutoff),
+                            dimmed = dimCutoff != null && event.isPastOn(day, dimCutoff),
                             onClick = { onEventClick(event) },
                             // An event added to or removed from the day you are
                             // already looking at moves its neighbours rather
@@ -2539,6 +2543,7 @@ private fun MonthWeekRow(
                             }
                             OverflowDots(
                                 events = hiddenEvents,
+                                day = d,
                                 total = hidden,
                                 dark = dark,
                                 rowHeight = overflowRow,
@@ -2863,7 +2868,9 @@ private fun MonthBar(
 ) {
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
     val dimCutoff = LocalDimCutoff.current
-    val dimmed = dimCutoff != null && event.hasEnded(dimCutoff)
+    // A bar is one piece, so it dims once the last day it covers has passed.
+    val dimmed = dimCutoff != null &&
+        (event.hasEnded(dimCutoff) || days?.let { event.isPastOn(it.last(), dimCutoff) } == true)
     val paint = eventPaint(event, dark)
     // The same title/secondary ink pairing the week and day blocks use, with
     // the time on the quieter half.
@@ -2916,6 +2923,7 @@ private fun MonthBar(
 @Composable
 private fun OverflowDots(
     events: List<EventInstance>,
+    day: LocalDate,
     total: Int,
     dark: Boolean,
     rowHeight: Dp,
@@ -2934,7 +2942,7 @@ private fun OverflowDots(
             Box(
                 modifier = Modifier
                     .size(OVERFLOW_DOT_SIZE)
-                    .alpha(if (allEnded(byColor.getValue(argb), dimCutoff)) EventDimAlpha else 1f)
+                    .alpha(if (allEnded(byColor.getValue(argb), day, dimCutoff)) EventDimAlpha else 1f)
                     .background(eventAccent(argb, dark, soften), CircleShape),
             )
         }
@@ -2944,15 +2952,15 @@ private fun OverflowDots(
                 text = "+$extra",
                 style = MaterialTheme.typography.labelSmall,
                 color = MaterialTheme.colorScheme.onSurfaceVariant,
-                modifier = Modifier.alpha(if (allEnded(events, dimCutoff)) EventDimAlpha else 1f),
+                modifier = Modifier.alpha(if (allEnded(events, day, dimCutoff)) EventDimAlpha else 1f),
             )
         }
     }
 }
 
-/** True when dimming is on and every one of [events] is already over. */
-private fun allEnded(events: List<EventInstance>, dimCutoff: Instant?): Boolean =
-    dimCutoff != null && events.isNotEmpty() && events.all { it.hasEnded(dimCutoff) }
+/** True when dimming is on and every one of [events] is already over on [day]. */
+private fun allEnded(events: List<EventInstance>, day: LocalDate, dimCutoff: Instant?): Boolean =
+    dimCutoff != null && events.isNotEmpty() && events.all { it.isPastOn(day, dimCutoff) }
 
 @Composable
 private fun MonthGridLoading() {

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

@@ -7,6 +7,8 @@ import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.firstDayOfWeek
+import de.jeanlucmakiola.calendula.data.time.TodaySource
+import de.jeanlucmakiola.calendula.data.time.currentDate
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
@@ -45,7 +47,6 @@ import kotlinx.datetime.minus
 import kotlinx.datetime.plus
 import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
-import kotlin.time.Clock
 import kotlin.time.Instant
 import javax.inject.Inject
 
@@ -57,6 +58,7 @@ private const val MONTH_CACHE_SPAN = 2
 class MonthViewModel @Inject constructor(
     private val repository: CalendarRepository,
     settingsPrefs: SettingsPrefs,
+    todaySource: TodaySource,
     @IoDispatcher private val io: CoroutineDispatcher,
 ) : ViewModel() {
 
@@ -90,7 +92,18 @@ class MonthViewModel @Inject constructor(
         )
 
     private val todayDate: LocalDate
-        get() = Clock.System.now().toLocalDateTime(zone).date
+        get() = currentDate()
+
+    private var lastToday = todayDate
+
+    /** Today, kept current across midnight so a grid left open doesn't mark yesterday (#373). */
+    val today: StateFlow<LocalDate> = todaySource.today
+        .onEach { date ->
+            val old = lastToday
+            lastToday = date
+            if (old != date) followToday(old, date)
+        }
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000L), todayDate)
 
     private val _month = MutableStateFlow(YearMonth(todayDate.year, todayDate.month))
     val month: StateFlow<YearMonth> = _month
@@ -139,8 +152,9 @@ class MonthViewModel @Inject constructor(
         combine(
             repository.calendars(),
             repository.instances(monthGridRange(ym, ws, zone)),
-        ) { calendars, instances ->
-            buildState(ym, ws, calendars, instances)
+            today,
+        ) { calendars, instances, today ->
+            buildState(ym, ws, calendars, instances, today)
         }
             .catch { emit(MonthUiState.Failure(FailureReason.ProviderUnavailable)) }
             .flowOn(io)
@@ -211,8 +225,9 @@ class MonthViewModel @Inject constructor(
                 combine(
                     repository.calendars(),
                     repository.instances(range),
-                ) { calendars, instances ->
-                    buildContinuousState(window, ws, style, calendars, instances)
+                    today,
+                ) { calendars, instances, today ->
+                    buildContinuousState(window, ws, style, calendars, instances, today)
                 }
             }
             // A load landing is the cue to reach further out. Widening from here
@@ -257,6 +272,7 @@ class MonthViewModel @Inject constructor(
         style: MonthViewStyle,
         calendars: List<CalendarSource>,
         instances: List<EventInstance>,
+        today: LocalDate,
     ): ContinuousMonthUiState {
         calendarListFailure(calendars)?.let { return ContinuousMonthUiState.Failure(it) }
         // Bucketed once for the whole window: a row then takes the handful of
@@ -283,7 +299,7 @@ class MonthViewModel @Inject constructor(
             emptyMap()
         }
         return ContinuousMonthUiState.Success(
-            today = todayDate,
+            today = today,
             monthsByIndex = months,
             weeksByIndex = weeks,
             weekStart = weekStart,
@@ -333,6 +349,18 @@ class MonthViewModel @Inject constructor(
         _selectedDate.value = null
     }
 
+    /**
+     * The date rolled over from [old] to [new]. A paged grid still on [old]'s
+     * month moves on to [new]'s and drops the day picked yesterday; one browsed
+     * elsewhere stays put. The scrolling styles only repaint the today marker.
+     */
+    private fun followToday(old: LocalDate, new: LocalDate) {
+        if (viewStyle.value.isScrolling) return
+        if (_month.value != YearMonth(old.year, old.month)) return
+        _month.value = YearMonth(new.year, new.month)
+        _selectedDate.value = null
+    }
+
     /**
      * Track [_month] to the month a scrolling style is showing. Those styles
      * navigate by scroll position and never set [_month] themselves, so it would
@@ -358,12 +386,13 @@ class MonthViewModel @Inject constructor(
         weekStart: DayOfWeek,
         calendars: List<CalendarSource>,
         instances: List<EventInstance>,
+        today: LocalDate,
     ): MonthUiState {
         calendarListFailure(calendars)?.let { return MonthUiState.Failure(it) }
         val weeks = layoutMonthWeeks(ym, weekStart, instances, zone)
         return MonthUiState.Success(
             month = ym,
-            today = todayDate,
+            today = today,
             weeks = weeks,
             instancesByDay = instancesByDay(weeks.flatMap { it.days }, instances, zone),
             zone = zone,

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

@@ -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
@@ -59,11 +60,28 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.snapshotFlow
+import androidx.activity.compose.BackHandler
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.platform.LocalHapticFeedback
+import androidx.compose.ui.zIndex
+import androidx.compose.ui.geometry.Offset
+import de.jeanlucmakiola.calendula.ui.common.PickUp
+import de.jeanlucmakiola.calendula.ui.common.SelectionBarClearance
+import de.jeanlucmakiola.calendula.ui.common.ResizeEdge
+import de.jeanlucmakiola.calendula.ui.common.ResizeHandle
+import de.jeanlucmakiola.calendula.ui.common.ResizeHandleTarget
+import de.jeanlucmakiola.calendula.ui.common.TimelineResizeDrop
+import de.jeanlucmakiola.calendula.ui.common.eventAccent
+import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
+import de.jeanlucmakiola.calendula.ui.common.PublishSelection
+import de.jeanlucmakiola.calendula.ui.common.eventSelectAllowed
+import de.jeanlucmakiola.calendula.ui.common.selectionLift
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.BiasAlignment
 import androidx.compose.ui.Modifier
 import de.jeanlucmakiola.calendula.ui.common.LocalViewMorph
 import de.jeanlucmakiola.calendula.ui.common.StayPut
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.withTimeoutOrNull
 import kotlinx.coroutines.flow.first
 import androidx.compose.runtime.withFrameNanos
@@ -79,6 +97,7 @@ import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.animation.core.animateFloatAsState
 import androidx.compose.ui.layout.layout
 import androidx.compose.ui.graphics.RectangleShape
 import androidx.compose.ui.input.pointer.pointerInput
@@ -98,7 +117,6 @@ import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.domain.hasEnded
 import de.jeanlucmakiola.calendula.ui.common.LocalChipGround
 import de.jeanlucmakiola.calendula.ui.common.eventPaint
 import de.jeanlucmakiola.calendula.ui.common.eventSurface
@@ -135,6 +153,7 @@ import de.jeanlucmakiola.calendula.ui.common.rememberEventDragSource
 import de.jeanlucmakiola.calendula.ui.common.rememberTimelineDragController
 import de.jeanlucmakiola.calendula.ui.common.startInstant
 import de.jeanlucmakiola.calendula.ui.common.LocalDimCutoff
+import de.jeanlucmakiola.calendula.ui.common.isPastOn
 import de.jeanlucmakiola.calendula.ui.common.EventChipShape
 import de.jeanlucmakiola.calendula.ui.common.trimmedLines
 import de.jeanlucmakiola.calendula.ui.common.NowLine
@@ -281,6 +300,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
 
@@ -417,7 +442,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 = viewModel.zone
     val today by remember(zone) { derivedStateOf { nowState.value.toLocalDateTime(zone).date } }
     val isOnCurrentWeek = state !is WeekUiState.Success || (today >= weekStart && today <= weekEnd)
 
@@ -458,9 +484,13 @@ private fun PagedTimelineScreen(
     )
 
     ScreenBody(modifier = modifier) { innerPadding ->
-        CompositionLocalProvider(LocalDimCutoff provides dimCutoff) {
+        CompositionLocalProvider(
+            LocalDimCutoff provides dimCutoff,
+            LocalTimelineZone provides viewModel.zone,
+        ) {
             WeekContent(
                 state = state,
+                today = today,
                 pagerState = pagerState,
                 grid = grid,
                 kind = kind,
@@ -482,6 +512,7 @@ private fun PagedTimelineScreen(
 @Composable
 private fun WeekContent(
     state: WeekUiState,
+    today: LocalDate,
     pagerState: PagerState,
     grid: PageGrid,
     kind: TimelineKind,
@@ -507,8 +538,16 @@ private fun WeekContent(
     // inside the outgoing page.
     val dragController = rememberTimelineDragController()
     val move = LocalEventMove.current
-    val zone = remember { TimeZone.currentSystemDefault() }
+    val zone = LocalTimelineZone.current
     val onDrop: (TimelineDrop) -> Unit = { 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,
+            )
+        }
         move?.move(
             MoveRequest(
                 eventId = drop.event.eventId,
@@ -519,6 +558,51 @@ private fun WeekContent(
         )
     }
 
+    // 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,
+        )
+        move?.move(
+            MoveRequest(
+                eventId = drop.event.eventId,
+                beginMillis = drop.event.start.toEpochMilliseconds(),
+                endMillis = drop.event.end.toEpochMilliseconds(),
+                target = MoveTarget.Span(drop.start, drop.end),
+            ),
+        )
+    }
+
+    // Selection (#141) ends on back, a page or view change, or any tap.
+    val selection = dragController.selection
+    PublishSelection(
+        event = selection?.event,
+        busy = dragController.isDragging,
+        compact = dragController.selectionCovered,
+        onDismiss = dragController::deselect,
+    )
+    BackHandler(enabled = selection != null) { dragController.deselect() }
+    LaunchedEffect(pagerState, dragController) {
+        snapshotFlow { pagerState.currentPage }.drop(1).collect { dragController.deselect() }
+    }
+    LaunchedEffect(morph != null) { if (morph != null) dragController.deselect() }
+    LaunchedEffect(selection, dragController.settling, dragController.isDragging, dragController.selectedCandidates.size) {
+        dragController.settleMovedSelection()
+    }
+    val orphaned = selection != null && dragController.selectedCandidates.isEmpty() &&
+        !dragController.isDragging && dragController.settling == null
+    LaunchedEffect(orphaned) {
+        if (!orphaned) return@LaunchedEffect
+        // A beat for a re-read to bring the event back under a new row.
+        delay(SELECTION_ORPHAN_GRACE_MILLIS)
+        dragController.deselect()
+    }
+    val openEvent: (EventInstance) -> Unit = { event ->
+        dragController.deselect()
+        onEventClick(event)
+    }
+
     Box(modifier = modifier) {
         CompositionLocalProvider(LocalOpeningTimeline provides timelineScroll) {
             // Loading and failure concern the provider as a whole, so they stand in
@@ -536,27 +620,29 @@ private fun WeekContent(
                     is WeekUiState.Success -> if (morph != null) {
                         TimelineMorphFrame(
                             morph = morph,
-                            today = s.today,
+                            today = today,
                             scrollState = scrollState,
                             dragController = dragController,
-                            onEventClick = onEventClick,
+                            onEventClick = openEvent,
                             onOpenDay = onOpenDay,
                             onCreateAt = onCreateAt,
                             onDrop = onDrop,
+                            onResize = onResize,
                         )
                     } else WeekPager(
                         pagerState = pagerState,
                         grid = grid,
                         kind = kind,
                         span = span,
-                        today = s.today,
+                        today = today,
                         initialStripHeight = handoffStrip ?: s.allDayStripHeight(),
                         scrollState = scrollState,
                         dragController = dragController,
-                        onEventClick = onEventClick,
+                        onEventClick = openEvent,
                         onOpenDay = onOpenDay,
                         onCreateAt = onCreateAt,
                         onDrop = onDrop,
+                        onResize = onResize,
                     )
                 }
             }
@@ -583,6 +669,7 @@ private fun WeekPager(
     onOpenDay: (LocalDate) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
     onDrop: (TimelineDrop) -> Unit,
+    onResize: (TimelineResizeDrop) -> Unit,
 ) {
     val stripHeights = remember { mutableStateMapOf<Int, Dp>() }
     val allDayHeight = pagedHeight(pagerState, stripHeights, initialStripHeight)
@@ -618,7 +705,10 @@ private fun WeekPager(
             }
             ViewMorphPage(active = morphPageActive(page, pagerState.settledPage)) {
                 WeekPage(
-                    state = loaded ?: empty,
+                    // A cached page may predate midnight; today comes off the clock (#373).
+                    state = remember(loaded, empty, today) {
+                        loaded?.takeIf { it.today != today }?.copy(today = today) ?: loaded ?: empty
+                    },
                     headerBias = kind.headerBias,
                     allDayHeight = allDayHeight,
                     scrollState = scrollState,
@@ -628,6 +718,7 @@ private fun WeekPager(
                     onOpenDay = onOpenDay,
                     onCreateAt = onCreateAt,
                     onDrop = onDrop,
+                    onResize = onResize,
                 )
             }
         }
@@ -662,6 +753,7 @@ private fun TimelineMorphFrame(
     onOpenDay: (LocalDate) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
     onDrop: (TimelineDrop) -> Unit,
+    onResize: (TimelineResizeDrop) -> Unit,
 ) {
     val fromState by morph.fromState.collectAsStateWithLifecycle()
     val toState by morph.toState.collectAsStateWithLifecycle()
@@ -717,6 +809,7 @@ private fun TimelineMorphFrame(
                 onOpenDay = onOpenDay,
                 onCreateAt = onCreateAt,
                 onDrop = onDrop,
+                onResize = onResize,
             )
         }
     }
@@ -810,6 +903,7 @@ internal fun WeekSuccess(
     onOpenDay: (LocalDate) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
     onDrop: (TimelineDrop) -> Unit,
+    onResize: (TimelineResizeDrop) -> Unit,
 ) {
     WeekFrame(
         weekStart = state.weekStart,
@@ -829,6 +923,7 @@ internal fun WeekSuccess(
             onOpenDay = onOpenDay,
             onCreateAt = onCreateAt,
             onDrop = onDrop,
+            onResize = onResize,
         )
     }
 }
@@ -851,6 +946,7 @@ private fun WeekPage(
     onOpenDay: (LocalDate) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
     onDrop: (TimelineDrop) -> Unit,
+    onResize: (TimelineResizeDrop) -> Unit,
 ) {
     val geometry = remember(state.weekStart, state.days.size) {
         ColumnGeometry.of(DaySpan(state.weekStart, state.days.size))
@@ -870,6 +966,7 @@ private fun WeekPage(
         onOpenDay = onOpenDay,
         onCreateAt = onCreateAt,
         onDrop = onDrop,
+        onResize = onResize,
     )
 }
 
@@ -893,6 +990,7 @@ private fun TimelinePageContent(
     onOpenDay: (LocalDate) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
     onDrop: (TimelineDrop) -> Unit,
+    onResize: (TimelineResizeDrop) -> Unit,
 ) {
     Column(modifier = Modifier.fillMaxSize()) {
         Column(
@@ -923,6 +1021,7 @@ private fun TimelinePageContent(
             onEventClick = onEventClick,
             onCreateAt = onCreateAt,
             onDrop = onDrop,
+            onResize = onResize,
         )
     }
 }
@@ -1071,6 +1170,7 @@ private fun AllDayStrip(
                     key(bar.event.eventId, bar.event.start) {
                         AllDayBar(
                             event = bar.event,
+                            lastDay = bar.toRange.endInclusive,
                             dark = dark,
                             onClick = { onEventClick(bar.event) },
                             modifier = Modifier
@@ -1106,13 +1206,15 @@ private fun AllDayStrip(
 @Composable
 private fun AllDayBar(
     event: EventInstance,
+    lastDay: LocalDate,
     dark: Boolean,
     onClick: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
     val dimCutoff = LocalDimCutoff.current
-    val dimmed = dimCutoff != null && event.hasEnded(dimCutoff)
+    // A bar is one piece, so it dims once the last day it covers here has passed.
+    val dimmed = dimCutoff != null && event.isPastOn(lastDay, dimCutoff)
     val paint = eventPaint(event, dark)
     Box(
         modifier = (if (dimmed) modifier.alpha(EventDimAlpha) else modifier)
@@ -1149,6 +1251,7 @@ private fun Timeline(
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
     onDrop: (TimelineDrop) -> Unit,
+    onResize: (TimelineResizeDrop) -> Unit,
 ) {
     val fullViewportHeight = remember(geometry) { intArrayOf(-1) }
     val dark = isSystemInDarkTheme()
@@ -1246,6 +1349,7 @@ private fun Timeline(
                     onEventClick = onEventClick,
                     onCreateAt = onCreateAt,
                     onDrop = onDrop,
+                    onResize = onResize,
                     scrollState = scrollState,
                     modifier = Modifier.fillMaxHeight(),
                 )
@@ -1268,6 +1372,7 @@ private fun DayColumnCard(
     onEventClick: (EventInstance) -> Unit,
     onCreateAt: (LocalDate, Int) -> Unit,
     onDrop: (TimelineDrop) -> Unit,
+    onResize: (TimelineResizeDrop) -> Unit,
     scrollState: ScrollState,
     modifier: Modifier = Modifier,
 ) {
@@ -1275,7 +1380,7 @@ 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
     // Tells a settled drop when this column has caught up with it.
     LaunchedEffect(blocks, dragController.settling) {
         dragController.noteGrid(date, blocks)
@@ -1316,6 +1421,10 @@ private fun DayColumnCard(
                 // blocks are consumed by their own handler first. Snaps to hour.
                 .pointerInput(date) {
                     detectTapGestures { offset ->
+                        if (dragController.selection != null) {
+                            dragController.deselect()
+                            return@detectTapGestures
+                        }
                         if (currentEdges.value.tap(offset.y)) return@detectTapGestures
                         currentOnCreateAt.value(
                             date,
@@ -1375,6 +1484,7 @@ private fun DayColumnCard(
                         dragController = dragController,
                         onClick = { onEventClick(block.event) },
                         onDrop = onDrop,
+                        onResize = onResize,
                         modifier = Modifier
                             .laneSlot(place)
                             .offset(y = place.y + topInset)
@@ -1419,13 +1529,16 @@ private fun EventBlock(
     dragController: TimelineDragController,
     onClick: () -> Unit,
     onDrop: (TimelineDrop) -> Unit,
+    onResize: (TimelineResizeDrop) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     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
@@ -1439,7 +1552,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
@@ -1469,72 +1582,173 @@ private fun EventBlock(
         if (showTime) metrics.timeLine else 0.dp
     val timeMaxLines = if (showTime) blockTimeLines(shownTime, textWidth, spare) else 1
     val dimCutoff = LocalDimCutoff.current
-    val dimmed = dimCutoff != null && block.event.hasEnded(dimCutoff)
-    val zone = remember { TimeZone.currentSystemDefault() }
+    val dimmed = dimCutoff != null && block.event.isPastOn(date, dimCutoff)
     val moveAction = eventMoveAction(block.event)
     val draggable = eventDragAllowed(block.event)
+    val selectable = eventSelectAllowed()
+    val selected = dragController.isSelected(block)
+    val haptics = LocalHapticFeedback.current
     // The drop takes this offset back off, so a tail clipped at midnight lands
     // where the event's own start belongs (#253).
     val clipOffset = remember(block, date, zone) { block.clipOffsetMinutes(date, zone) }
     val shape = remember(cuts) { timedBlockShape(cuts.top, cuts.bottom) }
     val topInsetPx = with(density) { topInset.toPx() }
+    // Long press (#141): move to drag, let go to select; selected blocks drag at once.
     val dragModifier = rememberEventDragSource(
-        enabled = draggable,
+        enabled = selectable,
         key = block.event.instanceId,
+        immediate = selected && draggable,
         onPickUp = { pointer, blockRoot, _ ->
-            dragController.begin(
-                block = block,
-                clipOffsetMin = clipOffset,
-                titleLines = if (showTitle) titleMaxLines else 0,
-                pointerInRoot = pointer,
-                // Measured off the block's placement rather than off where the
-                // hour grid seats it: the copy is drawn from that placement and
-                // re-seated the same half-gap down (#267).
-                blockInRoot = blockRoot.copy(y = blockRoot.y - topInsetPx),
-            )
+            if (draggable) {
+                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
+                    // hour grid seats it: the copy is drawn from that placement and
+                    // re-seated the same half-gap down (#267).
+                    blockInRoot = blockRoot.copy(y = blockRoot.y - topInsetPx),
+                )
+                PickUp.Drag
+            } else {
+                haptics.performHapticFeedback(HapticFeedbackType.LongPress)
+                dragController.select(block.event)
+                PickUp.Hold
+            }
         },
         onMove = dragController::move,
         onDrop = { dragController.finish()?.let(onDrop) },
         onCancel = dragController::cancel,
+        onRelease = { dragController.select(block.event, fromLift = draggable) },
     )
     val lifted = draggable && dragController.ghosts(block)
-    val ghost = ghostAlpha(lifted)
+    // 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 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() }
+    val barClearancePx = with(density) { SelectionBarClearance.toPx() }
+    val tracksBar = selected && !cuts.bottom
+    // Not while its own write is pending: it still shows the old times.
+    LaunchedEffect(selected, block.event, lifted) {
+        if (selected && !lifted) dragController.adoptSelection(block)
+    }
+    // Kept composed while hidden: removing them would cancel their own resize.
+    DisposableEffect(selected, block.event) {
+        if (selected) dragController.noteSelectedBlock(block.event, true)
+        onDispose { if (selected) dragController.noteSelectedBlock(block.event, false) }
+    }
+    val showHandles = selected && draggable
+    val handlesShown = !lifted && !dragController.isDragging
     Box(
-        modifier = (if (dimmed) modifier.alpha(EventDimAlpha) else modifier)
+        modifier = (if (dimmed && !selected) modifier.alpha(EventDimAlpha) else modifier)
+            .zIndex(if (selected) 1f else 0f)
             // The source stays put as a ghost while its floating copy travels.
             .then(if (ghost < 1f) Modifier.alpha(ghost) else Modifier)
-            .eventSurface(paint, shape, cuts)
-            .clickable(onClick = onClick)
-            // After clickable, so it is the inner node and wins the main pass;
-            // the tap still works, since a drag consumes the up.
-            .then(dragModifier)
-            .padding(horizontal = BLOCK_TEXT_PADDING, vertical = metrics.inset)
-            .semantics {
-                contentDescription = "$title, $timeLabel"
-                if (moveAction != null) customActions = listOf(moveAction)
-            },
+            .then(if (raise > 0f) Modifier.selectionLift(raise, shape) else Modifier)
+            .then(
+                if (tracksBar) {
+                    Modifier.onGloballyPositioned {
+                        dragController.noteSelectedBottom(it, revealExtraPx, barClearancePx)
+                    }
+                } else {
+                    Modifier
+                },
+            ),
     ) {
-        Column {
-            if (showTitle) {
-                BlockTitle(
-                    title = title,
-                    maxLines = titleMaxLines,
-                    color = paint.titleInk,
-                    textDecoration = paint.decoration,
-                    fontWeight = paint.titleWeight,
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .eventSurface(paint, shape, cuts)
+                .clickable(onClick = onClick)
+                // After clickable, so it is the inner node and wins the main pass;
+                // the tap still works, since a drag consumes the up.
+                .then(dragModifier)
+                .padding(horizontal = BLOCK_TEXT_PADDING, vertical = metrics.inset)
+                .semantics {
+                    contentDescription = "$title, $timeLabel"
+                    if (moveAction != null) customActions = listOf(moveAction)
+                },
+        ) {
+            Column {
+                if (showTitle) {
+                    BlockTitle(
+                        title = title,
+                        maxLines = titleMaxLines,
+                        color = paint.titleInk,
+                        textDecoration = paint.decoration,
+                        fontWeight = paint.titleWeight,
+                    )
+                }
+                if (showTime) {
+                    BlockTimeLabel(
+                        label = shownTime,
+                        color = paint.secondaryInk,
+                        maxLines = timeMaxLines,
+                    )
+                }
+            }
+        }
+        if (showHandles) {
+            val accent = eventAccent(block.event.color, dark, LocalSoftenColors.current)
+            val handleLines = if (showTitle) titleMaxLines else 0
+            val begin = { edge: ResizeEdge ->
+                { pointer: Offset ->
+                    dragController.beginResize(block, edge, zone, handleLines, pointer)
+                }
+            }
+            val end = { dragController.finishResize(zone)?.let(onResize) }
+            val handleIn by animateFloatAsState(
+                targetValue = if (handlesShown) 1f else 0f,
+                animationSpec = MaterialTheme.motionScheme.fastSpatialSpec(),
+                label = "handles",
+            )
+            val handleAlpha = Modifier.graphicsLayer {
+                alpha = handleIn.coerceIn(0f, 1f)
+                scaleX = 0.5f + 0.5f * handleIn
+                scaleY = 0.5f + 0.5f * handleIn
+            }
+            if (!cuts.top) {
+                ResizeHandle(
+                    color = accent,
+                    enabled = handlesShown,
+                    onStart = begin(ResizeEdge.Top),
+                    onMove = dragController::move,
+                    onEnd = { end() },
+                    onCancel = dragController::cancel,
+                    modifier = Modifier
+                        .align(Alignment.TopStart)
+                        .offset(x = HANDLE_INSET - ResizeHandleTarget / 2, y = -ResizeHandleTarget / 2)
+                        .then(handleAlpha),
                 )
             }
-            if (showTime) {
-                BlockTimeLabel(
-                    label = shownTime,
-                    color = paint.secondaryInk,
-                    maxLines = timeMaxLines,
+            if (!cuts.bottom) {
+                ResizeHandle(
+                    color = accent,
+                    enabled = handlesShown,
+                    onStart = begin(ResizeEdge.Bottom),
+                    onMove = dragController::move,
+                    onEnd = { end() },
+                    onCancel = dragController::cancel,
+                    modifier = Modifier
+                        .align(Alignment.BottomEnd)
+                        .offset(x = ResizeHandleTarget / 2 - HANDLE_INSET, y = ResizeHandleTarget / 2)
+                        .then(handleAlpha),
                 )
             }
         }
     }
 }
 
+private const val SELECTION_ORPHAN_GRACE_MILLIS = 500L
+
+/** How far in from the block's side a resize handle's centre sits. */
+private val HANDLE_INSET = 16.dp
+
 private val SKELETON_HEADER_HEIGHT = 36.dp
 private val SKELETON_HEADER_PADDING = 8.dp
 

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

@@ -7,6 +7,8 @@ import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 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.currentDate
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.displayPriority
@@ -27,11 +29,13 @@ import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toJavaZoneId
 import kotlinx.datetime.atStartOfDayIn
 import kotlinx.datetime.atTime
 import kotlinx.datetime.daysUntil
@@ -40,7 +44,6 @@ import kotlinx.datetime.plus
 import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
 import java.util.Locale
-import kotlin.time.Clock
 import kotlin.time.Instant
 import javax.inject.Inject
 import kotlin.math.abs
@@ -73,12 +76,14 @@ fun positionOf(anchor: LocalDate, rule: (LocalDate) -> PageGrid): PagerPosition
 abstract class PagedTimelineViewModel(
     private val repository: CalendarRepository,
     settingsPrefs: SettingsPrefs,
+    todaySource: TodaySource,
     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 (#387). */
+    val zone: TimeZone = TimeZone.currentSystemDefault()
 
     /** Whether to fade events that have already finished (display concern only). */
     val dimCompletedEvents: StateFlow<Boolean> = settingsPrefs.dimCompletedEvents
@@ -89,7 +94,7 @@ abstract class PagedTimelineViewModel(
         )
 
     private val todayDate: LocalDate
-        get() = Clock.System.now().toLocalDateTime(zone).date
+        get() = currentDate()
 
     // A day on the visible page; the page itself comes from the grid, so a
     // settings change re-frames the same days instead of jumping.
@@ -103,6 +108,17 @@ abstract class PagedTimelineViewModel(
     val rule: StateFlow<(LocalDate) -> PageGrid> =
         gridRule.stateIn(viewModelScope, SharingStarted.Eagerly, initialRule)
 
+    private var lastToday = todayDate
+
+    /** Today, kept current across midnight so a page left open doesn't mark yesterday (#373). */
+    private val today: StateFlow<LocalDate> = todaySource.today
+        .onEach { date ->
+            val old = lastToday
+            lastToday = date
+            if (old != date) followToday(old, date)
+        }
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000L), todayDate)
+
     private val position: StateFlow<PagerPosition> =
         combine(_anchor, rule) { anchor, rule -> positionOf(anchor, rule) }
             .distinctUntilChanged()
@@ -141,8 +157,9 @@ abstract class PagedTimelineViewModel(
         combine(
             repository.calendars(),
             repository.instances(spanRange(span.start, span.count, zone)),
-        ) { calendars, instances ->
-            buildState(span, calendars, instances)
+            today,
+        ) { calendars, instances, today ->
+            buildState(span, calendars, instances, today)
         }
             .catch { emit(WeekUiState.Failure(FailureReason.ProviderUnavailable)) }
             .flowOn(io)
@@ -163,12 +180,20 @@ abstract class PagedTimelineViewModel(
     }
 
     fun goToToday() = jumpTo(todayDate)
+
+    /** The date rolled over; a page still showing [old] follows on to [new], one browsed elsewhere stays. */
+    private fun followToday(old: LocalDate, new: LocalDate) {
+        val anchor = _anchor.value
+        val grid = rule.value(anchor)
+        if (grid.pageFor(anchor) == grid.pageFor(old)) _anchor.value = new
+    }
     fun goToDate(date: LocalDate) = jumpTo(date)
 
     private fun buildState(
         span: DaySpan,
         calendars: List<CalendarSource>,
         instances: List<EventInstance>,
+        today: LocalDate,
     ): WeekUiState {
         calendarListFailure(calendars)?.let { return WeekUiState.Failure(it) }
         val days = (0 until span.count).map { span.start.plus(it, DateTimeUnit.DAY) }
@@ -176,7 +201,7 @@ abstract class PagedTimelineViewModel(
         val timed = instances.filterNot { it.isAllDay }
         return WeekUiState.Success(
             weekStart = span.start,
-            today = todayDate,
+            today = today,
             days = days,
             allDaySpans = layoutAllDay(allDay, days, zone),
             timedByDay = days.associateWith { day -> layoutDay(timed, day, zone) },
@@ -189,10 +214,12 @@ abstract class PagedTimelineViewModel(
 class WeekViewModel @Inject constructor(
     repository: CalendarRepository,
     settingsPrefs: SettingsPrefs,
+    todaySource: TodaySource,
     @IoDispatcher io: CoroutineDispatcher,
 ) : PagedTimelineViewModel(
     repository = repository,
     settingsPrefs = settingsPrefs,
+    todaySource = todaySource,
     io = io,
     gridRule = settingsPrefs.weekStart.map { pref ->
         val grid = WeekGrid(pref.resolveFirstDay(Locale.getDefault()))
@@ -211,10 +238,12 @@ class WeekViewModel @Inject constructor(
 class MultiDayViewModel @Inject constructor(
     repository: CalendarRepository,
     settingsPrefs: SettingsPrefs,
+    todaySource: TodaySource,
     @IoDispatcher io: CoroutineDispatcher,
 ) : PagedTimelineViewModel(
     repository = repository,
     settingsPrefs = settingsPrefs,
+    todaySource = todaySource,
     io = io,
     gridRule = settingsPrefs.multiDayCount.map { count ->
         { anchor: LocalDate -> DaysGrid.startingAt(anchor, count) }
@@ -227,10 +256,12 @@ class MultiDayViewModel @Inject constructor(
 class DayViewModel @Inject constructor(
     repository: CalendarRepository,
     settingsPrefs: SettingsPrefs,
+    todaySource: TodaySource,
     @IoDispatcher io: CoroutineDispatcher,
 ) : PagedTimelineViewModel(
     repository = repository,
     settingsPrefs = settingsPrefs,
+    todaySource = todaySource,
     io = io,
     gridRule = flowOf { _: LocalDate -> DayGrid },
     initialRule = { DayGrid },
@@ -302,6 +333,62 @@ 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. One ending in the fall-back hour's repeat can read as ending before
+ * it began: it starts in that hour's first pass, so it covers the hour's wall
+ * clock from its start to where the hour ends, and is drawn to there.
+ */
+internal fun wallClockEndMinutes(
+    startMin: Int,
+    start: Instant,
+    end: Instant,
+    day: LocalDate,
+    zone: TimeZone,
+): Int {
+    val wall = end.minutesPast(day, zone)
+    if (wall > startMin || end <= start) return maxOf(wall, startMin)
+    return repeatedHourEndMinutes(end, day, zone) ?: (startMin + (end - start).inWholeMinutes.toInt())
+}
+
+/**
+ * Where the repeated hour [end] falls in ends, as minutes past [day]'s midnight:
+ * the wall clock the zone fell back from (03:00 in Berlin). Null when the last
+ * change before [end] was no fall-back.
+ */
+private fun repeatedHourEndMinutes(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 local = transition.dateTimeBefore
+    val days = (local.toLocalDate().toEpochDay() - day.toEpochDays()).toInt()
+    return days * MINUTES_PER_DAY + local.toLocalTime().toSecondOfDay() / 60
+}
+
+/**
+ * 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) {
@@ -355,14 +442,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/java/de/jeanlucmakiola/calendula/ui/week/WeekViewPreview.kt

@@ -58,6 +58,7 @@ internal fun WeekViewPreview(
             onOpenDay = {},
             onCreateAt = { _, _ -> },
             onDrop = {},
+            onResize = {},
         )
     }
 }

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

@@ -97,6 +97,12 @@
     <string name="event_move_occurrence_only">Moving the whole series would change which days it falls on, so only this event can move.</string>
     <!-- %1$s is the new date and time, e.g. "Fri, 7 Aug, 09:00". -->
     <string name="event_move_done">Moved to %1$s</string>
+    <string name="event_resize_done">Changed to %1$s</string>
+    <string name="event_resize_recurring_title">Change recurring event</string>
+    <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_action_load_failed">Couldn\'t open the event</string>
     <string name="event_move_undo">Undo</string>
     <string name="event_move_undone">Move undone</string>
     <string name="event_move_failed">Couldn\'t move the event</string>

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

@@ -9,8 +9,10 @@ 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 {
 
@@ -1387,4 +1389,37 @@ 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(startOffset = UtcOffset(hours = 2), endOffset = 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(startOffset = UtcOffset(hours = 2), endOffset = UtcOffset(hours = 2))
+        val updated = original.copy(startOffset = UtcOffset(hours = 1), endOffset = 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(startOffset = UtcOffset(hours = 2), endOffset = UtcOffset(hours = 1))
+        assertThat(update(original, original.copy(title = "Renamed")))
+            .doesNotContainKey(CalendarContract.Events.DTSTART)
+    }
 }

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

@@ -19,25 +19,25 @@ class EventFormTest {
 
     @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 +47,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 +57,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 +66,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 +76,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)
     }
 
@@ -210,64 +210,23 @@ class EventFormTest {
     }
 
     @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)),
         )
         // 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 +384,43 @@ 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).isEqualTo(prefilled.end)
+        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).isLessThan(form.start)
+        assertThat(form.problems(berlin)).isEmpty()
+        // Read as the same pass at both ends, it really does end first.
+        assertThat(form.copy(startOffset = null, endOffset = null).problems(berlin))
+            .containsExactly(EventFormProblem.EndBeforeStart)
+    }
+
+    @Test
+    fun `an end picked by hand takes the earlier repeated hour`() {
+        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)).isEqualTo(form)
+        val picked = form.withEnd(LocalDateTime(LocalDate(2026, 10, 25), LocalTime(2, 50)))
+        assertThat(picked.endOffset).isNull()
+        assertThat(picked.endInstant(berlin)).isEqualTo(Instant.parse("2026-10-25T00:50:00Z"))
+    }
 }

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 {
 
@@ -88,8 +90,10 @@ class EventShiftTest {
 
     @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.toInstant(berlin)
+        val original = form().withTimes(start, form().end.toInstant(berlin), berlin)
+        assertThat(original.shiftedTo(start, berlin)).isEqualTo(original)
     }
 
     @Test
@@ -152,4 +156,80 @@ class EventShiftTest {
         val original = form()
         assertThat(original.shiftedByDays(0, berlin)).isEqualTo(original)
     }
+
+    @Test
+    fun `resizing sets each edge on its own`() {
+        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)
+
+        assertThat(resized.start).isEqualTo(original.start)
+        assertThat(resized.end).isEqualTo(LocalDateTime(LocalDate(2026, 6, 11), LocalTime(12, 30)))
+    }
+
+    @Test
+    fun `a resize past midnight carries the end onto the next day`() {
+        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)
+
+        assertThat(resized.end).isEqualTo(LocalDateTime(LocalDate(2026, 6, 12), LocalTime(1, 0)))
+    }
+
+    @Test
+    fun `a pinned event is resized in its own zone`() {
+        val original = form(
+            start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(9, 0)),
+            end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(10, 0)),
+            timezone = "America/New_York",
+        )
+        // "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)
+
+        assertThat(resized.start).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)
+
+        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).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))
+    }
 }

app/src/test/java/de/jeanlucmakiola/calendula/ui/agenda/AnchorTodayTest.kt

@@ -9,6 +9,7 @@ class AnchorTodayTest {
 
     private val today = LocalDate(2026, 6, 17)
     private val tomorrow = LocalDate(2026, 6, 18)
+    private val yesterday = LocalDate(2026, 6, 16)
 
     @Test
     fun `disabled leaves the days untouched even when today is absent`() {
@@ -36,4 +37,18 @@ class AnchorTodayTest {
         val days = listOf(AgendaDay(today, emptyList()), AgendaDay(tomorrow, emptyList()))
         assertThat(anchorTodayIfMissing(days, today, enabled = true)).isEqualTo(days)
     }
+
+    @Test
+    fun `enabled slots today in after loaded past days`() {
+        val days = listOf(AgendaDay(yesterday, emptyList()), AgendaDay(tomorrow, emptyList()))
+        val result = anchorTodayIfMissing(days, today, enabled = true)
+        assertThat(result.map { it.date }).containsExactly(yesterday, today, tomorrow).inOrder()
+    }
+
+    @Test
+    fun `enabled appends today after only past days`() {
+        val days = listOf(AgendaDay(yesterday, emptyList()))
+        val result = anchorTodayIfMissing(days, today, enabled = true)
+        assertThat(result.map { it.date }).containsExactly(yesterday, today).inOrder()
+    }
 }

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

@@ -0,0 +1,49 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.TimeZone
+import org.junit.jupiter.api.Test
+import kotlin.time.Instant
+
+class IsPastOnTest {
+
+    private val zone = TimeZone.of("Europe/Berlin")
+    private val today = LocalDate(2026, 10, 8)
+    private val now = Instant.parse("2026-10-08T12:00:00Z")
+
+    // All-day Oct 6–9, still running today.
+    private val summit = EventInstance(
+        instanceId = 1,
+        eventId = 1,
+        calendarId = 1,
+        title = "Summit",
+        start = Instant.parse("2026-10-06T00:00:00Z"),
+        end = Instant.parse("2026-10-10T00:00:00Z"),
+        isAllDay = true,
+        color = 0,
+        location = null,
+    )
+
+    @Test
+    fun `an ongoing multi-day event is past on the days already behind`() {
+        assertThat(summit.isPastOn(LocalDate(2026, 10, 7), now, zone)).isTrue()
+    }
+
+    @Test
+    fun `an ongoing multi-day event is not past today or later`() {
+        assertThat(summit.isPastOn(today, now, zone)).isFalse()
+        assertThat(summit.isPastOn(LocalDate(2026, 10, 9), now, zone)).isFalse()
+    }
+
+    @Test
+    fun `an event that ended earlier today is past`() {
+        val standup = summit.copy(
+            isAllDay = false,
+            start = Instant.parse("2026-10-08T07:00:00Z"),
+            end = Instant.parse("2026-10-08T07:15:00Z"),
+        )
+        assertThat(standup.isPastOn(today, now, zone)).isTrue()
+    }
+}

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

@@ -115,6 +115,17 @@ class RescheduleViewModelTest {
         target = MoveTarget.Start(Instant.fromEpochMilliseconds(beginMillis + 3_600_000L)),
     )
 
+    /** The end dragged an hour later, the start left where it is. */
+    private fun endOneHourLater() = MoveRequest(
+        eventId = 42L,
+        beginMillis = beginMillis,
+        endMillis = endMillis,
+        target = MoveTarget.Span(
+            Instant.fromEpochMilliseconds(beginMillis),
+            Instant.fromEpochMilliseconds(endMillis + 3_600_000L),
+        ),
+    )
+
     @Test
     fun `a one-off drop writes straight through with no scope prompt`(
         @TempDir tempDir: Path,
@@ -595,4 +606,82 @@ class RescheduleViewModelTest {
         assertThat(vm.outcome.value).isInstanceOf(MoveOutcome.Moved::class.java)
         assertThat(vm.abandoned.value).isEqualTo(0)
     }
+
+    @Test
+    fun `a resize writes the new length and reports both ends`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply { eventDetailResult = { detail() } }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(endOneHourLater())
+        advanceUntilIdle()
+
+        val (_, original, updated) = fake.updatedEvents.single()
+        assertThat(updated.start).isEqualTo(original.start)
+        assertThat(updated.end).isNotEqualTo(original.end)
+        val moved = vm.outcome.value as MoveOutcome.Moved
+        assertThat(moved.startMillis).isEqualTo(beginMillis)
+        assertThat(moved.endMillis).isEqualTo(endMillis + 3_600_000L)
+        assertThat(moved.undo).isNotNull()
+    }
+
+    @Test
+    fun `a moved event reports no end, so its chip keeps the move wording`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply { eventDetailResult = { detail() } }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(oneHourLater())
+        advanceUntilIdle()
+
+        assertThat((vm.outcome.value as MoveOutcome.Moved).endMillis).isNull()
+    }
+
+    @Test
+    fun `resizing a recurring event asks for the scope, as a resize`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY;BYDAY=MO") }
+        }
+        val vm = viewModel(tempDir, fake)
+
+        vm.move(endOneHourLater())
+        advanceUntilIdle()
+
+        assertThat(vm.scopePrompt.value)
+            .isEqualTo(MoveScopePrompt(occurrenceOnly = false, resize = true))
+        vm.moveWithScope(RecurringWriteScope.AllEvents)
+        advanceUntilIdle()
+        // The start stays put, so the rule needs no realigning.
+        assertThat(fake.updatedEvents.single().third.rrule).isEqualTo("FREQ=WEEKLY;BYDAY=MO")
+    }
+
+    @Test
+    fun `pulling a recurring event's start back over midnight resizes only the occurrence`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail(rrule = "FREQ=WEEKLY;BYDAY=MO") }
+        }
+        val vm = viewModel(tempDir, fake)
+        val sundayEvening = LocalDateTime(LocalDate(2026, 6, 7), LocalTime(22, 0))
+            .toInstant(TimeZone.currentSystemDefault())
+
+        vm.move(
+            MoveRequest(
+                eventId = 42L,
+                beginMillis = beginMillis,
+                endMillis = endMillis,
+                target = MoveTarget.Span(sundayEvening, Instant.fromEpochMilliseconds(endMillis)),
+            ),
+        )
+        advanceUntilIdle()
+
+        // Not a whole-day shift, so the series anchor can't follow.
+        assertThat(vm.scopePrompt.value)
+            .isEqualTo(MoveScopePrompt(occurrenceOnly = true, resize = true))
+    }
 }

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

@@ -0,0 +1,105 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import com.google.common.truth.Truth.assertThat
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toInstant
+import org.junit.jupiter.api.Test
+
+/** Where a dragged resize handle leaves an event's ends (#141). */
+class ResizedSpanTest {
+
+    // 09:00–10:00, in minutes from its day's midnight.
+    private val start = 9 * 60
+    private val end = 10 * 60
+
+    @Test
+    fun `the bottom edge snaps and leaves the start alone`() {
+        assertThat(resizedSpan(ResizeEdge.Bottom, start, end, 11 * 60 + 8f))
+            .isEqualTo(start to 11 * 60 + 15)
+    }
+
+    @Test
+    fun `the top edge snaps and leaves the end alone`() {
+        assertThat(resizedSpan(ResizeEdge.Top, start, end, 8 * 60 - 7f))
+            .isEqualTo(8 * 60 to end)
+    }
+
+    @Test
+    fun `an edge stops one snap step short of the other end`() {
+        assertThat(resizedSpan(ResizeEdge.Bottom, start, end, 7 * 60f))
+            .isEqualTo(start to start + DRAG_SNAP_MINUTES)
+        assertThat(resizedSpan(ResizeEdge.Top, start, end, 12 * 60f))
+            .isEqualTo(end - DRAG_SNAP_MINUTES to end)
+    }
+
+    @Test
+    fun `the bottom edge runs on past midnight`() {
+        assertThat(resizedSpan(ResizeEdge.Bottom, start, end, 24 * 60 + 90f))
+            .isEqualTo(start to 24 * 60 + 90)
+    }
+
+    @Test
+    fun `the top edge runs back into the day before`() {
+        assertThat(resizedSpan(ResizeEdge.Top, start, end, -60f))
+            .isEqualTo(-60 to end)
+    }
+
+    @Test
+    fun `wall clock minutes past either midnight land on the neighbouring day`() {
+        val zone = TimeZone.of("Europe/Berlin")
+        val day = LocalDate(2026, 10, 9)
+        assertThat(wallClockInstant(day, 24 * 60 + 30, zone))
+            .isEqualTo(LocalDateTime(LocalDate(2026, 10, 10), LocalTime(0, 30)).toInstant(zone))
+        assertThat(wallClockInstant(day, -30, zone))
+            .isEqualTo(LocalDateTime(LocalDate(2026, 10, 8), LocalTime(23, 30)).toInstant(zone))
+    }
+
+    @Test
+    fun `a finger drifting just over a column border keeps the edge on its day`() {
+        assertThat(stickyColumn(position = 3.1f, held = 2, lastIndex = 6)).isEqualTo(2)
+        assertThat(stickyColumn(position = 1.9f, held = 2, lastIndex = 6)).isEqualTo(2)
+    }
+
+    @Test
+    fun `a finger well into the next column takes the edge there`() {
+        assertThat(stickyColumn(position = 3.4f, held = 2, lastIndex = 6)).isEqualTo(3)
+        assertThat(stickyColumn(position = 1.6f, held = 2, lastIndex = 6)).isEqualTo(1)
+    }
+
+    @Test
+    fun `the first column is the one under the finger`() {
+        assertThat(stickyColumn(position = 4.9f, held = null, lastIndex = 6)).isEqualTo(4)
+        assertThat(stickyColumn(position = 9f, held = null, lastIndex = 6)).isEqualTo(6)
+    }
+
+    @Test
+    fun `a finger resting between two slots keeps the one it is on`() {
+        // 09:08 rounds to 09:15, but from 09:00 it is not far enough to leave.
+        assertThat(stickySnap(9 * 60 + 8f, held = 9 * 60)).isEqualTo(9 * 60)
+        assertThat(stickySnap(9 * 60 + 12f, held = 9 * 60)).isEqualTo(9 * 60 + 15)
+        assertThat(stickySnap(9 * 60 + 8f, held = null)).isEqualTo(9 * 60 + 15)
+    }
+
+    @Test
+    fun `an edge dragged into a day past the other end changes nothing`() {
+        // The start into the day after a same-day event ends.
+        assertThat(resizedSpan(ResizeEdge.Top, start, end, 24 * 60 + 9 * 60f, edgeDay = 1))
+            .isEqualTo(start to end)
+        // The end into the day before it starts.
+        assertThat(resizedSpan(ResizeEdge.Bottom, start, end, -60f, edgeDay = -1))
+            .isEqualTo(start to end)
+    }
+
+    @Test
+    fun `an edge in the event's own days still clamps against the other end`() {
+        assertThat(resizedSpan(ResizeEdge.Top, start, end, 12 * 60f, edgeDay = 0))
+            .isEqualTo(end - DRAG_SNAP_MINUTES to end)
+        // An overnight event's start may move anywhere up to its end's day.
+        val overnightEnd = 24 * 60 + 2 * 60
+        assertThat(resizedSpan(ResizeEdge.Top, start, overnightEnd, 24 * 60 + 60f, edgeDay = 1))
+            .isEqualTo(24 * 60 + 60 to overnightEnd)
+    }
+}

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

@@ -4,12 +4,15 @@ import com.google.common.truth.Truth.assertThat
 import de.jeanlucmakiola.calendula.domain.EventInstance
 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 +156,88 @@ 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, keepOffsetOf = 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, keepOffsetOf = july)).isEqualTo(first)
+        assertThat(wallClockInstant(fallBack, slot, brussels, keepOffsetOf = 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, keepOffsetOf = evening)).isEqualTo(first)
+    }
 }

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

@@ -190,5 +190,108 @@ 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)
 }

fastlane/metadata/android/ar/changelogs/2220599.txt

@@ -0,0 +1,2 @@
+إصلاحات
+• عند فتح التطبيق في صباح اليوم التالي يظهر اليوم الصحيح. كان عرض الشهر يعلّم الأمس على أنه اليوم ويُبقي اليوم الذي اخترته في المساء السابق محددًا. الآن تنتقل كل العروض إلى اليوم الجديد.

fastlane/metadata/android/be/changelogs/2220599.txt

@@ -0,0 +1,2 @@
+Выпраўлена
+• Калі адкрыць праграму наступнай раніцай, яна паказвае правільны дзень. Раней месяц адзначаў учорашні дзень як сённяшні і пакідаў выбраным дзень, які вы абралі ўвечары. Цяпер усе віды пераходзяць на новы дзень.

fastlane/metadata/android/cs-CZ/changelogs/2220599.txt

@@ -0,0 +1,2 @@
+Opraveno
+• Když aplikaci otevřete druhý den ráno, ukáže správný den. Měsíc dřív označoval včerejšek jako dnešek a nechával vybraný den, který jste zvolili večer předtím. Všechna zobrazení teď přejdou na nový den.

fastlane/metadata/android/de-DE/changelogs/2220599.txt

@@ -0,0 +1,2 @@
+Behoben
+• Wird die App am nächsten Morgen geöffnet, zeigt sie den richtigen Tag. Die Monatsansicht markierte bisher gestern als heute und ließ den am Vorabend gewählten Tag ausgewählt. Jetzt wechseln alle Ansichten auf den neuen Tag.

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

@@ -0,0 +1,2 @@
+Fixed
+• Reopening the app the next morning shows the right day. The month view used to mark yesterday as today and keep the day you picked the evening before selected. All views now move on to the new day.

fastlane/metadata/android/es-ES/changelogs/2220599.txt

@@ -0,0 +1,2 @@
+Corregido
+• Al abrir la app a la mañana siguiente, se muestra el día correcto. La vista de mes marcaba ayer como hoy y dejaba seleccionado el día que elegiste la noche anterior. Ahora todas las vistas pasan al nuevo día.

fastlane/metadata/android/fr-FR/changelogs/2220599.txt

@@ -0,0 +1,2 @@
+Corrigé
+• En ouvrant l'app le lendemain matin, vous voyez le bon jour. La vue mois marquait la veille comme aujourd'hui et gardait sélectionné le jour choisi la veille au soir. Toutes les vues passent maintenant au nouveau jour.

fastlane/metadata/android/hu-HU/changelogs/2220599.txt

@@ -0,0 +1,2 @@
+Javítva
+• Ha másnap reggel megnyitod az alkalmazást, a helyes napot mutatja. A havi nézet eddig a tegnapot jelölte mai napként, és kijelölve hagyta az előző este választott napot. Most minden nézet átvált az új napra.

fastlane/metadata/android/it-IT/changelogs/2220599.txt

@@ -0,0 +1,2 @@
+Corretto
+• Aprendo l'app la mattina dopo, viene mostrato il giorno giusto. La vista mese segnava ieri come oggi e lasciava selezionato il giorno scelto la sera prima. Ora tutte le viste passano al nuovo giorno.

fastlane/metadata/android/ja-JP/changelogs/2220599.txt

@@ -0,0 +1,2 @@
+修正
+• 翌朝アプリを開くと、正しい日が表示されるようになりました。これまで月表示では前日が今日として表示され、前の晩に選んだ日も選択されたままでした。今はすべての表示が新しい日に切り替わります。

fastlane/metadata/android/nl-NL/changelogs/2220599.txt

@@ -0,0 +1,2 @@
+Opgelost
+• Open je de app de volgende ochtend, dan zie je de juiste dag. De maandweergave markeerde gisteren als vandaag en hield de dag die je de avond ervoor koos geselecteerd. Alle weergaven gaan nu mee naar de nieuwe dag.

fastlane/metadata/android/pl-PL/changelogs/2220599.txt

@@ -0,0 +1,2 @@
+Poprawki
+• Po otwarciu aplikacji następnego ranka widać właściwy dzień. Widok miesiąca oznaczał wczoraj jako dziś i zostawiał zaznaczony dzień wybrany poprzedniego wieczoru. Teraz wszystkie widoki przechodzą na nowy dzień.

fastlane/metadata/android/pt-BR/changelogs/2220599.txt

@@ -0,0 +1,2 @@
+Corrigido
+• Ao abrir o app na manhã seguinte, aparece o dia certo. A visualização do mês marcava ontem como hoje e deixava selecionado o dia escolhido na noite anterior. Agora todas as visualizações passam para o novo dia.

fastlane/metadata/android/pt-PT/changelogs/2220599.txt

@@ -0,0 +1,2 @@
+Corrigido
+• Ao abrir a app na manhã seguinte, aparece o dia certo. A vista do mês marcava ontem como hoje e deixava selecionado o dia escolhido na noite anterior. Agora todas as vistas passam para o novo dia.

fastlane/metadata/android/ru-RU/changelogs/2220599.txt

@@ -0,0 +1,2 @@
+Исправлено
+• Если открыть приложение на следующее утро, оно показывает правильный день. Раньше месяц отмечал вчерашний день как сегодняшний и не снимал выделение с дня, выбранного накануне вечером. Теперь все виды переходят на новый день.

fastlane/metadata/android/sk/changelogs/2220599.txt

@@ -0,0 +1,2 @@
+Opravené
+• Keď aplikáciu otvoríte na druhý deň ráno, ukáže správny deň. Mesiac predtým označoval včerajšok ako dnešok a nechával vybraný deň, ktorý ste zvolili večer predtým. Všetky zobrazenia teraz prejdú na nový deň.

fastlane/metadata/android/zh-CN/changelogs/2220599.txt

@@ -0,0 +1,2 @@
+修复
+• 第二天早上打开应用时，会显示正确的日期。以前月视图会把昨天标为今天，并保留前一天晚上选中的日期。现在所有视图都会切换到新的一天。

gradle/libs.versions.toml

@@ -1,6 +1,6 @@
 [versions]
-agp = "9.2.1"
-kotlin = "2.3.21"
+agp = "9.4.1"
+kotlin = "2.4.20"
 ksp = "2.3.11"
 hilt = "2.60.1"
 coreKtx = "1.19.0"

gradle/wrapper/gradle-wrapper.properties

@@ -1,8 +1,10 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.1-bin.zip
-distributionSha256Sum=bafc141b619ad6350fd975fc903156dd5c151998cc8b058e8c1044ab5f7b031f
+distributionSha256Sum=bafd5ce9cfaea0fbccfdc8439a1ac42fbd4cd9c89dc9a988228d8a2639a58e6c
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.8.0-bin.zip
 networkTimeout=10000
+retries=0
+retryBackOffMs=500
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 #
-# Copyright © 2015-2021 the original authors.
+# Copyright © 2015 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -20,7 +20,7 @@
 
 ##############################################################################
 #
-#   Gradle start up script for POSIX generated by Gradle.
+#   gradlew start up script for POSIX generated by Gradle.
 #
 #   Important for running:
 #
@@ -29,7 +29,7 @@
 #       bash, then to run this script, type that shell name before the whole
 #       command line, like:
 #
-#           ksh Gradle
+#           ksh gradlew
 #
 #       Busybox and similar reduced shells will NOT work, because this script
 #       requires all of these POSIX shell features:
@@ -57,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/3d91ce3b8caaf77ad09f381f43615b715b53f72c/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -114,7 +114,6 @@ case "$( uname )" in                #(
   NONSTOP* )        nonstop=true ;;
 esac
 
-CLASSPATH="\\\"\\\""
 
 
 # Determine the Java command to use to start the JVM.
@@ -172,7 +171,6 @@ fi
 # For Cygwin or MSYS, switch paths to Windows format before running java
 if "$cygwin" || "$msys" ; then
     APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
 
     JAVACMD=$( cygpath --unix "$JAVACMD" )
 
@@ -212,7 +210,6 @@ DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
         -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
         "$@"
 

gradlew.bat

@@ -19,12 +19,39 @@
 @if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
-@rem  Gradle startup script for Windows
+@rem  gradlew startup script for Windows
 @rem
 @rem ##########################################################################
 
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
+@rem Set local scope for the variables, and ensure extensions are enabled
+setlocal EnableExtensions
+
+@rem Catch executions from older scripts and ensure they exit cleanly.
+@rem This can be removed once we can be reasonably confident that few people
+@rem will be migrating directly to this new wrapper.
+goto afterSafetyNet
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+goto exitWithErrorLevel
+:afterSafetyNet
 
 set DIRNAME=%~dp0
 if "%DIRNAME%"=="" set DIRNAME=.
@@ -45,13 +72,14 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute
 
-echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
+1>&2 echo.
+1>&2 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+1>&2 echo.
+1>&2 echo Please set the JAVA_HOME variable in your environment to match the
+1>&2 echo location of your Java installation.
 
-goto fail
+"%COMSPEC%" /c exit 1
+goto exitWithErrorLevel
 
 :findJavaFromJavaHome
 set JAVA_HOME=%JAVA_HOME:"=%
@@ -59,36 +87,26 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
+1>&2 echo.
+1>&2 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+1>&2 echo.
+1>&2 echo Please set the JAVA_HOME variable in your environment to match the
+1>&2 echo location of your Java installation.
 
-goto fail
+"%COMSPEC%" /c exit 1
+goto exitWithErrorLevel
 
 :execute
 @rem Setup the command line
 
-set CLASSPATH=
 
 
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
+@rem Execute gradlew
+@rem endlocal doesn't take effect until after the line is parsed and variables are expanded
+@rem which allows us to clear the local environment before executing the java command
+endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel & goto exitWithErrorLevel
 
-:end
-@rem End local scope for the variables with windows NT shell
-if %ERRORLEVEL% equ 0 goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-set EXIT_CODE=%ERRORLEVEL%
-if %EXIT_CODE% equ 0 set EXIT_CODE=1
-if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
-exit /b %EXIT_CODE%
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
+@rem This label must not be changed. We rely on old scripts being able to jump to this point.
+:exitWithErrorLevel
+@rem Use "%COMSPEC%" /c exit to allow operators to work properly in scripts
+"%COMSPEC%" /c exit %ERRORLEVEL%