fix(#517): review round 2 - back off failed pref reads, one derivation for the drawer's hidden-in-view set

The day view's top bar now shows the month name (e.g. "November", abbreviated when space is short, with the year outside the current year), the same as the week and 3-day views. Weekday and date already sit in the column header right below, so the old title repeated them.

Closes #501

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

.gitea/workflows/renovate.yml

@@ -33,7 +33,7 @@ jobs:
     # directly drops the docker-in-docker requirement entirely.
     # Full tag pinned; Renovate's github-actions manager keeps it bumped.
     container:
-      image: ghcr.io/renovatebot/renovate:43.232.0
+      image: ghcr.io/renovatebot/renovate:44.237.3
     steps:
       - name: Run Renovate
         run: renovate

CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.24.2] — 2026-11-13
+
+### Fixed
+- **Quick moves no longer get lost.** Dropping an event while an earlier move was still saving used to snap it back without a word. Drops now wait in line and are saved in order, and a moved event stays where you dropped it until the calendar shows it there. If an event changed before a drop could be saved, or the line is full, a message says so instead ([#494]).
+- **Undo after a run of moves** keeps the first move's Undo, and each failed move gets its own message rather than replacing the last one ([#494]).
+
+### Changed
+- **The day view's title names the month**, like the week and 3-day views. Weekday and date already sit in the column header below it ([#501]).
+- Library updates (kotlinx-datetime, AppCompat).
+
 ## [2.24.1] — 2026-11-12
 
 ### Added
@@ -1973,3 +1983,5 @@ automatically, with zero telemetry and no internet permission.
 [#489]: https://codeberg.org/jlmakiola/calendula/issues/489
 [#491]: https://codeberg.org/jlmakiola/calendula/issues/491
 [#493]: https://codeberg.org/jlmakiola/calendula/issues/493
+[#494]: https://codeberg.org/jlmakiola/calendula/issues/494
+[#501]: https://codeberg.org/jlmakiola/calendula/issues/501

Gemfile

@@ -7,4 +7,4 @@ source "https://rubygems.org"
 # Pinned exactly; Renovate's bundler manager keeps it bumped. No Gemfile.lock is
 # committed on purpose: this resolves an uploader's transitive deps, not the
 # app's, and none of it affects the reproducible release build.
-gem "fastlane", "2.237.0"
+gem "fastlane", "2.241.1"

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 = 2240199
-        versionName = "2.24.1"
+        versionCode = 2240299
+        versionName = "2.24.2"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }

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

@@ -165,6 +165,7 @@ class SettingsPrefs @Inject constructor(
     val autofocusEventTitle: Flow<Boolean> = prefs.flow(SettingsKeys.autofocusEventTitle)
     val defaultEventDurationMinutes: Flow<Int> = prefs.flow(SettingsKeys.defaultEventDurationMinutes)
     val perCalendarEventDuration: Flow<Map<Long, Int>> = prefs.flow(SettingsKeys.perCalendarEventDuration)
+    val perCalendarHiddenViews: Flow<Map<Long, Set<CalendarView>>> = prefs.flow(SettingsKeys.perCalendarHiddenViews)
     val remindersEnabled: Flow<Boolean> = prefs.flow(SettingsKeys.remindersEnabled)
     val allowColorOnUnsupportedCalendars: Flow<Boolean> =
         prefs.flow(SettingsKeys.allowColorOnUnsupportedCalendars)
@@ -271,6 +272,25 @@ class SettingsPrefs @Inject constructor(
         }
     }
 
+    /** Show [calendarId] in every view again (#270), e.g. once it is deleted. */
+    suspend fun clearCalendarHiddenViews(calendarId: Long) {
+        prefs.update(SettingsKeys.perCalendarHiddenViews) { current -> current - calendarId }
+    }
+
+    /** Hide or show [calendarId] in one [view], against the stored set rather than a snapshot of it. */
+    suspend fun setCalendarHiddenIn(calendarId: Long, view: CalendarView, hidden: Boolean) =
+        applyCalendarHiddenChanges(calendarId, mapOf(view to hidden))
+
+    /** Hide (true) or show (false) [calendarId] in each view of [changes], in one write; other views keep theirs. */
+    suspend fun applyCalendarHiddenChanges(calendarId: Long, changes: Map<CalendarView, Boolean>) {
+        if (changes.isEmpty()) return
+        prefs.update(SettingsKeys.perCalendarHiddenViews) { current ->
+            val views = current[calendarId].orEmpty()
+            val next = views + changes.filterValues { it }.keys - changes.filterValues { !it }.keys
+            current.withHiddenViews(calendarId, next)
+        }
+    }
+
     suspend fun setRemindersEnabled(enabled: Boolean) = prefs.set(SettingsKeys.remindersEnabled, enabled)
 
     suspend fun setAllowColorOnUnsupportedCalendars(enabled: Boolean) =
@@ -588,6 +608,15 @@ object SettingsKeys {
     val perCalendarEventDuration: Pref<Map<Long, Int>> =
         nullableStringPref("per_calendar_event_duration").map(::parseDurationOverrides) { it.toStoredDurations() }
 
+    /**
+     * Views each calendar is hidden in (#270): a display-only filter on top of
+     * `Calendars.VISIBLE` and the drawer's filter, so reminders and search never
+     * see it. A calendar absent shows in every view. Serialised as
+     * `id=Month,Agenda;id=Week`.
+     */
+    val perCalendarHiddenViews: Pref<Map<Long, Set<CalendarView>>> =
+        nullableStringPref("per_calendar_hidden_views").map(::parseHiddenViews) { it.toStoredHiddenViews() }
+
     /**
      * Whether Calendula posts reminder notifications (v1.4). On by default — for
      * users whose only calendar app this is, reminders are essential.
@@ -817,9 +846,11 @@ private fun parseFormFields(stored: String?): Set<EventFormField> = when (stored
 private fun parseViewOrder(stored: String?): List<CalendarView> =
     completeViewOrder(
         stored?.split(',').orEmpty()
-            .mapNotNull { name -> CalendarView.entries.firstOrNull { it.name == name.trim() } },
+            .mapNotNull { it.trim().toCalendarViewOrNull() },
     )
 
+private fun String.toCalendarViewOrNull(): CalendarView? = CalendarView.entries.firstOrNull { it.name == this }
+
 /** Parse the quick-switch config; "!"-prefixed names are disabled. */
 private fun parseQuickSwitch(stored: String?): QuickSwitchConfig {
     if (stored == null) return QuickSwitchConfig.Default
@@ -827,7 +858,7 @@ private fun parseQuickSwitch(stored: String?): QuickSwitchConfig {
         val token = raw.trim()
         val disabled = token.startsWith("!")
         val name = if (disabled) token.drop(1) else token
-        CalendarView.entries.firstOrNull { it.name == name }?.let { it to disabled }
+        name.toCalendarViewOrNull()?.let { it to disabled }
     }
     val order = completeViewOrder(parsed.map { it.first })
     // Only views explicitly stored disabled are excluded; anything appended
@@ -977,6 +1008,33 @@ private fun parseDurationOverrides(stored: String?): Map<Long, Int> =
         calendarId to minutes
     }.toMap()
 
+/**
+ * Parse the per-calendar hidden-views map (`id=View,View` entries joined by `;`).
+ * Unknown view names and malformed entries are dropped; an entry left with no
+ * views is dropped with them.
+ */
+internal fun parseHiddenViews(stored: String?): Map<Long, Set<CalendarView>> =
+    stored?.split(ENTRY_SEP).orEmpty().mapNotNull { entry ->
+        val parts = entry.split(KEY_VALUE_SEP)
+        if (parts.size != 2) return@mapNotNull null
+        val calendarId = parts[0].trim().toLongOrNull() ?: return@mapNotNull null
+        val views = parts[1].split(LIST_SEP)
+            .mapNotNullTo(mutableSetOf()) { it.trim().toCalendarViewOrNull() }
+        if (views.isEmpty()) null else calendarId to views
+    }.toMap()
+
+private fun Map<Long, Set<CalendarView>>.withHiddenViews(
+    calendarId: Long,
+    views: Set<CalendarView>,
+): Map<Long, Set<CalendarView>> = if (views.isEmpty()) this - calendarId else this + (calendarId to views)
+
+internal fun Map<Long, Set<CalendarView>>.toStoredHiddenViews(): String? =
+    entries.filter { it.value.isNotEmpty() }.sortedBy { it.key }
+        .joinToString(ENTRY_SEP) { (id, views) ->
+            "$id$KEY_VALUE_SEP" + views.sortedBy { it.ordinal }.joinToString(LIST_SEP) { it.name }
+        }
+        .ifEmpty { null }
+
 private fun Map<Long, Int>.toStoredDurations(): String =
     entries.sortedBy { it.key }.joinToString(ENTRY_SEP) { (id, minutes) ->
         "$id$KEY_VALUE_SEP$minutes"

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

@@ -309,3 +309,7 @@ enum class FailureReason {
     EventNotFound,
     Unknown,
 }
+
+/** [this] without the events of [hidden] calendars. */
+fun List<EventInstance>.withoutCalendars(hidden: Set<Long>): List<EventInstance> =
+    if (hidden.isEmpty()) this else filterNot { it.calendarId in hidden }

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

@@ -97,6 +97,8 @@ import de.jeanlucmakiola.calendula.ui.month.MonthScreen
 import de.jeanlucmakiola.calendula.ui.search.SearchScreen
 import de.jeanlucmakiola.calendula.ui.settings.SettingsScreen
 import de.jeanlucmakiola.calendula.ui.week.TimelineScreen
+import de.jeanlucmakiola.calendula.ui.filter.FilterViewModel
+import de.jeanlucmakiola.calendula.ui.filter.ViewCalendarsPicker
 import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.launch
@@ -192,10 +194,15 @@ fun CalendarHost(
     var detailKey by rememberSaveable { mutableStateOf<LongArray?>(null) }
     val onOpenDetail: (EventInstance) -> Unit = { event -> detailKey = event.occurrenceKey() }
 
+    // The drawer's "Hide in this view" picker (#517). It is its own window over
+    // everything here, so each external request below closes it first.
+    var showViewCalendars by rememberSaveable { mutableStateOf(false) }
+
     // A tapped reminder notification asks for a specific occurrence.
     val requestedDetailKey = requests.detailKey
     LaunchedEffect(requestedDetailKey) {
         if (requestedDetailKey != null) {
+            showViewCalendars = false
             detailKey = requestedDetailKey
             requests.detailKey = null
         }
@@ -211,6 +218,7 @@ fun CalendarHost(
     // top bar. Sits below the detail/edit overlays so tapping a result reveals
     // the detail on top and backing out returns to the results.
     var showSearch by rememberSaveable { mutableStateOf(false) }
+    val filterViewModel: FilterViewModel = hiltViewModel()
     val onOpenSearch = { showSearch = true }
 
     // Calendar manager (reached from Settings) — its own overlay so it slides
@@ -316,6 +324,7 @@ fun CalendarHost(
                 requests.importUri = null
                 return@LaunchedEffect
             }
+            showViewCalendars = false
             importUri = requestedImportUri
             importForceMany = false
             importSession++
@@ -333,6 +342,7 @@ fun CalendarHost(
                 requests.insert = null
                 return@LaunchedEffect
             }
+            showViewCalendars = false
             if (importForm == null) {
                 openImportForm(requestedInsert.form, requestedInsert.source, fromRequest = true)
             } else {
@@ -349,6 +359,7 @@ fun CalendarHost(
     fun dismissCoveringOverlays(keepCreate: Boolean = false) {
         showSettings = false
         showSearch = false
+        showViewCalendars = false
         showCalendars = false
         showBackup = false
         detailKey = null
@@ -485,9 +496,8 @@ fun CalendarHost(
             movableCalendarIds = movableCalendarIds,
             dragEnabled = dragToReschedule,
             move = { reschedule.move(it) },
-            inFlight = reschedule.inFlight,
+            drops = reschedule.drops,
             undoStarted = reschedule.undoStarted,
-            abandoned = reschedule.abandoned,
             edit = onEditEvent,
         )
     }
@@ -559,6 +569,15 @@ fun CalendarHost(
             // (#239); nothing else in the calendar surfaces navigates here.
             LocalManageCalendars provides remember { { showCalendars = true } },
         ) {
+        if (showViewCalendars) {
+            val filterState by filterViewModel.state.collectAsStateWithLifecycle()
+            ViewCalendarsPicker(
+                view = view,
+                state = filterState,
+                onSetHidden = { id, hidden -> filterViewModel.setHiddenIn(id, view, hidden) },
+                onDismiss = { showViewCalendars = false },
+            )
+        }
         // One drawer, top bar and FAB for every screen (#184): a switch changes
         // what they say, from what the screen on show publishes, rather than
         // swapping them for another screen's.
@@ -589,6 +608,10 @@ fun CalendarHost(
                         onOpenSettings()
                         switchScope.launch { drawerState.close() }
                     },
+                    onHideInView = {
+                        showViewCalendars = true
+                        switchScope.launch { drawerState.close() }
+                    },
                 )
             },
         ) {

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

@@ -15,6 +15,9 @@ import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.domain.calendarListFailure
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.calendarsHiddenIn
+import de.jeanlucmakiola.calendula.ui.common.instancesWithout
 import de.jeanlucmakiola.floret.android.stateWhileSubscribed
 import de.jeanlucmakiola.floret.di.IoDispatcher
 import kotlinx.coroutines.CoroutineDispatcher
@@ -46,6 +49,8 @@ class AgendaViewModel @Inject constructor(
     @IoDispatcher private val io: CoroutineDispatcher,
 ) : ViewModel() {
 
+    private val hiddenHere = settingsPrefs.perCalendarHiddenViews.calendarsHiddenIn(CalendarView.Agenda, viewModelScope)
+
     // The saved agenda range plus the range-bar visibility toggle.
     private val agendaSettings = combine(
         settingsPrefs.agendaScreenRange,
@@ -138,7 +143,7 @@ class AgendaViewModel @Inject constructor(
             )
             combine(
                 repository.calendars(),
-                repository.instances(window),
+                repository.instancesWithout(window, hiddenHere),
                 today,
             ) { calendars, instances, today ->
                 buildState(params, calendars, instances, today)

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

@@ -3,6 +3,7 @@ package de.jeanlucmakiola.calendula.ui.calendars
 import android.accounts.AccountManager
 import android.content.Context
 import android.content.Intent
+import android.icu.text.ListFormatter
 import android.provider.Settings
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.foundation.background
@@ -45,6 +46,7 @@ import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.saveable.rememberSaveable
@@ -54,6 +56,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalConfiguration
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.contentDescription
@@ -72,6 +75,10 @@ import de.jeanlucmakiola.calendula.domain.stateLabels
 import de.jeanlucmakiola.calendula.data.calendar.CalendarColorPalette
 import de.jeanlucmakiola.calendula.ui.common.AccountKey
 import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
+import de.jeanlucmakiola.calendula.ui.common.icon
+import de.jeanlucmakiola.calendula.ui.common.label
 import de.jeanlucmakiola.calendula.ui.common.CalendarVisibilitySwitch
 import de.jeanlucmakiola.calendula.ui.common.accountGroupTitle
 import de.jeanlucmakiola.calendula.ui.common.groupByAccount
@@ -92,6 +99,7 @@ import de.jeanlucmakiola.floret.identity.expandEnter
 import de.jeanlucmakiola.floret.identity.predictiveBack
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.InlineTextField
+import de.jeanlucmakiola.floret.components.MultiOptionPicker
 import de.jeanlucmakiola.floret.components.Position
 import androidx.compose.foundation.layout.aspectRatio
 import androidx.compose.foundation.layout.heightIn
@@ -130,14 +138,19 @@ fun CalendarsScreen(
     val calendars by viewModel.calendars.collectAsStateWithLifecycle()
     val deleteLockedIds by viewModel.deleteLockedCalendarIds.collectAsStateWithLifecycle()
     val error by viewModel.error.collectAsStateWithLifecycle()
+    val loadedHiddenViews by viewModel.hiddenViews.collectAsStateWithLifecycle()
+    val hiddenViews = loadedHiddenViews.orEmpty()
 
     // null = list; NEW_CALENDAR_ID = create; any other id = edit that calendar.
     // [editorSession] bumps on every open so the editor's field state resets for
     // a fresh open while still surviving configuration changes within one open.
     var editorId by rememberSaveable { mutableStateOf<Long?>(null) }
     var editorSession by rememberSaveable { mutableStateOf(0) }
+    // A synced calendar has no editor; tapping it opens its hidden-views picker.
+    var hidingId by rememberSaveable { mutableStateOf<Long?>(null) }
 
-    if (editorId != null) {
+    // The editor and the picker seed from the stored hidden views, so both wait for the first read.
+    if (editorId != null && loadedHiddenViews != null) {
         val editing = calendars.firstOrNull { it.id == editorId }
         CalendarEditor(
             sessionKey = editorSession,
@@ -145,13 +158,15 @@ fun CalendarsScreen(
             initialName = editing?.displayName.orEmpty(),
             initialColor = editing?.color ?: CalendarColorPalette.all.first(),
             initialDescription = editing?.description.orEmpty(),
+            showHiddenViews = true,
+            initialHiddenViews = editing?.let { hiddenViews[it.id] }.orEmpty(),
             deleteLocked = editing != null && editing.id in deleteLockedIds,
-            onSave = { name, color, description ->
+            onSave = { name, color, description, views ->
                 val id = editorId
                 if (id == null || id == NEW_CALENDAR_ID) {
-                    viewModel.createCalendar(name, color, description)
+                    viewModel.createCalendar(name, color, description, views)
                 } else {
-                    viewModel.updateCalendar(id, name, color, description)
+                    viewModel.updateCalendar(id, name, color, description, views)
                 }
                 editorId = null
             },
@@ -165,6 +180,7 @@ fun CalendarsScreen(
         CalendarsList(
             local = calendars.filter { it.isLocal },
             synced = calendars.filterNot { it.isLocal },
+            hiddenViews = hiddenViews,
             error = error,
             onConsumeError = viewModel::consumeError,
             onOpenBackup = onOpenBackup,
@@ -172,9 +188,26 @@ fun CalendarsScreen(
             visible = visible,
             onAdd = { editorSession++; editorId = NEW_CALENDAR_ID },
             onEdit = { calendar -> editorSession++; editorId = calendar.id },
+            onEditHiddenViews = { calendar -> hidingId = calendar.id },
             onSetVisible = viewModel::setCalendarVisible,
             onSetAccountVisible = viewModel::setAccountVisible,
         )
+        hidingId?.let { id ->
+            val calendar = calendars.firstOrNull { it.id == id }
+            // Gone while the picker was up; an empty list is one still loading, not a deletion.
+            if (calendar == null && calendars.isNotEmpty()) {
+                LaunchedEffect(id) { hidingId = null }
+            } else if (calendar != null && loadedHiddenViews != null) {
+                key(id) {
+                    HiddenViewsPicker(
+                        calendarName = calendar.displayName.orUnnamed(),
+                        hidden = hiddenViews[id].orEmpty(),
+                        onToggle = { view, hide -> viewModel.setHiddenIn(id, view, hide) },
+                        onDismiss = { hidingId = null },
+                    )
+                }
+            }
+        }
     }
 }
 
@@ -182,6 +215,7 @@ fun CalendarsScreen(
 private fun CalendarsList(
     local: List<CalendarSource>,
     synced: List<CalendarSource>,
+    hiddenViews: Map<Long, Set<CalendarView>>,
     error: Boolean,
     onConsumeError: () -> Unit,
     onOpenBackup: () -> Unit,
@@ -189,6 +223,7 @@ private fun CalendarsList(
     visible: Boolean,
     onAdd: () -> Unit,
     onEdit: (CalendarSource) -> Unit,
+    onEditHiddenViews: (CalendarSource) -> Unit,
     onSetVisible: (Long, Boolean) -> Unit,
     onSetAccountVisible: (Collection<Long>, Boolean) -> Unit,
 ) {
@@ -241,6 +276,7 @@ private fun CalendarsList(
                 local.forEachIndexed { index, calendar ->
                     CalendarManagerRow(
                         calendar = calendar,
+                        hiddenViews = hiddenViews[calendar.id].orEmpty(),
                         last = index == local.lastIndex,
                         onSetVisible = onSetVisible,
                         onClick = { onEdit(calendar) },
@@ -315,8 +351,10 @@ private fun CalendarsList(
                     ordered.forEachIndexed { index, calendar ->
                         CalendarManagerRow(
                             calendar = calendar,
+                            hiddenViews = hiddenViews[calendar.id].orEmpty(),
                             last = index == ordered.lastIndex,
                             onSetVisible = onSetVisible,
+                            onClick = { onEditHiddenViews(calendar) },
                         )
                     }
                 }
@@ -339,19 +377,32 @@ internal fun CalendarEditor(
     initialName: String,
     initialColor: Int,
     initialDescription: String,
-    onSave: (name: String, color: Int, description: String?) -> Unit,
+    onSave: (name: String, color: Int, description: String?, hiddenChanges: Map<CalendarView, Boolean>) -> Unit,
     onDelete: () -> Unit,
     onClose: () -> Unit,
     deleteLocked: Boolean = false,
+    showHiddenViews: Boolean = false,
+    initialHiddenViews: Set<CalendarView> = emptySet(),
 ) {
     var name by rememberSaveable(sessionKey) { mutableStateOf(initialName) }
+    val seededHiddenViews = rememberSaveable(sessionKey) { initialHiddenViews }
+    var hiddenViews by rememberSaveable(sessionKey) { mutableStateOf(initialHiddenViews) }
+    var pickHiddenViews by rememberSaveable(sessionKey) { mutableStateOf(false) }
     var color by rememberSaveable(sessionKey) { mutableStateOf(initialColor) }
     var description by rememberSaveable(sessionKey) { mutableStateOf(initialDescription) }
     var confirmDelete by remember { mutableStateOf(false) }
     val focusRequester = remember { FocusRequester() }
 
     val valid = name.isNotBlank()
-    val commit = { if (valid) onSave(name.trim(), color, description.trim().ifEmpty { null }) }
+    val commit = {
+        if (valid) {
+            // Only the views toggled here are written, so a save never resets ones it didn't load.
+            val changes = IMPLEMENTED_VIEWS
+                .filter { (it in hiddenViews) != (it in seededHiddenViews) }
+                .associateWith { it in hiddenViews }
+            onSave(name.trim(), color, description.trim().ifEmpty { null }, changes)
+        }
+    }
 
     FullScreenPicker(
         title = stringResource(
@@ -403,6 +454,16 @@ internal fun CalendarEditor(
             }
         }
 
+        if (showHiddenViews) {
+            Spacer(Modifier.height(20.dp))
+            GroupedRow(
+                title = stringResource(R.string.calendars_hide_in_views),
+                summary = hiddenViewsSummary(hiddenViews),
+                position = Position.Alone,
+                onClick = { pickHiddenViews = true },
+            )
+        }
+
         if (!isNew && !deleteLocked) {
             Spacer(Modifier.height(24.dp))
             DeleteCalendarRow(onClick = { confirmDelete = true })
@@ -410,6 +471,17 @@ internal fun CalendarEditor(
         Spacer(Modifier.height(24.dp))
     }
 
+    if (pickHiddenViews) {
+        HiddenViewsPicker(
+            calendarName = name.trim().orUnnamed(),
+            hidden = hiddenViews,
+            onToggle = { view, hide ->
+                hiddenViews = if (hide) hiddenViews + view else hiddenViews - view
+            },
+            onDismiss = { pickHiddenViews = false },
+        )
+    }
+
     if (confirmDelete) {
         AlertDialog(
             onDismissRequest = { confirmDelete = false },
@@ -636,7 +708,7 @@ private fun EditorSectionLabel(text: String) {
  * plain writable one (#76), then its own description.
  */
 @Composable
-private fun calendarRowSummary(calendar: CalendarSource): String? {
+private fun calendarRowSummary(calendar: CalendarSource, hiddenViews: Set<CalendarView>): String? {
     val states = calendar.stateLabels().map { label ->
         stringResource(
             when (label) {
@@ -646,7 +718,8 @@ private fun calendarRowSummary(calendar: CalendarSource): String? {
             },
         )
     }
-    val parts = states + listOfNotNull(calendar.description?.takeIf { it.isNotBlank() })
+    val hidden = if (hiddenViews.isEmpty()) null else hiddenViewsSummary(hiddenViews)
+    val parts = states + listOfNotNull(hidden, calendar.description?.takeIf { it.isNotBlank() })
     return parts.joinToString(" · ").ifEmpty { null }
 }
 
@@ -662,6 +735,7 @@ private fun calendarRowSummary(calendar: CalendarSource): String? {
 @Composable
 private fun CalendarManagerRow(
     calendar: CalendarSource,
+    hiddenViews: Set<CalendarView>,
     last: Boolean,
     onSetVisible: (Long, Boolean) -> Unit,
     onClick: (() -> Unit)? = null,
@@ -669,7 +743,7 @@ private fun CalendarManagerRow(
     val disabled = !calendar.isVisibleInSystem || calendar.isNotSynced
     GroupedRow(
         title = calendar.displayName.orUnnamed(),
-        summary = calendarRowSummary(calendar),
+        summary = calendarRowSummary(calendar, hiddenViews),
         position = if (last) Position.Bottom else Position.Middle,
         container = MaterialTheme.colorScheme.surfaceContainerHighest,
         dimmed = disabled,
@@ -689,6 +763,51 @@ private fun CalendarManagerRow(
     )
 }
 
+/**
+ * Which views one calendar stays out of (#270); display only, so reminders and
+ * search keep the calendar. [onToggle] decides when a toggle lands: at once for
+ * a synced calendar, on Save inside the local editor.
+ */
+@Composable
+private fun HiddenViewsPicker(
+    calendarName: String,
+    hidden: Set<CalendarView>,
+    onToggle: (CalendarView, Boolean) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    // Seeded once and then ahead of the store: the picker is the only writer while
+    // it is open, so following each write back would only flicker a quick second tap.
+    var shown by remember { mutableStateOf(hidden) }
+    MultiOptionPicker(
+        title = stringResource(R.string.calendars_hide_in_views),
+        options = IMPLEMENTED_VIEWS,
+        selected = shown,
+        label = { it.label() },
+        onToggle = { view, hide ->
+            shown = if (hide) shown + view else shown - view
+            onToggle(view, hide)
+        },
+        onDismiss = onDismiss,
+        leading = { Icon(it.icon, contentDescription = null) },
+        header = {
+            GroupedHint(
+                stringResource(R.string.calendars_hide_in_views_hint, calendarName),
+                verticalPadding = 8.dp,
+            )
+        },
+        predictiveBack = true,
+    )
+}
+
+/** "Shown in every view", or the views [hidden] names, in the app's view order. */
+@Composable
+private fun hiddenViewsSummary(hidden: Set<CalendarView>): String {
+    if (hidden.isEmpty()) return stringResource(R.string.calendars_hide_in_views_none)
+    val names = IMPLEMENTED_VIEWS.filter { it in hidden }.map { it.label() }
+    val locale = LocalConfiguration.current.locales[0]
+    return stringResource(R.string.calendars_hidden_in, ListFormatter.getInstance(locale).format(names))
+}
+
 /** Fade a leading element to the M3 disabled emphasis when [disabled]. */
 private fun dimIf(disabled: Boolean): Modifier =
     if (disabled) Modifier.alpha(0.38f) else Modifier

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

@@ -3,6 +3,7 @@ package de.jeanlucmakiola.calendula.ui.calendars
 import android.content.Context
 import android.content.Intent
 import android.net.Uri
+import android.util.Log
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
@@ -15,6 +16,8 @@ import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.hidingNothingOnError
 import de.jeanlucmakiola.floret.android.stateWhileSubscribed
 import de.jeanlucmakiola.floret.di.IoDispatcher
 import kotlinx.coroutines.CoroutineDispatcher
@@ -104,6 +107,19 @@ class CalendarsViewModel @Inject constructor(
             initialValue = emptySet(),
         )
 
+    /** The views each calendar is hidden in (#270); null until first read. */
+    val hiddenViews: StateFlow<Map<Long, Set<CalendarView>>?> =
+        settingsPrefs.perCalendarHiddenViews
+            .hidingNothingOnError()
+            .stateWhileSubscribed(
+                scope = viewModelScope,
+                initialValue = null,
+            )
+
+    fun setHiddenIn(id: Long, view: CalendarView, hidden: Boolean) = write {
+        settingsPrefs.setCalendarHiddenIn(id, view, hidden)
+    }
+
     private val _error = MutableStateFlow(false)
     val error: StateFlow<Boolean> = _error.asStateFlow()
 
@@ -139,16 +155,41 @@ class CalendarsViewModel @Inject constructor(
         }
     }
 
-    fun createCalendar(displayName: String, color: Int, description: String?) = write {
-        repository.createLocalCalendar(displayName, color, description)
+    fun createCalendar(
+        displayName: String,
+        color: Int,
+        description: String?,
+        hiddenChanges: Map<CalendarView, Boolean>,
+    ) = write {
+        val id = repository.createLocalCalendar(displayName, color, description)
+        settingsPrefs.applyCalendarHiddenChanges(id, hiddenChanges)
     }
 
-    fun updateCalendar(id: Long, displayName: String, color: Int, description: String?) = write {
+    fun updateCalendar(
+        id: Long,
+        displayName: String,
+        color: Int,
+        description: String?,
+        hiddenChanges: Map<CalendarView, Boolean>,
+    ) = write {
         repository.updateCalendar(id, displayName, color, description)
+        settingsPrefs.applyCalendarHiddenChanges(id, hiddenChanges)
     }
 
     fun deleteCalendar(id: Long) = write {
         repository.deleteCalendar(id)
+        // Tidy-up only: the delete already landed, so a failure here isn't its failure.
+        bestEffort { settingsPrefs.clearCalendarHiddenViews(id) }
+    }
+
+    private suspend fun bestEffort(block: suspend () -> Unit) {
+        try {
+            block()
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            Log.w("CalendarsViewModel", "Hidden-views write failed", e)
+        }
     }
 
     /**

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

@@ -70,6 +70,7 @@ fun CalendarDrawer(
     onSelectView: (CalendarView) -> Unit,
     onJumpToDate: (LocalDate) -> Unit,
     onSettings: () -> Unit,
+    onHideInView: () -> Unit,
     viewOrder: List<CalendarView> = IMPLEMENTED_VIEWS,
 ) {
     var showDatePicker by remember { mutableStateOf(false) }
@@ -112,7 +113,7 @@ fun CalendarDrawer(
             Spacer(Modifier.height(16.dp))
 
             DrawerSectionHeader(stringResource(R.string.filter_title))
-            CalendarFilterList()
+            CalendarFilterList(currentView = currentView, onHideInView = onHideInView)
 
             Spacer(Modifier.height(16.dp))
             GroupedRow(

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

@@ -8,9 +8,9 @@ import java.util.Locale
  * out in [locale]'s own order, with the year shown only when [date] falls outside
  * [currentYear].
  *
- * Pass [skeleton] *without* a year field — "LLLL" for a month, "EEEdMMM" for a
- * day. A skeleton is a field list, so wanting the year is just asking for one
- * more field; the locale still decides where it lands ("July 2026" vs "2026年7月").
+ * Pass [skeleton] *without* a year field, e.g. "LLLL" for a month. A skeleton
+ * is a field list, so wanting the year is just asking for one more field; the
+ * locale still decides where it lands ("July 2026" vs "2026年7月").
  *
  * Dropping the year in the current year is the one bit of policy here: the title
  * sits directly above a grid that already says which year it is, and the year's

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

@@ -90,6 +90,9 @@ fun EventMoveHost(
         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)
+        MoveOutcome.Stale -> stringResource(R.string.event_move_stale)
+        MoveOutcome.Skipped -> stringResource(R.string.event_move_skipped)
+        MoveOutcome.QueueFull -> stringResource(R.string.event_move_queue_full)
         MoveOutcome.BlockedSeriesEnd -> stringResource(R.string.event_move_blocked_series_end)
         MoveOutcome.BlockedCancelledSeries -> stringResource(R.string.event_move_blocked_cancelled_series)
         MoveOutcome.Failed -> stringResource(R.string.event_move_failed)

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

@@ -1,12 +1,15 @@
 package de.jeanlucmakiola.calendula.ui.common
 
 import androidx.compose.animation.core.animateFloatAsState
+import kotlinx.coroutines.delay
+import androidx.compose.animation.core.tween
+import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.Immutable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.compositionLocalOf
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.res.stringResource
@@ -16,6 +19,7 @@ import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
+import java.util.concurrent.atomic.AtomicLong
 
 /**
  * Drag-to-reschedule wiring (#68), provided once at `CalendarHost` and read by
@@ -37,24 +41,18 @@ class EventMoveScope(
     val dragEnabled: Boolean,
     /**
      * Hand a drop to the writer. Returns nothing on purpose: a drop is answered
-     * before its write resolves, so [abandoned] — not a return value — is what
-     * tells a held copy that nothing landed.
+     * before its write resolves, so [drops] — not a return value — is what tells
+     * a held copy whether anything landed.
      */
     val move: (MoveRequest) -> Unit,
     /**
-     * True while a dropped event is being written, including the time its scope
-     * dialog is up. A flow rather than a value so this scope stays the same
-     * object across a move — every visible block reads it as a composition local.
+     * Each drop's progress by its token — see `RescheduleViewModel.drops`. A flow
+     * rather than a value so this scope stays the same object across a move —
+     * every visible block reads it as a composition local.
      */
-    val inFlight: StateFlow<Boolean>,
-    /** Ticks when an undo write begins — see `RescheduleViewModel.undoStarted`. */
-    val undoStarted: StateFlow<Int>,
-    /**
-     * Ticks when a drop ends with nothing landing — see
-     * `RescheduleViewModel.abandoned`. [move] answers before the write is
-     * resolved, so this is what tells a held copy to stop waiting.
-     */
-    val abandoned: StateFlow<Int>,
+    val drops: StateFlow<DropStates>,
+    /** The undo write that just began — see `RescheduleViewModel.undoStarted`. */
+    val undoStarted: StateFlow<UndoStart?>,
     /** Open an event in the edit form — the pointer-free route to the same change. */
     val edit: (EventInstance) -> Unit,
 ) {
@@ -63,30 +61,42 @@ class EventMoveScope(
 
 val LocalEventMove = compositionLocalOf<EventMoveScope?> { null }
 
-private val NEVER_IN_FLIGHT = MutableStateFlow(false)
+private val moveTokens = AtomicLong()
 
-private val NEVER_UNDONE = MutableStateFlow(0)
+/** A fresh identity for one drop or undo, unique for the process. */
+fun nextMoveToken(): Long = moveTokens.incrementAndGet()
 
-private val NEVER_ABANDONED = MutableStateFlow(0)
+/** How many abandoned drops [DropStates] remembers — far more than can be on screen at once. */
+private const val ABANDONED_KEPT = 32
 
-/**
- * Whether a dropped event is still being written — false wherever moving is off.
- * The drag overlays hold a landed block on its target for this window.
- */
-@Composable
-fun moveInFlight(): Boolean {
-    val flow = LocalEventMove.current?.inFlight ?: NEVER_IN_FLIGHT
-    return flow.collectAsStateWithLifecycle().value
+/** Per-drop progress, by token — see `RescheduleViewModel.drops`. */
+@Immutable
+data class DropStates(
+    val pending: Set<Long> = emptySet(),
+    val abandoned: Set<Long> = emptySet(),
+) {
+    fun started(token: Long): DropStates = copy(pending = pending + token)
+
+    fun ended(token: Long, landed: Boolean): DropStates = copy(
+        pending = pending - token,
+        // Insertion-ordered, so the oldest go first.
+        abandoned = if (landed) abandoned else (abandoned + token).let { kept ->
+            if (kept.size > ABANDONED_KEPT) kept.drop(kept.size - ABANDONED_KEPT).toSet() else kept
+        },
+    )
 }
 
+private val NO_DROPS = MutableStateFlow(DropStates())
+
+private val NEVER_UNDONE = MutableStateFlow<UndoStart?>(null)
+
 /**
- * How many drops have ended with nothing landing. Read as a plain count so a
- * drag overlay can capture it at the moment of the drop and tell, later, whether
- * *its own* drop was one of them.
+ * Every drop's progress — empty wherever moving is off. A drag overlay keeps
+ * the token of its own drop and holds its copy while that token is pending.
  */
 @Composable
-fun abandonedMoves(): Int {
-    val flow = LocalEventMove.current?.abandoned ?: NEVER_ABANDONED
+fun dropStates(): DropStates {
+    val flow = LocalEventMove.current?.drops ?: NO_DROPS
     return flow.collectAsStateWithLifecycle().value
 }
 
@@ -95,17 +105,53 @@ fun abandonedMoves(): Int {
  * this composable came on screen.
  */
 @Composable
-fun OnUndoStarted(onUndo: () -> Unit) {
+fun OnUndoStarted(onUndo: (UndoStart) -> Unit) {
     val flow = LocalEventMove.current?.undoStarted ?: NEVER_UNDONE
-    val tick by flow.collectAsStateWithLifecycle()
-    var seen by remember { mutableIntStateOf(tick) }
-    LaunchedEffect(tick) {
-        if (tick == seen) return@LaunchedEffect
-        seen = tick
-        onUndo()
+    val start by flow.collectAsStateWithLifecycle()
+    var seen by remember { mutableStateOf(start) }
+    LaunchedEffect(start) {
+        val started = start
+        if (started == null || started == seen) return@LaunchedEffect
+        seen = started
+        onUndo(started)
     }
 }
 
+/**
+ * The life of a drop parked by a newer pickup (#494): held while its [token]
+ * is pending, then a beat after the grid [seated] it — or [timeoutMillis] if it
+ * never does — handed over and faded, then released. Returns the copy's alpha.
+ * An abandoned drop skips the wait; nothing is coming to seat it.
+ */
+@Composable
+fun rememberHeldSettle(
+    token: Long,
+    seated: Boolean,
+    timeoutMillis: Long,
+    onHandOver: () -> Unit,
+    onRelease: () -> Unit,
+): Float {
+    val drops = dropStates()
+    val pending = token in drops.pending
+    val abandoned = token in drops.abandoned
+    val handOver by rememberUpdatedState(onHandOver)
+    val release by rememberUpdatedState(onRelease)
+    var fading by remember(token) { mutableStateOf(false) }
+    LaunchedEffect(token, pending, abandoned, seated) {
+        if (pending) return@LaunchedEffect
+        if (!abandoned) delay(if (seated) SETTLE_GRACE_MILLIS else timeoutMillis)
+        fading = true
+        handOver()
+        delay(SETTLE_FADE_MILLIS.toLong())
+        release()
+    }
+    return animateFloatAsState(
+        targetValue = if (fading) 0f else 1f,
+        animationSpec = tween(SETTLE_FADE_MILLIS),
+        label = "held-settle",
+    ).value
+}
+
 /** Opacity the source block keeps while its floating copy travels. */
 const val GHOST_ALPHA: Float = 0.3f
 

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

@@ -32,6 +32,7 @@ import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
@@ -40,12 +41,21 @@ import kotlinx.datetime.atStartOfDayIn
 import kotlinx.datetime.plus
 import kotlinx.datetime.toLocalDateTime
 import kotlin.coroutines.cancellation.CancellationException
+import kotlin.time.Duration.Companion.seconds
 import kotlin.time.Instant
+import kotlin.time.TimeMark
+import kotlin.time.TimeSource
 import javax.inject.Inject
 
 private const val MILLIS_PER_MINUTE = 60_000
 private const val MINUTES_PER_DAY = 24 * 60
 
+/** How many drops may wait behind the one in flight before more are refused. */
+private const val MAX_QUEUED = 8
+
+/** How long after a write its event's drawn times may still be the old ones. */
+private val RECENT_WRITE = 3.seconds
+
 /** Where a dragged event should land. */
 sealed interface MoveTarget {
     /** A new start instant — a timeline drag, which moves time and day at once. */
@@ -74,6 +84,10 @@ data class MoveRequest(
     val beginMillis: Long,
     val endMillis: Long,
     val target: MoveTarget,
+    /** Whether the dragged occurrence is all-day, which decides the zone its day is read in. */
+    val isAllDay: Boolean,
+    /** The drop's own identity, from [nextMoveToken], which the view holding its copy waits on. */
+    val token: Long,
 )
 
 /**
@@ -92,8 +106,13 @@ data class MoveUndo(
     val moved: EventForm,
     /** The form as it stood before the move. */
     val restored: EventForm,
+    /** The token of the drop this undoes, so the view that drew it carries the right chip back. */
+    val dropToken: Long,
 )
 
+/** An undo write that just began: its own [token], and the [dropToken] of the drop it undoes. */
+data class UndoStart(val token: Long, val dropToken: Long)
+
 sealed interface MoveOutcome {
     /**
      * Written. [startMillis] is where the dragged occurrence now begins, for the
@@ -115,6 +134,19 @@ sealed interface MoveOutcome {
     /** The event vanished (sync, another device) between the read and the write. */
     data object Gone : MoveOutcome
 
+    /** Drops that waited behind a scope dialog, cancelled rather than run after it (#494). */
+    data object Skipped : MoveOutcome
+
+    /** More drops waiting than the queue holds; this one was not taken. */
+    data object QueueFull : MoveOutcome
+
+    /**
+     * The drop's recurring occurrence may no longer be where it was picked up —
+     * its series was just written — and can't be followed there, so it is not
+     * written (#494).
+     */
+    data object Stale : MoveOutcome
+
     /** The drop would push the series past its own `UNTIL`, generating nothing. */
     data object BlockedSeriesEnd : MoveOutcome
 
@@ -152,36 +184,32 @@ class RescheduleViewModel @Inject constructor(
 
     private val _inFlight = MutableStateFlow(false)
 
-    /**
-     * True from the moment a drop is accepted until its write settles — the
-     * window the dropped block holds its landing position for.
-     */
+    /** True while any drop or undo runs or waits — what the confirmation chip holds for. */
     val inFlight: StateFlow<Boolean> = _inFlight.asStateFlow()
 
-    private val _abandoned = MutableStateFlow(0)
+    private val _drops = MutableStateFlow(DropStates())
 
     /**
-     * Ticks when a drop ends with nothing on the target day: refused outright,
-     * refused before the write, written and failed, or its scope dialog
-     * dismissed. [move] answers before any of that is known, so without this
-     * signal the view that drew the drop held its copy out for the full settle
-     * timeout waiting for a grid that was never going to draw it (#253).
+     * Each drop's own state, by its [MoveRequest.token]: pending from the moment
+     * it is accepted until its write settles, and abandoned once it ends with
+     * nothing on the target day — refused, failed, or its scope dialog dismissed.
+     * Per drop, so a queued drop's held copy waits on its own write and is never
+     * let go by another drop's failure (#253, #494).
      */
-    val abandoned: StateFlow<Int> = _abandoned.asStateFlow()
+    val drops: StateFlow<DropStates> = _drops.asStateFlow()
 
-    private val _undoStarted = MutableStateFlow(0)
+    private val _undoStarted = MutableStateFlow<UndoStart?>(null)
 
     /**
-     * Ticks the moment an undo write begins, before the provider has anything to
+     * An undo write the moment it begins, before the provider has anything to
      * re-read, so the view that drew the drop can carry its chip back rather than
-     * let it reappear on the old day.
+     * let it reappear on the old day. Its fate then reads off [drops].
      */
-    val undoStarted: StateFlow<Int> = _undoStarted.asStateFlow()
+    val undoStarted: StateFlow<UndoStart?> = _undoStarted.asStateFlow()
 
     /**
-     * Set from the moment a drop is accepted until its write settles. Two drops
-     * of the same recurring event inside that window would compute their shift
-     * from the same pre-move occurrence, and the shifts would compound.
+     * Set while a drop is being prepared, waits on its scope dialog, or is
+     * written. Drops arriving in that window wait in [queue] and run in order.
      */
     private var busy = false
         set(value) {
@@ -189,6 +217,22 @@ class RescheduleViewModel @Inject constructor(
             _inFlight.value = value
         }
 
+    /** Whether a move has been announced since the pipeline was last idle — see [report]. */
+    private var movedThisRun = false
+
+    /** Outcomes waiting for the chip, shown one after another as each is consumed. */
+    private val notices = ArrayDeque<MoveOutcome>()
+
+    /**
+     * When each event's series (by id) or single occurrence (by id and begin)
+     * was last written. The grid draws the old times until it re-reads, so a
+     * drop on a recurring event written moments ago may carry stale times (#494).
+     */
+    private val written = mutableMapOf<Pair<Long, Long?>, TimeMark>()
+
+    /** Drops that arrived while another was in flight, oldest first (#494). */
+    private val queue = ArrayDeque<MoveRequest>()
+
     /**
      * The calendars whose events may be dragged. Nothing below the UI guards
      * this, so a block outside this set registers no drag gesture at all.
@@ -219,38 +263,50 @@ class RescheduleViewModel @Inject constructor(
     }
 
     /**
-     * Take a drop, unless one is already being written. False means nothing will
-     * be written; [abandoned] ticks for that refusal too, so a held copy is let
-     * go by the one signal rather than by every caller remembering to.
+     * Take a drop: run it now, or queue it behind the ones in flight. False means
+     * nothing will be written — the queue is full — and the drop is marked
+     * abandoned in [drops], so its held copy is let go by the one signal rather
+     * than by every caller remembering to.
      *
      * The Boolean is diagnostic — the tests read it, [EventMoveScope] does not
-     * hand it on. A caller that gated on it would be back to releasing its copy
-     * from two places, and it answers before the write is resolved anyway.
+     * hand it on. It answers before the write is resolved anyway.
      */
     fun move(request: MoveRequest): Boolean {
-        if (busy || _scopePrompt.value != null) {
-            _abandoned.value += 1
+        if (queue.size >= MAX_QUEUED) {
+            _drops.update { it.ended(request.token, landed = false) }
+            report(MoveOutcome.QueueFull)
             return false
         }
+        if (_scopePrompt.value != null) {
+            _drops.update { it.ended(request.token, landed = false) }
+            report(MoveOutcome.Skipped)
+            return false
+        }
+        _drops.update { it.started(request.token) }
+        if (busy) queue.addLast(request) else run(request)
+        return true
+    }
+
+    private fun run(request: MoveRequest) {
         busy = true
         viewModelScope.launch {
             val prepared = prepare(request)
             if (prepared == null) {
-                _abandoned.value += 1
-                busy = false
+                settle(request.token, landed = false)
                 return@launch
             }
             // A cancelled series only moves as a whole (#388).
             val seriesOnly = !prepared.original.canSaveApartFromSeries()
             if (!prepared.isRecurring || (seriesOnly && prepared.canRealign)) {
-                write(prepared, RecurringWriteScope.AllEvents)
-                busy = false
+                settle(request.token, write(prepared, RecurringWriteScope.AllEvents))
             } else if (seriesOnly) {
-                _outcome.value = MoveOutcome.BlockedCancelledSeries
-                _abandoned.value += 1
-                busy = false
+                report(MoveOutcome.BlockedCancelledSeries)
+                settle(request.token, landed = false)
             } else {
-                // Still busy: the scope dialog is now the thing in flight.
+                // Still busy: the scope dialog is now the thing in flight. Drops
+                // waiting behind it are cancelled, not held behind a question
+                // about another event.
+                skipQueued()
                 pending = prepared
                 _scopePrompt.value = MoveScopePrompt(
                     occurrenceOnly = !prepared.canRealign,
@@ -258,7 +314,6 @@ class RescheduleViewModel @Inject constructor(
                 )
             }
         }
-        return true
     }
 
     /** Answer the scope dialog. */
@@ -269,35 +324,92 @@ class RescheduleViewModel @Inject constructor(
         pending = null
         _scopePrompt.value = null
         viewModelScope.launch {
-            write(prepared, scope)
-            busy = false
+            settle(prepared.request.token, write(prepared, scope))
         }
     }
 
     /** Dismiss the scope dialog without writing. */
     fun cancelScope() {
+        val prepared = pending ?: return
         pending = null
-        busy = false
         _scopePrompt.value = null
-        _abandoned.value += 1
+        settle(prepared.request.token, landed = false)
+    }
+
+    /** End the drop [token], then run the next queued one, if any. */
+    private fun settle(token: Long, landed: Boolean) {
+        _drops.update { it.ended(token, landed) }
+        // Straight on to the next, so busy never reads false between two drops.
+        val next = queue.removeFirstOrNull()
+        if (next != null) {
+            run(next)
+        } else {
+            busy = false
+            movedThisRun = false
+        }
+    }
+
+    private fun skipQueued() {
+        if (queue.isEmpty()) return
+        val skipped = queue.map { it.token }
+        queue.clear()
+        _drops.update { states -> skipped.fold(states) { acc, token -> acc.ended(token, landed = false) } }
+        report(MoveOutcome.Skipped)
+    }
+
+    /**
+     * Queue [outcome] for the chip. While drops run back to back only the first
+     * move is announced, so its Undo stays on offer; every failure gets its own
+     * turn after it, since the grid shows what moved but only the chip says what
+     * didn't. A later write to the announced move's event takes that Undo away,
+     * as putting the event back would undo the later move too.
+     */
+    private fun report(outcome: MoveOutcome, eventId: Long? = null) {
+        if (outcome is MoveOutcome.Moved) {
+            if (movedThisRun) {
+                dropUndoFor(eventId)
+                return
+            }
+            movedThisRun = true
+        } else if (outcome == (notices.lastOrNull() ?: _outcome.value)) {
+            return
+        }
+        if (_outcome.value == null) _outcome.value = outcome else notices.addLast(outcome)
+    }
+
+    private fun dropUndoFor(eventId: Long?) {
+        fun MoveOutcome.withoutUndo(): MoveOutcome =
+            if (this is MoveOutcome.Moved && undo?.eventId == eventId) copy(undo = null) else this
+        _outcome.value = _outcome.value?.withoutUndo()
+        val rest = notices.map { it.withoutUndo() }
+        notices.clear()
+        notices.addAll(rest)
+    }
+
+    private fun markWritten(eventId: Long, beginMillis: Long?) {
+        written[eventId to beginMillis] = TimeSource.Monotonic.markNow()
+    }
+
+    private fun writtenRecently(eventId: Long, beginMillis: Long): Boolean {
+        written.entries.removeAll { it.value.elapsedNow() > RECENT_WRITE }
+        return (eventId to null) in written || (eventId to beginMillis) in written
     }
 
     /**
      * Put a completed move back where it came from. The outcome stands until the
      * inverse write reports back, so the one chip changes what it says rather
      * than closing and reopening. False when another write is already running —
-     * the chip hides its action for that window, so this is the backstop.
-     *
-     * [abandoned] ticks once an inverse that *started* fails to land: [undoStarted]
-     * has sent the chip back on its journey by then and nothing else will seat it.
-     * A refusal ticks nothing — it launched no journey of its own, and the counter
-     * is global, so a tick here would release some other drop's held copy before
-     * the grid has drawn it.
+     * the chip hides its action for that window, so this is the backstop. An
+     * undo is a journey of its own: [undoStarted] names its token, and [drops]
+     * reports whether it landed.
      */
     fun undo(undo: MoveUndo): Boolean {
         if (busy) return false
+        val token = nextMoveToken()
+        _drops.update { it.started(token) }
         busy = true
-        _undoStarted.value += 1
+        _undoStarted.value = UndoStart(token, undo.dropToken)
+        markWritten(undo.eventId, null)
         viewModelScope.launch {
             _outcome.value = try {
                 repository.updateEvent(undo.eventId, undo.moved, undo.restored)
@@ -311,33 +423,40 @@ class RescheduleViewModel @Inject constructor(
             } catch (e: Exception) {
                 MoveOutcome.Failed
             }
-            // Read off the outcome, the way [write] does — no second copy of the
-            // same fact to drift from it.
-            if (_outcome.value !is MoveOutcome.Undone) _abandoned.value += 1
-            busy = false
+            settle(token, landed = _outcome.value is MoveOutcome.Undone)
         }
         return true
     }
 
-    /** Clear the outcome once the screen has shown it. */
+    /** Clear the outcome once the screen has shown it, bringing on the next one waiting. */
     fun consumeOutcome() {
-        _outcome.value = null
+        _outcome.value = notices.removeFirstOrNull()
     }
 
-    private suspend fun prepare(request: MoveRequest): PreparedMove? {
+    private suspend fun prepare(dropped: MoveRequest): PreparedMove? {
+        val zone = zoneSource.current()
         val detail = try {
-            repository.eventDetail(request.eventId)
+            repository.eventDetail(dropped.eventId)
         } catch (e: CancellationException) {
             throw e
         } catch (e: NoSuchEventException) {
-            _outcome.value = MoveOutcome.Gone
+            report(MoveOutcome.Gone)
             return null
         } catch (e: Exception) {
-            _outcome.value = MoveOutcome.Failed
+            report(MoveOutcome.Failed)
             return null
         }
+        // The drop carries the times the grid drew, which an earlier write may
+        // have moved on since (#494).
+        val request = if (detail.rrule == null || detail.isException) {
+            followed(dropped, detail, zone)
+        } else if (writtenRecently(dropped.eventId, dropped.beginMillis)) {
+            report(MoveOutcome.Stale)
+            return null
+        } else {
+            dropped
+        }
 
-        val zone = zoneSource.current()
         val original = detail.toEditForm(request.beginMillis, request.endMillis, zone)
         val shifted = when (val target = request.target) {
             is MoveTarget.Start -> original.shiftedTo(target.instant, zone)
@@ -350,7 +469,7 @@ class RescheduleViewModel @Inject constructor(
         // The UNTIL check is deferred to the write, which knows how far the move
         // reaches and so which date has to clear it.
         if ((shifted.problems(zone) - EventFormProblem.RecurrenceEndsBeforeStart).isNotEmpty()) {
-            _outcome.value = MoveOutcome.Failed
+            report(MoveOutcome.Failed)
             return null
         }
 
@@ -395,14 +514,14 @@ class RescheduleViewModel @Inject constructor(
         )
     }
 
-    private suspend fun write(prepared: PreparedMove, scope: RecurringWriteScope) {
+    /** Write [prepared] in [scope]; true when it landed. */
+    private suspend fun write(prepared: PreparedMove, scope: RecurringWriteScope): Boolean {
         val request = prepared.request
         if (endsBeforeItStarts(prepared, scope)) {
-            _outcome.value = MoveOutcome.BlockedSeriesEnd
-            _abandoned.value += 1
-            return
+            report(MoveOutcome.BlockedSeriesEnd)
+            return false
         }
-        _outcome.value = try {
+        val outcome = try {
             when {
                 !prepared.isRecurring || scope == RecurringWriteScope.AllEvents ->
                     repository.updateEvent(request.eventId, prepared.original, prepared.updated)
@@ -437,9 +556,37 @@ class RescheduleViewModel @Inject constructor(
         } catch (e: Exception) {
             MoveOutcome.Failed
         }
-        // Nothing landed, so the copy the view is holding has nothing to fade
-        // into — let it go now rather than at the end of the settle timeout.
-        if (_outcome.value !is MoveOutcome.Moved) _abandoned.value += 1
+        if (outcome is MoveOutcome.Moved) {
+            markWritten(request.eventId, request.beginMillis.takeIf { scope == RecurringWriteScope.ThisEvent && prepared.isRecurring })
+        }
+        report(outcome, request.eventId)
+        return outcome is MoveOutcome.Moved
+    }
+
+    /**
+     * A one-off [dropped] rebased onto where its event now is, so the last drop
+     * wins: absolute targets stand as they are, and a whole-day shift is re-aimed
+     * at the day it was dropped on. Unchanged when the event hasn't moved.
+     */
+    private fun followed(dropped: MoveRequest, detail: EventDetail, zone: TimeZone): MoveRequest {
+        val now = detail.instance
+        val target = when (val target = dropped.target) {
+            is MoveTarget.ByDays -> {
+                // Each day read the way its own kind anchors it: all-day at UTC.
+                val aimed = Instant.fromEpochMilliseconds(dropped.beginMillis)
+                    .toLocalDateTime(if (dropped.isAllDay) TimeZone.UTC else zone).date
+                    .plus(target.days, DateTimeUnit.DAY)
+                val from = now.start.toLocalDateTime(if (now.isAllDay) TimeZone.UTC else zone).date
+                MoveTarget.ByDays((aimed.toEpochDays() - from.toEpochDays()).toInt())
+            }
+            else -> target
+        }
+        return dropped.copy(
+            beginMillis = now.start.toEpochMilliseconds(),
+            endMillis = now.end.toEpochMilliseconds(),
+            target = target,
+            isAllDay = now.isAllDay,
+        )
     }
 
     /**
@@ -506,6 +653,7 @@ class RescheduleViewModel @Inject constructor(
                 eventId = prepared.request.eventId,
                 moved = prepared.updated,
                 restored = prepared.original,
+                dropToken = prepared.request.token,
             )
         } else {
             null

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

@@ -20,6 +20,7 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.Stable
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
 import androidx.compose.runtime.mutableStateListOf
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
@@ -60,7 +61,6 @@ import de.jeanlucmakiola.floret.identity.LocalFloretDarkTheme
 import de.jeanlucmakiola.floret.identity.rememberReduceMotion
 import de.jeanlucmakiola.floret.locale.currentLocale
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.StateFlow
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.atStartOfDayIn
@@ -139,9 +139,17 @@ data class StripDrag(val event: EventInstance, val dayShift: Int = 0, val overGr
 sealed interface StripDrop {
     val event: EventInstance
 
-    data class Days(override val event: EventInstance, val days: Int) : StripDrop
+    /** The drop's identity, which its held copy waits on. */
+    val token: Long
 
-    data class Timed(override val event: EventInstance, val start: Instant, val end: Instant) : StripDrop
+    data class Days(override val event: EventInstance, val days: Int, override val token: Long) : StripDrop
+
+    data class Timed(
+        override val event: EventInstance,
+        val start: Instant,
+        val end: Instant,
+        override val token: Long,
+    ) : StripDrop
 }
 
 /** The event a long press left selected (#141). */
@@ -297,7 +305,9 @@ data class TimelineDrop(
     val date: LocalDate,
     val startMin: Int,
     /** Minutes from the event's start to the dragged block's top edge. */
-    val clipOffsetMin: Int = 0,
+    val clipOffsetMin: Int,
+    /** The drop's identity, which its held copy waits on. */
+    val token: Long,
 )
 
 /** The id a drafted block's stand-in event carries, which no provider row has (#153). */
@@ -340,8 +350,37 @@ internal fun draftBlock(draft: EventInstance, date: LocalDate, zone: TimeZone):
 /** Which end of an event a resize handle moves (#141). */
 enum class ResizeEdge { Top, Bottom }
 
+/** A drop parked by a newer pickup while its write still runs — see [TimelineDragController.held]. */
+data class HeldDrop(
+    val copy: TimelineDrag,
+    val token: Long,
+    val instanceId: Long,
+    /** The event row and start the drop came from, as [TimelineDragController.ghosts] matches them. */
+    val origin: Pair<Long, Instant>,
+    /** A resize's new end, which has to have landed too before the drop counts as seated. */
+    val end: Instant?,
+    /** Whether the grid now draws the drop at its landing slot. */
+    val seated: Boolean = false,
+    val handedOver: Boolean = false,
+) {
+    fun ghosts(block: TimedBlock): Boolean = block.event.instanceId == instanceId ||
+        (block.event.eventId == origin.first && block.event.start == origin.second)
+}
+
+/** A strip drop parked by a newer one while its write still runs — see [TimelineDragController.heldStrips]. */
+data class HeldStrip(val drag: StripDrag, val token: Long, val seated: Boolean = false)
+
+/** An event's new start and end, as a resize leaves them. */
+data class ResizedSpan(val start: Instant, val end: Instant)
+
 /** Where a finished resize asks its event to begin and end. */
-data class TimelineResizeDrop(val event: EventInstance, val start: Instant, val end: Instant)
+data class TimelineResizeDrop(
+    val event: EventInstance,
+    val start: Instant,
+    val end: Instant,
+    /** The drop's identity, which its held copy waits on. */
+    val token: Long,
+)
 
 /**
  * [event] resized by its [edge] to the span [startMin]..+[spanMin] from [date]'s
@@ -352,17 +391,16 @@ data class TimelineResizeDrop(val event: EventInstance, val start: Instant, val
  * it was drawn (see [repicked]). An end takes a pass the grid draws at the drop
  * point, so the block settles under the finger.
  */
-internal fun resizedDrop(
+internal fun resizedSpan(
     event: EventInstance,
     edge: ResizeEdge?,
     date: LocalDate,
     startMin: Int,
     spanMin: Int,
     zone: TimeZone,
-): TimelineResizeDrop {
+): ResizedSpan {
     val drawn = wallClockSpan(event, zone)
-    return TimelineResizeDrop(
-        event = event,
+    return ResizedSpan(
         start = if (edge == ResizeEdge.Top) {
             event.start.toFormTime(zone).repicked(
                 wallClockTime(date, startMin),
@@ -513,6 +551,14 @@ class TimelineDragController {
      */
     private var settledOrigin: Pair<Long, Instant>? by mutableStateOf(null)
 
+    /**
+     * Earlier drops still being written when another block was picked up. They
+     * keep their copy and their ghost until their own token settles, rather than
+     * vanishing and flashing back at the old slot (#494).
+     */
+    var held: List<HeldDrop> by mutableStateOf(emptyList())
+        private set
+
     /** How long a block drafted on an empty slot starts out, in minutes (#153). */
     var draftMinutes: Int = SettingsPrefs.DEFAULT_EVENT_DURATION
 
@@ -611,14 +657,8 @@ class TimelineDragController {
     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.
-     */
-    var abandonedTicks: StateFlow<Int>? = null
-
-    /** What [abandonedTicks] stood at when the settling drop was let go. */
-    var settledAbandonedMark: Int = 0
+    /** The token of the drop [settling] waits on. */
+    var settledToken: Long = 0L
         private set
 
     private var source: TimedBlock? = null
@@ -661,8 +701,12 @@ class TimelineDragController {
     var stripSeated: Boolean by mutableStateOf(false)
         private set
 
-    /** What [abandonedTicks] stood at when [stripSettling] was let go. */
-    var stripAbandonedMark: Int = 0
+    /** Strip drops parked by a newer strip drop while their writes still run (#494). */
+    var heldStrips: List<HeldStrip> by mutableStateOf(emptyList())
+        private set
+
+    /** The token of the drop [stripSettling] waits on. */
+    var stripToken: Long = 0L
         private set
 
     /** The shown day the finger picked the strip bar up on. */
@@ -687,7 +731,7 @@ class TimelineDragController {
         dragDuration = (block.event.end - block.event.start).coerceAtLeast(Duration.ZERO)
         dragKept = zone.repeatedHourOffsetAt(block.event.start)
         this.titleLines = titleLines
-        settling = null
+        parkSettling()
         isDragging = true
         liftedInstanceId = block.event.instanceId
         grab = pointerInRoot - blockInRoot
@@ -726,7 +770,7 @@ class TimelineDragController {
         dragDuration = draftMinutes.minutes
         dragKept = null
         titleLines = 1
-        settling = null
+        parkSettling()
         isDragging = true
         liftedInstanceId = event.instanceId
         grab = Offset(0f, geometry.hourPx * STRIP_GRAB_MINUTES / 60f)
@@ -749,16 +793,18 @@ class TimelineDragController {
         val zone = dragZone
         cancel()
         if (held.overGrid && landed != null && zone != null && !landed.edgeOnly) {
-            settle(landed)
-            val start = TimelineDrop(landed.event, landed.date, landed.startMin).startInstant(zone)
-            return StripDrop.Timed(held.event, start, start + draftMinutes.minutes)
+            val token = settle(landed)
+            val start = dropStartInstant(landed.event, landed.date, landed.startMin, clipOffsetMin = 0, zone)
+            return StripDrop.Timed(held.event, start, start + draftMinutes.minutes, token)
         }
         if (held.overGrid || held.dayShift == 0) return null
+        // One still settling keeps its place on the strip until its own write lands (#494).
+        stripSettling?.let { heldStrips = heldStrips + HeldStrip(it, stripToken, stripSeated) }
         stripSettling = held
         stripSeated = false
-        stripAbandonedMark = abandonedTicks?.value ?: 0
+        stripToken = nextMoveToken()
         drops++
-        return StripDrop.Days(held.event, held.dayShift)
+        return StripDrop.Days(held.event, held.dayShift, stripToken)
     }
 
     /** Let the held strip drop go, once the strip shows the event at its new days or the move failed. */
@@ -772,6 +818,21 @@ class TimelineDragController {
         if (stripSettling != null) stripSeated = true
     }
 
+    /** Note that the strip draws the parked strip drop [token] at its new days. */
+    fun seatHeldStrip(token: Long) {
+        if (heldStrips.any { it.token == token && !it.seated }) {
+            heldStrips = heldStrips.map { if (it.token == token) it.copy(seated = true) else it }
+        }
+    }
+
+    /** Let the parked strip drop [token] go. */
+    fun releaseHeldStrip(token: Long) {
+        heldStrips = heldStrips.filterNot { it.token == token }
+    }
+
+    /** Every strip drop still shown at its new days: the parked ones, then the latest. */
+    fun stripPreviews(): List<StripDrag> = heldStrips.map { it.drag } + listOfNotNull(stripDrag ?: stripSettling)
+
     fun move(pointerInRoot: Offset) {
         pointer = pointerInRoot
         if (!pointerMoved && (pointerInRoot - pickupPointer).getDistance() > slopPx) pointerMoved = true
@@ -806,12 +867,36 @@ class TimelineDragController {
      * an event that crosses midnight (#253).
      */
     fun ghosts(block: TimedBlock): Boolean {
+        if (held.any { !it.handedOver && it.ghosts(block) }) return true
         if (liftedInstanceId == null) return false
         if (block.event.instanceId == liftedInstanceId) return true
         val (eventId, start) = settledOrigin ?: return false
         return block.event.eventId == eventId && block.event.start == start
     }
 
+    /** Move a still-settling drop to [held] before a new pickup takes the slot. */
+    private fun parkSettling() {
+        val landed = settling
+        val origin = settledOrigin
+        if (landed != null && origin != null && !landed.event.isDraft) {
+            held = held + HeldDrop(landed, settledToken, landed.event.instanceId, origin, settledEnd, settledOnGrid)
+        }
+        settling = null
+        settledOnGrid = false
+        settledOrigin = null
+        settledEnd = null
+    }
+
+    /** Stop ghosting the held drop [token]'s source while its copy fades. */
+    fun handOverHeld(token: Long) {
+        held = held.map { if (it.token == token) it.copy(handedOver = true) else it }
+    }
+
+    /** Drop the held copy [token] once it has faded. */
+    fun releaseHeld(token: Long) {
+        held = held.filterNot { it.token == token }
+    }
+
     /**
      * What a day column now holds, so a settled drop can tell when the grid has
      * caught up with it. Matched on the landing slot plus either the event row
@@ -819,16 +904,23 @@ class TimelineDragController {
      * blank title matches nothing: every untitled event has one (#253).
      */
     fun noteGrid(date: LocalDate, blocks: List<TimedBlock>) {
+        if (held.any { !it.seated && drawsDrop(it.copy, it.end, date, blocks) }) {
+            held = held.map { if (!it.seated && drawsDrop(it.copy, it.end, date, blocks)) it.copy(seated = true) else it }
+        }
         val landed = settling ?: return
         if (settledOnGrid) return
+        settledOnGrid = drawsDrop(landed, settledEnd, date, blocks)
+    }
+
+    /** Whether [blocks], [date]'s column, draws the drop [landed] where it landed. */
+    private fun drawsDrop(landed: TimelineDrag, end: Instant?, date: LocalDate, blocks: List<TimedBlock>): Boolean {
         // Where this day would draw it, which for a drop clipped at midnight is
         // the day's own start rather than the edge the finger held (#253) — and
         // which for a tail dragged clear of its day is the day before it.
         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 ->
+            .firstOrNull() ?: return false
+        return 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) &&
@@ -855,12 +947,15 @@ class TimelineDragController {
         if (landed == null || landed.slot == origin) return null
         // A draft dropped on a day off screen would vanish, so it stays where it was (#153).
         if (landed.edgeOnly && landed.event.isDraft) return null
-        settle(landed)
-        return TimelineDrop(landed.event, landed.date, landed.startMin, clipOffset)
+        val token = settle(landed)
+        return TimelineDrop(landed.event, landed.date, landed.startMin, clipOffset, token)
     }
 
-    /** Keep [landed]'s copy on the target as [settling] until [release]; [end] is a resize's. */
-    private fun settle(landed: TimelineDrag, end: Instant? = null) {
+    /**
+     * Keep [landed]'s copy on the target as [settling] until [release]; [end] is a
+     * resize's. Returns the drop's fresh token.
+     */
+    private fun settle(landed: TimelineDrag, end: Instant? = null): Long {
         // Landed on midnight to midnight, the event moves to the all-day strip (#296).
         val leavesGrid = !landed.event.isDraft && landed.eventSpanMin > 0 &&
             landed.eventStartMin.mod(MINUTES_PER_DAY) == 0 &&
@@ -873,9 +968,10 @@ class TimelineDragController {
         settling = if (landed.edgeOnly || leavesGrid) landed.copy(pieces = emptyList()) else landed
         liftedInstanceId = landed.event.instanceId
         settledOrigin = landed.event.eventId to landed.event.start
-        settledAbandonedMark = abandonedTicks?.value ?: 0
+        settledToken = nextMoveToken()
         settledEnd = end
         drops++
+        return settledToken
     }
 
     /**
@@ -895,7 +991,7 @@ class TimelineDragController {
         resize = session
         clipOffsetMin = 0
         this.titleLines = titleLines
-        settling = null
+        parkSettling()
         isDragging = true
         pointerMoved = true
         liftedInstanceId = block.event.instanceId
@@ -926,10 +1022,10 @@ class TimelineDragController {
         val event = source?.event ?: return null
         val edge = resize?.edge
         if (edge != null) {
-            val drop = resizedDrop(event, edge, date, startMin, spanMin, zone)
+            val drop = resizedSpan(event, edge, date, startMin, spanMin, zone)
             return event.copy(start = drop.start, end = drop.end)
         }
-        val start = TimelineDrop(event, date, startMin, clipOffsetMin).startInstant(zone)
+        val start = dropStartInstant(event, date, startMin, clipOffsetMin, zone)
         return event.copy(start = start, end = start + dragDuration)
     }
 
@@ -943,9 +1039,8 @@ class TimelineDragController {
         val edge = resize?.edge
         cancel()
         if (landed == null || landed.slot == origin) return null
-        val drop = resizedDrop(landed.event, edge, landed.date, landed.eventStartMin, landed.eventSpanMin, zone)
-        settle(landed, end = drop.end)
-        return drop
+        val span = resizedSpan(landed.event, edge, landed.date, landed.eventStartMin, landed.eventSpanMin, zone)
+        return TimelineResizeDrop(landed.event, span.start, span.end, settle(landed, end = span.end))
     }
 
     /**
@@ -1199,7 +1294,6 @@ fun rememberTimelineDragController(): TimelineDragController {
     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
 }
 
@@ -1229,7 +1323,16 @@ fun TimedBlock.continuesBefore(day: LocalDate, zone: TimeZone): Boolean =
  * visibly settles there.
  */
 fun TimelineDrop.startInstant(zone: TimeZone): Instant =
-    wallClockInstant(date, startMin - clipOffsetMin, zone, kept = zone.repeatedHourOffsetAt(event.start))
+    dropStartInstant(event, date, startMin, clipOffsetMin, zone)
+
+/** Where [event] starts when its block's top edge lands [startMin] past [date]'s midnight — see [TimelineDrop]. */
+internal fun dropStartInstant(
+    event: EventInstance,
+    date: LocalDate,
+    startMin: Int,
+    clipOffsetMin: Int,
+    zone: TimeZone,
+): Instant = wallClockInstant(date, startMin - clipOffsetMin, zone, kept = zone.repeatedHourOffsetAt(event.start))
 
 /**
  * The wall-clock minutes an event lasting [duration] covers when it starts
@@ -1301,6 +1404,7 @@ private const val SETTLE_TIMEOUT_MILLIS = 900L
  */
 const val SETTLE_FADE_MILLIS: Int = 250
 
+
 /**
  * The floating block, drawn over the whole calendar so it is free of the day
  * column's clip and of the scroll viewport's rounded corners.
@@ -1308,12 +1412,10 @@ const val SETTLE_FADE_MILLIS: Int = 250
 @Composable
 fun TimelineDragOverlay(controller: TimelineDragController, modifier: Modifier = Modifier) {
     var origin by remember { mutableStateOf(Offset.Zero) }
-    val density = LocalDensity.current
-    val dark = LocalFloretDarkTheme.current
-    val use24Hour = LocalUse24HourFormat.current
-    val locale = currentLocale()
     val reduceMotion = rememberReduceMotion()
-    val moveInFlight = moveInFlight()
+    val drops = dropStates()
+    val moveInFlight = controller.settledToken in drops.pending
+    val stripInFlight = controller.stripToken in drops.pending
 
     // 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.
@@ -1327,12 +1429,11 @@ fun TimelineDragOverlay(controller: TimelineDragController, modifier: Modifier =
     // recurring drop's scope dialog is up — and then until the grid draws the
     // drop itself.
     var handingOver by remember(controller.settling) { mutableStateOf(false) }
-    val abandoned = abandonedMoves()
+    val abandoned = controller.settledToken in drops.abandoned
     LaunchedEffect(controller.settling, moveInFlight, controller.settledOnGrid, abandoned) {
         if (controller.settling == null || moveInFlight) return@LaunchedEffect
-        // Past the mark this drop was let go on, it was abandoned: nothing will
-        // land and there is nothing to wait for.
-        if (abandoned == controller.settledAbandonedMark) {
+        // An abandoned drop: nothing will land and there is nothing to wait for.
+        if (!abandoned) {
             delay(if (controller.settledOnGrid) SETTLE_GRACE_MILLIS else SETTLE_TIMEOUT_MILLIS)
         }
         handingOver = true
@@ -1342,9 +1443,10 @@ fun TimelineDragOverlay(controller: TimelineDragController, modifier: Modifier =
     }
 
     // The same hold for a bar moved along the all-day strip.
-    LaunchedEffect(controller.stripSettling, moveInFlight, controller.stripSeated, abandoned) {
-        if (controller.stripSettling == null || moveInFlight) return@LaunchedEffect
-        if (abandoned == controller.stripAbandonedMark) {
+    val stripAbandoned = controller.stripToken in drops.abandoned
+    LaunchedEffect(controller.stripSettling, stripInFlight, controller.stripSeated, stripAbandoned) {
+        if (controller.stripSettling == null || stripInFlight) return@LaunchedEffect
+        if (!stripAbandoned) {
             delay(if (controller.stripSeated) SETTLE_GRACE_MILLIS else SETTLE_TIMEOUT_MILLIS)
         }
         controller.releaseStrip()
@@ -1358,6 +1460,12 @@ fun TimelineDragOverlay(controller: TimelineDragController, modifier: Modifier =
             .clearAndSetSemantics { }
             .onGloballyPositioned { origin = it.positionInRoot() },
     ) {
+        controller.held.forEach { parked ->
+            key(parked.token) { HeldTimelineCopy(controller, parked, origin) }
+        }
+        controller.heldStrips.forEach { parked ->
+            key(parked.token) { HeldStripSettle(controller, parked) }
+        }
         val drag = controller.drag ?: controller.settling ?: return@Box
         // Landed: the copy sinks back to the grid's own plane while the write runs.
         val landed = controller.drag == null
@@ -1371,6 +1479,58 @@ fun TimelineDragOverlay(controller: TimelineDragController, modifier: Modifier =
             animationSpec = tween(SETTLE_FADE_MILLIS),
             label = "drag-handover",
         )
+        TimelineCopy(drag, controller.geometry, origin, lift, copyAlpha)
+    }
+}
+
+/**
+ * [TimelineDragController.ghosts] for [block], derived so the block recomposes
+ * only when its own answer changes rather than on every lift, park and release.
+ */
+@Composable
+fun TimelineDragController.ghostsDerived(block: TimedBlock): Boolean {
+    val ghosted by remember(this, block) { derivedStateOf { ghosts(block) } }
+    return ghosted
+}
+
+/** A drop parked by a newer pickup: held at its landing slot until its own write settles. */
+@Composable
+private fun HeldTimelineCopy(controller: TimelineDragController, parked: HeldDrop, origin: Offset) {
+    val alpha = rememberHeldSettle(
+        token = parked.token,
+        seated = parked.seated,
+        timeoutMillis = SETTLE_TIMEOUT_MILLIS,
+        onHandOver = { controller.handOverHeld(parked.token) },
+        onRelease = { controller.releaseHeld(parked.token) },
+    )
+    TimelineCopy(parked.copy, controller.geometry, origin, lift = 0f, copyAlpha = alpha)
+}
+
+/** A strip drop parked by a newer one: shown at its new days until its own write settles. */
+@Composable
+private fun HeldStripSettle(controller: TimelineDragController, parked: HeldStrip) {
+    rememberHeldSettle(
+        token = parked.token,
+        seated = parked.seated,
+        timeoutMillis = SETTLE_TIMEOUT_MILLIS,
+        onHandOver = {},
+        onRelease = { controller.releaseHeldStrip(parked.token) },
+    )
+}
+
+/** [drag]'s pieces drawn over the calendar, clipped to the timeline's viewport. */
+@Composable
+private fun TimelineCopy(
+    drag: TimelineDrag,
+    geometry: TimelineGeometry,
+    origin: Offset,
+    lift: Float,
+    copyAlpha: Float,
+) {
+    val density = LocalDensity.current
+    val dark = LocalFloretDarkTheme.current
+    val use24Hour = LocalUse24HourFormat.current
+    val locale = currentLocale()
         val paint = eventPaint(drag.event, dark)
         val title = drag.event.title.ifBlank { stringResource(R.string.event_untitled) }
         // Read off the event rather than the held block, so grabbing either half
@@ -1386,7 +1546,7 @@ fun TimelineDragOverlay(controller: TimelineDragController, modifier: Modifier =
         // so no column clip or rounded corner cuts it, but it still belongs to
         // the timeline: a piece a whole day tall reaches far past both ends of
         // the viewport, and unclipped it paints over the headers above (#267).
-        val port = controller.geometry.viewport?.takeIf { it.isAttached }?.boundsInRoot()
+        val port = geometry.viewport?.takeIf { it.isAttached }?.boundsInRoot()
         // How much of each piece the viewport actually shows. A multi-day event
         // has a piece per day, and the widest one is a full 24 hours — taller
         // than the screen, its top at a midnight scrolled out of sight. Picking
@@ -1438,7 +1598,6 @@ fun TimelineDragOverlay(controller: TimelineDragController, modifier: Modifier =
                 )
             }
         }
-    }
 }
 
 /** One piece of a dragged block, floating over the calendar. */

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

@@ -0,0 +1,63 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.withoutCalendars
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.retryWhen
+import kotlinx.coroutines.flow.shareIn
+import java.io.IOException
+import kotlin.time.Instant
+
+/** The calendars hidden in [view] under a per-calendar hidden-views map (#270). */
+fun Map<Long, Set<CalendarView>>.calendarsHiddenIn(view: CalendarView): Set<Long> =
+    filterValues { view in it }.keys
+
+/**
+ * The calendars hidden in [view], shared by everything one view model shows so
+ * the setting is read once rather than per page. A failed read hides nothing
+ * rather than failing the view; the replay expires with the last subscriber, so
+ * a returning view filters against a fresh read.
+ */
+fun Flow<Map<Long, Set<CalendarView>>>.calendarsHiddenIn(
+    view: CalendarView,
+    scope: CoroutineScope,
+): Flow<Set<Long>> =
+    hidingNothingOnError()
+        .map { it.calendarsHiddenIn(view) }
+        .distinctUntilChanged()
+        // The grace period outlasts a flatMapLatest swap, so paging doesn't re-read it.
+        .shareIn(scope, SharingStarted.WhileSubscribed(5_000, replayExpirationMillis = 0), replay = 1)
+
+/**
+ * A failed read of the per-view setting hides nothing rather than failing what
+ * shows it, and keeps reading, so the next change still lands.
+ */
+fun Flow<Map<Long, Set<CalendarView>>>.hidingNothingOnError(): Flow<Map<Long, Set<CalendarView>>> =
+    retryWhen { cause, attempt ->
+        if (cause !is IOException) return@retryWhen false
+        emit(emptyMap())
+        // Backs off, so a file that keeps failing (corrupt) isn't re-read every second.
+        delay((RETRY_BASE_DELAY_MS shl attempt.coerceAtMost(6).toInt()).coerceAtMost(RETRY_MAX_DELAY_MS))
+        true
+    }
+
+private const val RETRY_BASE_DELAY_MS = 1_000L
+private const val RETRY_MAX_DELAY_MS = 60_000L
+
+/**
+ * [CalendarRepository.instances] as one view shows them: also without the
+ * [hidden] calendars the user keeps out of it. Display only — reminders, search
+ * and widgets read the repository directly.
+ */
+fun CalendarRepository.instancesWithout(
+    range: ClosedRange<Instant>,
+    hidden: Flow<Set<Long>>,
+): Flow<List<EventInstance>> =
+    combine(instances(range), hidden) { instances, ids -> instances.withoutCalendars(ids) }

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

@@ -4,15 +4,23 @@ import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.FilterList
 import androidx.compose.material3.Checkbox
+import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
@@ -22,20 +30,26 @@ import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.ui.common.CalendarAccountGroup
 import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.accountGroupTitle
 import de.jeanlucmakiola.calendula.ui.common.orUnnamed
 import de.jeanlucmakiola.floret.components.GroupedListInset
 import de.jeanlucmakiola.floret.components.GroupedRow
+import de.jeanlucmakiola.floret.components.Position
 import de.jeanlucmakiola.floret.components.positionOf
 
 /**
  * Calendar-visibility filter (M3), rendered inline in the navigation drawer.
  * Every calendar grouped by account, each with a colour swatch and a visibility
  * switch; toggling writes straight to DataStore and every calendar view
- * re-filters live. Three states (Loading / Failure / Success).
+ * re-filters live. Three states (Loading / Failure / Success). A calendar hidden
+ * in [currentView] through its per-view setting (#270) says so on its row, and
+ * the entry below the list opens that setting for the view (#517).
  */
 @Composable
 fun CalendarFilterList(
+    currentView: CalendarView,
+    onHideInView: () -> Unit,
     modifier: Modifier = Modifier,
     viewModel: FilterViewModel = hiltViewModel(),
 ) {
@@ -43,12 +57,18 @@ fun CalendarFilterList(
     when (val s = state) {
         FilterUiState.Loading -> FilterLoading(modifier)
         is FilterUiState.Failure -> FilterMessage(s.reason, modifier)
-        is FilterUiState.Success -> FilterList(
-            groups = s.groups,
-            hidden = s.hidden,
-            onSetVisible = viewModel::setVisible,
-            modifier = modifier,
-        )
+        is FilterUiState.Success -> {
+            val hiddenInView = remember(s, currentView) { s.hiddenOnlyIn(currentView) }
+            FilterList(
+                groups = s.groups,
+                hidden = s.hidden,
+                hiddenInView = hiddenInView,
+                hiddenOnlyHere = hiddenInView.size,
+                onHideInView = onHideInView,
+                onSetVisible = viewModel::setVisible,
+                modifier = modifier,
+            )
+        }
     }
 }
 
@@ -61,6 +81,9 @@ fun CalendarFilterList(
 private fun FilterList(
     groups: List<CalendarAccountGroup>,
     hidden: Set<Long>,
+    hiddenInView: Set<Long>,
+    hiddenOnlyHere: Int,
+    onHideInView: () -> Unit,
     onSetVisible: (Long, Boolean) -> Unit,
     modifier: Modifier = Modifier,
 ) {
@@ -81,6 +104,7 @@ private fun FilterList(
                 val visible = cal.id !in hidden
                 GroupedRow(
                     title = cal.displayName.orUnnamed(),
+                    summary = if (cal.id in hiddenInView) stringResource(R.string.filter_hidden_in_view) else null,
                     position = positionOf(index, group.calendars.size),
                     minHeight = 56.dp,
                     leading = { CalendarColorChip(cal.color) },
@@ -94,11 +118,32 @@ private fun FilterList(
                 )
             }
         }
+        // The per-view hide (#517): the drawer filter above hides everywhere, this only here.
+        Spacer(Modifier.height(8.dp))
+        GroupedRow(
+            title = stringResource(R.string.view_calendars_title),
+            summary = if (hiddenOnlyHere > 0) {
+                pluralStringResource(R.plurals.drawer_hidden_in_view_count, hiddenOnlyHere, hiddenOnlyHere)
+            } else {
+                stringResource(R.string.drawer_hidden_in_view_none)
+            },
+            position = Position.Alone,
+            minHeight = 56.dp,
+            // Tinted, not "selected": it is an entry point, not a chosen option.
+            container = if (hiddenOnlyHere > 0) MaterialTheme.colorScheme.secondaryContainer else null,
+            contentColor = if (hiddenOnlyHere > 0) MaterialTheme.colorScheme.onSecondaryContainer else null,
+            leading = {
+                Box(Modifier.size(40.dp), contentAlignment = Alignment.Center) {
+                    Icon(Icons.Filled.FilterList, contentDescription = null)
+                }
+            },
+            onClick = onHideInView,
+        )
     }
 }
 
 @Composable
-private fun FilterLoading(modifier: Modifier = Modifier) {
+internal fun FilterLoading(modifier: Modifier = Modifier) {
     Column(
         modifier = modifier.fillMaxWidth(),
         verticalArrangement = Arrangement.spacedBy(8.dp),
@@ -119,7 +164,7 @@ private fun FilterLoading(modifier: Modifier = Modifier) {
 }
 
 @Composable
-private fun FilterMessage(reason: FailureReason, modifier: Modifier = Modifier) {
+internal fun FilterMessage(reason: FailureReason, modifier: Modifier = Modifier) {
     val msg = when (reason) {
         FailureReason.NoCalendarsConfigured -> R.string.state_failure_no_calendars
         FailureReason.AllCalendarsHidden -> R.string.state_failure_all_hidden

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

@@ -2,6 +2,8 @@ package de.jeanlucmakiola.calendula.ui.filter
 
 import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.ui.common.CalendarAccountGroup
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.calendarsHiddenIn
 
 /**
  * State for the calendar-filter sheet (M3). The user toggles per-calendar
@@ -11,9 +13,22 @@ import de.jeanlucmakiola.calendula.ui.common.CalendarAccountGroup
 sealed interface FilterUiState {
     data object Loading : FilterUiState
     data class Failure(val reason: FailureReason) : FilterUiState
-    /** A calendar shows when its id is *not* in [hidden]. */
+    /**
+     * A calendar shows when its id is *not* in [hidden]; [hiddenViews] are the
+     * views each calendar is hidden in regardless (#270).
+     */
     data class Success(
         val groups: List<CalendarAccountGroup>,
         val hidden: Set<Long>,
-    ) : FilterUiState
+        val hiddenViews: Map<Long, Set<CalendarView>> = emptyMap(),
+    ) : FilterUiState {
+        /**
+         * The listed calendars [view] hides on its own (#517); ones already
+         * hidden everywhere from the drawer, or not listed, aren't included.
+         */
+        fun hiddenOnlyIn(view: CalendarView): Set<Long> {
+            val listed = groups.flatMapTo(mutableSetOf()) { group -> group.calendars.map { it.id } }
+            return hiddenViews.calendarsHiddenIn(view).filterTo(mutableSetOf()) { it in listed && it !in hidden }
+        }
+    }
 }

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

@@ -1,15 +1,20 @@
 package de.jeanlucmakiola.calendula.ui.filter
 
+import android.util.Log
 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.prefs.CalendarPrefs
+import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.domain.calendarListFailure
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.hidingNothingOnError
 import de.jeanlucmakiola.calendula.ui.common.groupByAccount
 import de.jeanlucmakiola.floret.android.stateWhileSubscribed
 import de.jeanlucmakiola.floret.di.IoDispatcher
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.catch
@@ -23,6 +28,7 @@ import javax.inject.Inject
 class FilterViewModel @Inject constructor(
     private val repository: CalendarRepository,
     private val prefs: CalendarPrefs,
+    private val settingsPrefs: SettingsPrefs,
     @IoDispatcher private val io: CoroutineDispatcher,
 ) : ViewModel() {
 
@@ -30,7 +36,9 @@ class FilterViewModel @Inject constructor(
         combine(
             repository.calendars(),
             prefs.hiddenCalendarIds,
-        ) { calendars, hidden ->
+            // Only feeds a note on the rows; a failed read leaves it off rather than failing the list.
+            settingsPrefs.perCalendarHiddenViews.hidingNothingOnError(),
+        ) { calendars, hidden, hiddenViews ->
             // Calendars switched off device-wide don't belong in the drawer's
             // hide/show list; they live only in Settings → Calendars.
             val enabled = calendars.filter { it.isVisibleInSystem }
@@ -38,7 +46,7 @@ class FilterViewModel @Inject constructor(
             if (failure != null) {
                 FilterUiState.Failure(failure)
             } else {
-                FilterUiState.Success(enabled.groupByAccount(), hidden)
+                FilterUiState.Success(enabled.groupByAccount(), hidden, hiddenViews)
             }
         }
             .catch { emit(FilterUiState.Failure(FailureReason.ProviderUnavailable)) }
@@ -48,6 +56,19 @@ class FilterViewModel @Inject constructor(
                 initialValue = FilterUiState.Loading,
             )
 
+    /** Hide or show one calendar in [view] only (#517), the same setting as Settings → Calendars. */
+    fun setHiddenIn(calendarId: Long, view: CalendarView, hidden: Boolean) {
+        viewModelScope.launch {
+            try {
+                settingsPrefs.setCalendarHiddenIn(calendarId, view, hidden)
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                Log.w("FilterViewModel", "Could not change hidden views of $calendarId", e)
+            }
+        }
+    }
+
     /** Show or hide a single calendar; persists the new hidden set. */
     fun setVisible(calendarId: Long, visible: Boolean) {
         viewModelScope.launch {

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

@@ -0,0 +1,65 @@
+package de.jeanlucmakiola.calendula.ui.filter
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.accountGroupTitle
+import de.jeanlucmakiola.calendula.ui.common.calendarsHiddenIn
+import de.jeanlucmakiola.calendula.ui.common.orUnnamed
+import de.jeanlucmakiola.floret.components.FullScreenPicker
+import de.jeanlucmakiola.floret.components.GroupedHint
+import de.jeanlucmakiola.floret.components.GroupedSectionHeader
+import de.jeanlucmakiola.floret.components.MultiOptionRows
+
+/**
+ * The calendars hidden in [view] (#517), opened from the drawer while on it: the
+ * per-view setting from Settings → Calendars (#270), seen from the view's side.
+ * Toggles apply at once.
+ */
+@Composable
+fun ViewCalendarsPicker(
+    view: CalendarView,
+    state: FilterUiState,
+    onSetHidden: (calendarId: Long, hidden: Boolean) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    FullScreenPicker(
+        title = stringResource(R.string.view_calendars_title),
+        onDismiss = onDismiss,
+        predictiveBack = true,
+    ) {
+        when (state) {
+            FilterUiState.Loading -> FilterLoading()
+            is FilterUiState.Failure -> FilterMessage(state.reason)
+            is FilterUiState.Success -> {
+                // Seeded once, then ahead of the store: the picker is the only
+                // writer while open, so a quick second tap still flips.
+                var hidden by remember(view) { mutableStateOf(state.hiddenViews.calendarsHiddenIn(view)) }
+                GroupedHint(stringResource(R.string.view_calendars_hint), verticalPadding = 8.dp)
+                state.groups.forEach { group ->
+                    GroupedSectionHeader(accountGroupTitle(group))
+                    MultiOptionRows(
+                        options = group.calendars,
+                        selected = group.calendars.filterTo(mutableSetOf()) { it.id in hidden },
+                        label = { it.displayName.orUnnamed() },
+                        onToggle = { calendar, hide ->
+                            hidden = if (hide) hidden + calendar.id else hidden - calendar.id
+                            onSetHidden(calendar.id, hide)
+                        },
+                        summary = { calendar ->
+                            if (calendar.id in state.hidden) stringResource(R.string.view_calendars_hidden_everywhere) else null
+                        },
+                        leading = { CalendarColorChip(it.color) },
+                    )
+                }
+            }
+        }
+    }
+}

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

@@ -14,8 +14,7 @@ import androidx.compose.ui.layout.boundsInRoot
 import androidx.compose.ui.layout.positionInRoot
 import androidx.compose.ui.unit.IntSize
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
-import kotlinx.coroutines.flow.StateFlow
+import de.jeanlucmakiola.calendula.ui.common.nextMoveToken
 import kotlinx.datetime.LocalDate
 import kotlin.math.abs
 
@@ -107,11 +106,22 @@ data class MonthChipDrag(
     val time: String? = null,
 )
 
+/** A drop parked by a newer pickup while its write still runs — see [MonthDragController.held]. */
+data class HeldChip(
+    val copy: MonthChipDrag,
+    val token: Long,
+    val handedOver: Boolean = false,
+    /** Where the grid now draws the drop, in root coordinates, once a row seats it. */
+    val seat: Offset? = null,
+)
+
 /** Where a finished chip drag asks its event to go, as a whole-day shift. */
 data class MonthChipDrop(
     val event: EventInstance,
     val grabDate: LocalDate,
     val targetDate: LocalDate,
+    /** The drop's identity, which its held copy waits on — see [MonthDragController.settledToken]. */
+    val token: Long,
 )
 
 /**
@@ -167,19 +177,22 @@ class MonthDragController {
         private set
 
     /**
-     * The last drop this controller made, kept past [release] for [beginUndo] —
-     * the confirmation chip carries Undo long after the copy is gone.
+     * This controller's recent drops by token, kept past [release] for
+     * [beginUndo] — the confirmation chip carries Undo long after the copy is
+     * gone, and it may be any of them the chip offers to undo.
      */
-    private var undoable: MonthChipDrag? = null
+    private val undoable = LinkedHashMap<Long, MonthChipDrag>()
 
     /**
-     * The abandoned-move counter, read at the drop so the mark can't be a
-     * composition behind the tick it is compared against.
+     * Earlier drops still being written when another chip was picked up. They
+     * keep their copy and their ghost until their own token settles, rather than
+     * vanishing and flashing back on the old day (#494).
      */
-    var abandonedTicks: StateFlow<Int>? = null
+    var held: List<HeldChip> by mutableStateOf(emptyList())
+        private set
 
-    /** What [abandonedTicks] stood at when the settling chip was let go. */
-    var settledAbandonedMark: Int = 0
+    /** The token of the drop (or undo) [settling] is waiting on. */
+    var settledToken: Long = 0L
         private set
 
     private var event: EventInstance? = null
@@ -208,7 +221,7 @@ class MonthDragController {
         this.event = event
         this.grabDate = grabDate
         this.time = time
-        settling = null
+        parkSettling()
         isDragging = true
         liftedInstanceId = event.instanceId
         grab = pointerInRoot - chipInRoot
@@ -234,6 +247,39 @@ class MonthDragController {
         settledGhost = false
     }
 
+    /**
+     * Whether [event]'s chip belongs to a held drop and must stay a ghost: its
+     * source, or once a row seats it, the chip the grid draws on its target day.
+     */
+    fun isHeldChip(event: EventInstance, days: List<LocalDate>?): Boolean = held.any { parked ->
+        !parked.handedOver && (
+            parked.copy.event.instanceId == event.instanceId ||
+                (
+                    parked.seat != null && days != null && parked.copy.targetDate in days &&
+                        isSameEvent(event, parked.copy.event)
+                    )
+            )
+    }
+
+    /** Move a still-settling drop to [held] before a new pickup takes the slot. */
+    private fun parkSettling() {
+        val landed = settling
+        if (landed != null) held = held + HeldChip(landed, settledToken)
+        settling = null
+        settledInRoot = null
+        settledGhost = false
+    }
+
+    /** Stop ghosting the held drop [token]'s source while its copy fades. */
+    fun handOverHeld(token: Long) {
+        held = held.map { if (it.token == token) it.copy(handedOver = true) else it }
+    }
+
+    /** Drop the held copy [token] once it has faded. */
+    fun releaseHeld(token: Long) {
+        held = held.filterNot { it.token == token }
+    }
+
     /**
      * Whether [days] holds the chip the grid has drawn for the settled drop —
      * the seat the copy is on its way to, which must ghost until it gets there.
@@ -250,6 +296,13 @@ class MonthDragController {
      * nearest where the chip was let go is the one the finger was over.
      */
     fun noteSettled(token: Any) {
+        val row = rows[token]
+        if (row != null && held.any { it.seat == null }) {
+            held = held.map { parked ->
+                val target = parked.copy.targetDate
+                if (parked.seat != null || target == null) parked else parked.copy(seat = row.seatOf(parked.copy.event, target))
+            }
+        }
         val landed = settling ?: return
         val target = landed.targetDate ?: return
         val at = rows[token]?.seatOf(landed.event, target) ?: return
@@ -265,16 +318,16 @@ class MonthDragController {
      * there is no drop of this controller's left to undo, or the grid doesn't
      * seat the moved event where the chip would have to start from.
      */
-    fun beginUndo(): Boolean {
-        val last = undoable ?: return false
-        undoable = null
+    fun beginUndo(token: Long, dropToken: Long): Boolean {
+        val last = undoable.remove(dropToken) ?: return false
+        parkSettling()
         val from = last.targetDate ?: return false
         val at = rows.values.firstNotNullOfOrNull { it.seatOf(last.event, from) } ?: return false
         settling = last.copy(grabDate = from, targetDate = last.grabDate, topLeftInRoot = at)
         liftedInstanceId = last.event.instanceId
         settledGhost = true
         settledInRoot = null
-        settledAbandonedMark = abandonedTicks?.value ?: 0
+        settledToken = token
         return true
     }
 
@@ -294,10 +347,11 @@ class MonthDragController {
         )
         liftedInstanceId = landed.event.instanceId
         settledGhost = true
-        undoable = settling
-        settledAbandonedMark = abandonedTicks?.value ?: 0
+        settledToken = nextMoveToken()
+        undoable[settledToken] = requireNotNull(settling)
+        if (undoable.size > UNDOABLE_KEPT) undoable.remove(undoable.keys.first())
         drops++
-        return MonthChipDrop(landed.event, landed.grabDate, target)
+        return MonthChipDrop(landed.event, landed.grabDate, target, settledToken)
     }
 
     /**
@@ -355,9 +409,10 @@ class MonthDragController {
 
 @Composable
 fun rememberMonthDragController(): MonthDragController {
-    val controller = remember { MonthDragController() }
-    controller.abandonedTicks = LocalEventMove.current?.abandoned
-    return controller
+    return remember { MonthDragController() }
 }
 
 val LocalMonthDrag = compositionLocalOf<MonthDragController?> { null }
+
+/** How many recent drops a month controller keeps for an undo to carry back. */
+private const val UNDOABLE_KEPT = 8

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

@@ -125,11 +125,11 @@ import de.jeanlucmakiola.calendula.ui.common.eventTitleOverflow
 import de.jeanlucmakiola.calendula.ui.common.MoveTarget
 import de.jeanlucmakiola.calendula.ui.common.MoveRequest
 import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
-import de.jeanlucmakiola.calendula.ui.common.moveInFlight
-import de.jeanlucmakiola.calendula.ui.common.abandonedMoves
+import de.jeanlucmakiola.calendula.ui.common.dropStates
 import de.jeanlucmakiola.calendula.ui.common.OnUndoStarted
 import de.jeanlucmakiola.calendula.ui.common.ghostAlpha
 import de.jeanlucmakiola.calendula.ui.common.DragSnapHaptics
+import de.jeanlucmakiola.calendula.ui.common.rememberHeldSettle
 import de.jeanlucmakiola.calendula.ui.common.SETTLE_FADE_MILLIS
 import de.jeanlucmakiola.calendula.ui.common.SETTLE_GRACE_MILLIS
 import de.jeanlucmakiola.calendula.ui.common.EventMoveScope
@@ -515,7 +515,7 @@ fun MonthScreen(
         val chipDrag = rememberMonthDragController()
         // Undo moves the event back, so the chip travels back too. The
         // signal comes from the write, not from the chip that offers it.
-        OnUndoStarted { chipDrag.beginUndo() }
+        OnUndoStarted { start -> chipDrag.beginUndo(start.token, start.dropToken) }
         Box(
             modifier = Modifier
                 .padding(innerPadding)
@@ -591,11 +591,11 @@ private const val MONTH_SETTLE_TIMEOUT_MILLIS = 450L
 @Composable
 private fun MonthDragOverlay(controller: MonthDragController, showStartTimes: Boolean) {
     var origin by remember { mutableStateOf(Offset.Zero) }
-    val dark = LocalFloretDarkTheme.current
-    val density = LocalDensity.current
     val timeFit = rememberMonthChipTimeFit(showStartTimes)
     val reduceMotion = rememberReduceMotion()
-    val moveInFlight = moveInFlight()
+    val drops = dropStates()
+    val moveInFlight = controller.settledToken in drops.pending
+    val abandoned = controller.settledToken in drops.abandoned
     // Here rather than beside the controller: this reads [drag], which changes
     // every frame, and this composable is the one that is meant to.
     DragSnapHaptics(controller.drag?.targetDate, controller.drops)
@@ -608,14 +608,12 @@ private fun MonthDragOverlay(controller: MonthDragController, showStartTimes: Bo
     val glide = remember { Animatable(Offset.Zero, Offset.VectorConverter) }
     val glideSpec = MaterialTheme.motionScheme.fastSpatialSpec<Offset>()
     val seat = controller.settledInRoot
-    val abandoned = abandonedMoves()
     LaunchedEffect(controller.settling, moveInFlight, seat, abandoned) {
         val landed = controller.settling
         if (landed == null || moveInFlight) return@LaunchedEffect
         if (seat == null) {
-            // Past the mark this drop was let go on, it was abandoned and no
-            // seat is ever coming.
-            if (abandoned == controller.settledAbandonedMark) delay(MONTH_SETTLE_TIMEOUT_MILLIS)
+            // An abandoned drop has no seat coming.
+            if (!abandoned) delay(MONTH_SETTLE_TIMEOUT_MILLIS)
         } else {
             if (!gliding) glide.snapTo(landed.topLeftInRoot)
             gliding = true
@@ -635,6 +633,9 @@ private fun MonthDragOverlay(controller: MonthDragController, showStartTimes: Bo
             .clearAndSetSemantics { }
             .onGloballyPositioned { origin = it.positionInRoot() },
     ) {
+        controller.held.forEach { parked ->
+            key(parked.token) { HeldMonthChip(controller, parked, origin, timeFit) }
+        }
         val drag = controller.drag ?: controller.settling ?: return@Box
         // Landed: the copy sinks back to the grid's own plane while the write runs.
         val lift by animateFloatAsState(
@@ -646,42 +647,93 @@ private fun MonthDragOverlay(controller: MonthDragController, showStartTimes: Bo
             animationSpec = tween(SETTLE_FADE_MILLIS),
             label = "chip-handover",
         )
-        MonthBar(
-            event = drag.event,
-            dark = dark,
-            continuesLeft = false,
-            continuesRight = false,
-            // The time the source chip carried, drawn only if this one-column
-            // cut-out of it has the room — which a slice of a multi-day bar has
-            // not, however wide the bar was.
-            time = drag.time,
+        MonthChipCopy(
+            drag = drag,
+            // Read at layout, so the glide doesn't recompose every frame.
+            at = { if (gliding) glide.value else drag.topLeftInRoot },
+            origin = origin,
+            lift = lift,
+            alpha = copyAlpha,
             timeFit = timeFit,
-            chipWidth = with(density) { drag.sizePx.width.toDp() },
-            modifier = Modifier
-                // Absolute: these are root coordinates, and the direction-aware
-                // offset would mirror them across the screen in an RTL layout.
-                .absoluteOffset {
-                    val at = if (gliding) glide.value else drag.topLeftInRoot
-                    IntOffset(
-                        (at.x - origin.x).roundToInt(),
-                        (at.y - origin.y).roundToInt(),
-                    )
-                }
-                .width(with(density) { drag.sizePx.width.toDp() })
-                .height(with(density) { drag.sizePx.height.toDp() })
-                .padding(horizontal = MONTH_CHIP_INSET, vertical = 1.dp)
-                .graphicsLayer {
-                    scaleX = 1f + 0.04f * lift
-                    scaleY = 1f + 0.04f * lift
-                    shadowElevation = 8.dp.toPx() * lift
-                    alpha = copyAlpha
-                    shape = EventChipShape
-                    clip = false
-                },
         )
     }
 }
 
+/** A drop parked by a newer pickup: held on its landing day until its own write settles. */
+@Composable
+private fun HeldMonthChip(
+    controller: MonthDragController,
+    parked: HeldChip,
+    origin: Offset,
+    timeFit: MonthChipTimeFit?,
+) {
+    val reduceMotion = rememberReduceMotion()
+    val glide = remember { Animatable(parked.copy.topLeftInRoot, Offset.VectorConverter) }
+    val glideSpec = MaterialTheme.motionScheme.fastSpatialSpec<Offset>()
+    val seat = parked.seat
+    val landed = parked.token !in dropStates().pending
+    // Carried onto its seat once the write is in, as the settling chip is.
+    LaunchedEffect(seat, landed) {
+        if (seat == null || !landed) return@LaunchedEffect
+        if (reduceMotion) glide.snapTo(seat) else glide.animateTo(seat, glideSpec)
+    }
+    val alpha = rememberHeldSettle(
+        token = parked.token,
+        seated = seat != null,
+        timeoutMillis = MONTH_SETTLE_TIMEOUT_MILLIS,
+        onHandOver = { controller.handOverHeld(parked.token) },
+        onRelease = { controller.releaseHeld(parked.token) },
+    )
+    MonthChipCopy(parked.copy, { glide.value }, origin, lift = 0f, alpha = alpha, timeFit = timeFit)
+}
+
+/** [drag]'s chip floating over the grid with its top left at [at], in root coordinates. */
+@Composable
+private fun MonthChipCopy(
+    drag: MonthChipDrag,
+    at: () -> Offset,
+    origin: Offset,
+    lift: Float,
+    alpha: Float,
+    timeFit: MonthChipTimeFit?,
+) {
+    val density = LocalDensity.current
+    val dark = LocalFloretDarkTheme.current
+    MonthBar(
+        event = drag.event,
+        dark = dark,
+        continuesLeft = false,
+        continuesRight = false,
+        // The time the source chip carried, drawn only if this one-column
+        // cut-out of it has the room — which a slice of a multi-day bar has
+        // not, however wide the bar was.
+        time = drag.time,
+        timeFit = timeFit,
+        chipWidth = with(density) { drag.sizePx.width.toDp() },
+        modifier = Modifier
+            // Absolute: these are root coordinates, and the direction-aware
+            // offset would mirror them across the screen in an RTL layout.
+            .absoluteOffset {
+                val topLeft = at()
+                IntOffset(
+                    (topLeft.x - origin.x).roundToInt(),
+                    (topLeft.y - origin.y).roundToInt(),
+                )
+            }
+            .width(with(density) { drag.sizePx.width.toDp() })
+            .height(with(density) { drag.sizePx.height.toDp() })
+            .padding(horizontal = MONTH_CHIP_INSET, vertical = 1.dp)
+            .graphicsLayer {
+                scaleX = 1f + 0.04f * lift
+                scaleY = 1f + 0.04f * lift
+                shadowElevation = 8.dp.toPx() * lift
+                this.alpha = alpha
+                shape = EventChipShape
+                clip = false
+            },
+    )
+}
+
 /**
  * Content for both scrolling styles. No swipe detector and no [AnimatedContent]:
  * vertical scrolling owns the gesture, and the list never swaps wholesale — it
@@ -2258,7 +2310,7 @@ private fun MonthWeekRow(
     // Once the grid holds the settled chip, tell the controller where this row
     // has seated it, so the copy in flight can glide onto it. Keyed on the week,
     // which is what changes when the re-read lands.
-    LaunchedEffect(week, dragController?.settling) {
+    LaunchedEffect(week, dragController?.settling, dragController?.held) {
         dragController?.noteSettled(rowToken)
     }
 
@@ -2691,6 +2743,8 @@ private fun monthChipDragModifier(
                     beginMillis = drop.event.start.toEpochMilliseconds(),
                     endMillis = drop.event.end.toEpochMilliseconds(),
                     target = MoveTarget.ByDays(delta),
+                    isAllDay = drop.event.isAllDay,
+                    token = drop.token,
                 ),
             )
         }
@@ -2836,8 +2890,17 @@ private fun MonthBar(
     val moveAction = eventMoveAction(event)
     // The source stays put as a ghost while its floating copy travels.
     val monthDrag = LocalMonthDrag.current
-    val lifted = monthDrag?.liftedInstanceId == event.instanceId ||
-        monthDrag?.isSettledChip(event, days) == true
+    // Derived, so a chip recomposes only when its own answer changes rather than
+    // on every lift, park and release anywhere in the grid.
+    val lifted by remember(monthDrag, event, days) {
+        derivedStateOf {
+            monthDrag != null && (
+                monthDrag.liftedInstanceId == event.instanceId ||
+                    monthDrag.isSettledChip(event, days) ||
+                    monthDrag.isHeldChip(event, days)
+                )
+        }
+    }
     val ghost = ghostAlpha(lifted)
     val shape = monthBarShape(continuesLeft, continuesRight)
     Box(

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

@@ -19,7 +19,10 @@ import de.jeanlucmakiola.calendula.domain.calendarListFailure
 import de.jeanlucmakiola.calendula.ui.agenda.AgendaDay
 import de.jeanlucmakiola.calendula.ui.agenda.anchorTodayIfMissing
 import de.jeanlucmakiola.calendula.ui.common.CalendarSpan
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.PageStateCache
+import de.jeanlucmakiola.calendula.ui.common.calendarsHiddenIn
+import de.jeanlucmakiola.calendula.ui.common.instancesWithout
 import de.jeanlucmakiola.calendula.domain.isCrossedOut
 import de.jeanlucmakiola.calendula.domain.sortedForDisplay
 import de.jeanlucmakiola.calendula.ui.week.coversDay
@@ -68,6 +71,8 @@ class MonthViewModel @Inject constructor(
 
     private val zone = TimeZone.currentSystemDefault()
 
+    private val hiddenHere = settingsPrefs.perCalendarHiddenViews.calendarsHiddenIn(CalendarView.Month, viewModelScope)
+
     /** First day of the week, from the Settings preference (AUTO → locale). */
     val weekStart: StateFlow<DayOfWeek> = settingsPrefs.firstDayOfWeek(viewModelScope)
 
@@ -152,7 +157,7 @@ class MonthViewModel @Inject constructor(
     ) { (ym, ws) ->
         combine(
             repository.calendars(),
-            repository.instances(monthGridRange(ym, ws, zone)),
+            repository.instancesWithout(monthGridRange(ym, ws, zone), hiddenHere),
             today,
         ) { calendars, instances, today ->
             buildState(ym, ws, calendars, instances, today)
@@ -224,7 +229,7 @@ class MonthViewModel @Inject constructor(
                 val range = dayRange(first, last, zone)
                 combine(
                     repository.calendars(),
-                    repository.instances(range),
+                    repository.instancesWithout(range, hiddenHere),
                     today,
                 ) { calendars, instances, today ->
                     buildContinuousState(window, ws, style, calendars, instances, today)

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

@@ -89,7 +89,7 @@ internal fun CalendarsStep(
             initialName = "",
             initialColor = CalendarColorPalette.all.first(),
             initialDescription = "",
-            onSave = { name, color, description ->
+            onSave = { name, color, description, _ ->
                 if (!submitted) {
                     submitted = true
                     onCreateLocal(name, color, description)

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

@@ -157,6 +157,7 @@ import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
 import de.jeanlucmakiola.calendula.ui.common.MoveRequest
 import de.jeanlucmakiola.calendula.ui.common.MoveTarget
 import de.jeanlucmakiola.calendula.ui.common.TimelineDragController
+import de.jeanlucmakiola.calendula.ui.common.ghostsDerived
 import de.jeanlucmakiola.calendula.ui.common.StripDrag
 import de.jeanlucmakiola.calendula.ui.common.StripDrop
 import de.jeanlucmakiola.calendula.ui.common.TimelineDragOverlay
@@ -310,14 +311,6 @@ internal enum class TimelineKind(
     // A run of days often straddles two weeks, so no single number fits it.
     MultiDay(showWeekNumber = false, todayText = R.string.week_today_action, headerBias = 0f),
     Day(showWeekNumber = false, todayText = R.string.day_today_action, headerBias = -1f),
-    ;
-
-    fun title(start: LocalDate, end: LocalDate, locale: Locale, currentYear: Int, abbreviated: Boolean): String =
-        if (this == Day) {
-            formatDayTitle(start, locale, currentYear, abbreviated)
-        } else {
-            formatWeekTitle(start, end, locale, currentYear, abbreviated)
-        }
 }
 
 internal val CalendarView.timelineKind: TimelineKind
@@ -492,9 +485,10 @@ private fun PagedTimelineScreen(
     val jumpToToday = { jumpToDate(today) }
 
     val locale = currentLocale()
-    val (title, shortTitle) = remember(titleKind, weekStart, weekEnd, locale, today.year) {
-        titleKind.title(weekStart, weekEnd, locale, today.year, abbreviated = false) to
-            titleKind.title(weekStart, weekEnd, locale, today.year, abbreviated = true)
+    // The day view names the month too: its header already shows weekday and date (#501).
+    val (title, shortTitle) = remember(weekStart, weekEnd, locale, today.year) {
+        formatTimelineTitle(weekStart, weekEnd, locale, today.year, abbreviated = false) to
+            formatTimelineTitle(weekStart, weekEnd, locale, today.year, abbreviated = true)
     }
     PublishChrome(
         ScreenChrome(
@@ -591,7 +585,9 @@ private fun WeekContent(
                 eventId = drop.event.eventId,
                 beginMillis = drop.event.start.toEpochMilliseconds(),
                 endMillis = drop.event.end.toEpochMilliseconds(),
+                isAllDay = drop.event.isAllDay,
                 target = MoveTarget.Start(start),
+                token = drop.token,
             ),
         )
     }
@@ -610,7 +606,9 @@ private fun WeekContent(
                 eventId = drop.event.eventId,
                 beginMillis = drop.event.start.toEpochMilliseconds(),
                 endMillis = drop.event.end.toEpochMilliseconds(),
+                isAllDay = drop.event.isAllDay,
                 target = MoveTarget.Span(drop.start, drop.end),
+                token = drop.token,
             ),
         )
     }
@@ -622,10 +620,12 @@ private fun WeekContent(
                 eventId = drop.event.eventId,
                 beginMillis = drop.event.start.toEpochMilliseconds(),
                 endMillis = drop.event.end.toEpochMilliseconds(),
+                isAllDay = drop.event.isAllDay,
                 target = when (drop) {
                     is StripDrop.Days -> MoveTarget.ByDays(drop.days)
                     is StripDrop.Timed -> MoveTarget.Span(drop.start, drop.end)
                 },
+                token = drop.token,
             ),
         )
     }
@@ -767,8 +767,7 @@ private fun WeekPager(
             // Until its days arrive a page shows their frame without events.
             val empty = remember(pageSpan, today) { emptySpan(pageSpan, today) }
             // A bar held over other days in the strip makes room there before it is dropped.
-            val held = (dragController.stripDrag ?: dragController.stripSettling)
-                ?.takeIf { page == pagerState.currentPage }
+            val held = dragController.stripPreviews().takeIf { page == pagerState.currentPage }.orEmpty()
             val zone = LocalTimelineZone.current
             val shown = remember(loaded, held, zone) { loaded?.withStripPreview(held, zone) }
             val stripHeight = shown?.allDayStripHeight()
@@ -793,17 +792,24 @@ private fun WeekPager(
 }
 
 /**
- * [this] with the strip bar [held] sideways laid out at the days it is over, so
- * the bars there move aside live. The bar keeps its own event, and with it its
- * key and the gesture on it; one moved off the page keeps a lane it is not seen in.
+ * [this] with the strip bars [held] sideways laid out at the days they are over,
+ * so the bars there move aside live. Each bar keeps its own event, and with it
+ * its key and the gesture on it; one moved off the page keeps a lane it is not
+ * seen in.
  */
-internal fun WeekUiState.Success.withStripPreview(held: StripDrag?, zone: TimeZone): WeekUiState.Success {
-    if (held == null || held.overGrid || held.dayShift == 0) return this
-    val id = held.event.instanceId
-    val original = allDaySpans.firstOrNull { it.event.instanceId == id } ?: return this
-    val events = allDaySpans.map { if (it.event.instanceId == id) it.event.shiftedDays(held.dayShift, zone) else it.event }
-    val spans = layoutAllDay(events, days, zone).map { if (it.event.instanceId == id) it.copy(event = original.event) else it }
-    return copy(allDaySpans = if (spans.any { it.event.instanceId == id }) spans else spans + original.copy(lane = 0))
+internal fun WeekUiState.Success.withStripPreview(held: List<StripDrag>, zone: TimeZone): WeekUiState.Success {
+    val shifts = held.filter { !it.overGrid && it.dayShift != 0 }.associate { it.event.instanceId to it.dayShift }
+    if (shifts.isEmpty()) return this
+    val originals = allDaySpans.filter { it.event.instanceId in shifts }.associateBy { it.event.instanceId }
+    if (originals.isEmpty()) return this
+    val events = allDaySpans.map { span ->
+        shifts[span.event.instanceId]?.let { span.event.shiftedDays(it, zone) } ?: span.event
+    }
+    val spans = layoutAllDay(events, days, zone).map { span ->
+        originals[span.event.instanceId]?.let { span.copy(event = it.event) } ?: span
+    }
+    val laidOut = spans.mapTo(HashSet()) { it.event.instanceId }
+    return copy(allDaySpans = spans + originals.values.filter { it.event.instanceId !in laidOut }.map { it.copy(lane = 0) })
 }
 
 private fun EventInstance.shiftedDays(days: Int, zone: TimeZone): EventInstance {
@@ -811,6 +817,17 @@ private fun EventInstance.shiftedDays(days: Int, zone: TimeZone): EventInstance
     return copy(start = start.plus(days, DateTimeUnit.DAY, dates), end = end.plus(days, DateTimeUnit.DAY, dates))
 }
 
+/** Whether these bars draw the strip drop [drop] at the days it was dropped on. */
+private fun List<PlacedBar>.drawStripDrop(drop: StripDrag, zone: TimeZone): Boolean {
+    val target = drop.event.spanFirstDay(zone).plus(drop.dayShift, DateTimeUnit.DAY)
+    return any { bar ->
+        bar.event.instanceId != drop.event.instanceId &&
+            (bar.event.eventId == drop.event.eventId ||
+                (drop.event.title.isNotBlank() && bar.event.title == drop.event.title)) &&
+            bar.event.spanFirstDay(zone) == target
+    }
+}
+
 /** A page with no events yet, for one whose days are still loading. */
 private fun emptySpan(span: DaySpan, today: LocalDate): WeekUiState.Success {
     val days = (0 until span.count).map { span.start.plus(it, kotlinx.datetime.DateTimeUnit.DAY) }
@@ -1193,17 +1210,11 @@ private fun AllDayStrip(
     val sideways = held?.takeIf { !it.overGrid }
     val lifted = dragController.liftedInstanceId?.takeIf { active && dragController.stripDrag?.overGrid != false }
     val settling = dragController.stripSettling?.takeIf { active }
+    val heldStrips = dragController.heldStrips.takeIf { active }.orEmpty()
     // Seated once the re-read draws the event at the days it was dropped on.
-    LaunchedEffect(settling, bars) {
-        if (settling == null) return@LaunchedEffect
-        val target = settling.event.spanFirstDay(zone).plus(settling.dayShift, DateTimeUnit.DAY)
-        val landed = bars.any { bar ->
-            bar.event.instanceId != settling.event.instanceId &&
-                (bar.event.eventId == settling.event.eventId ||
-                    (settling.event.title.isNotBlank() && bar.event.title == settling.event.title)) &&
-                bar.event.spanFirstDay(zone) == target
-        }
-        if (landed) dragController.seatStrip()
+    LaunchedEffect(settling, heldStrips, bars) {
+        if (settling != null && bars.drawStripDrop(settling, zone)) dragController.seatStrip()
+        heldStrips.forEach { if (!it.seated && bars.drawStripDrop(it.drag, zone)) dragController.seatHeldStrip(it.token) }
     }
 
     Row(
@@ -1588,7 +1599,7 @@ private fun DayColumnCard(
                         widthFraction = 1f / block.laneCount,
                         y = top,
                         height = height,
-                        landing = dragController.ghosts(block),
+                        landing = dragController.ghostsDerived(block),
                     )
                     val topInset = hourCellBlockInset(showHourGrid, cuts.top)
                     val bottomInset = hourCellBlockInset(showHourGrid, cuts.bottom)
@@ -1756,7 +1767,7 @@ private fun EventBlock(
         onCancel = dragController::cancel,
         onRelease = { dragController.select(block.event, fromLift = draggable) },
     )
-    val lifted = draggable && dragController.ghosts(block)
+    val lifted = draggable && dragController.ghostsDerived(block)
     // 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)
@@ -2016,7 +2027,7 @@ private fun minToHm(min: Int, is24Hour: Boolean, locale: java.util.Locale): Stri
     formatMinuteOfDay(min, is24Hour, locale)
 
 /**
- * The week's title: just the month [weekStart] falls in.
+ * Every timeline's title, the day view's included: just the month [weekStart] falls in.
  *
  * The day numbers are already in the column headers directly below, so spelling
  * out "13.–19. Jul" restates them in the widest string in the bar. Naming the
@@ -2031,7 +2042,7 @@ private fun minToHm(min: Int, is24Hour: Boolean, locale: java.util.Locale): Stri
  * "December" with no year would be actively misleading while the reader is
  * looking straight at January dates.
  */
-private fun formatWeekTitle(
+private fun formatTimelineTitle(
     weekStart: LocalDate,
     weekEnd: LocalDate,
     locale: Locale,
@@ -2046,17 +2057,3 @@ private fun formatWeekTitle(
         forceYear = weekEnd.year != weekStart.year,
     )
 }
-
-/** The day's title: its weekday and date, abbreviated to the date alone when short of room. */
-private fun formatDayTitle(
-    date: LocalDate,
-    locale: Locale,
-    currentYear: Int,
-    abbreviated: Boolean = false,
-): String =
-    formatCalendarTitle(
-        date = date.toJavaLocalDate(),
-        locale = locale,
-        currentYear = currentYear,
-        skeleton = if (abbreviated) "dMMM" else "EEEdMMM",
-    )

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

@@ -19,7 +19,10 @@ import de.jeanlucmakiola.calendula.domain.displayPriority
 import de.jeanlucmakiola.calendula.domain.displayStart
 import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.domain.calendarListFailure
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.PageStateCache
+import de.jeanlucmakiola.calendula.ui.common.calendarsHiddenIn
+import de.jeanlucmakiola.calendula.ui.common.instancesWithout
 import de.jeanlucmakiola.floret.android.stateWhileSubscribed
 import de.jeanlucmakiola.floret.di.IoDispatcher
 import kotlinx.coroutines.CoroutineDispatcher
@@ -89,8 +92,11 @@ abstract class PagedTimelineViewModel(
     private val io: CoroutineDispatcher,
     gridRule: Flow<(LocalDate) -> DaysGrid>,
     initialRule: (LocalDate) -> DaysGrid,
+    view: CalendarView,
 ) : ViewModel() {
 
+    private val hiddenHere = settingsPrefs.perCalendarHiddenViews.calendarsHiddenIn(view, viewModelScope)
+
     /**
      * The zone every page is laid out in; drags and drops resolve in it too, and
      * pages lay out again when the device moves zones (#387).
@@ -167,7 +173,7 @@ abstract class PagedTimelineViewModel(
         zone.flatMapLatest { zone ->
             combine(
                 repository.calendars(),
-                repository.instances(spanRange(span.start, span.count, zone)),
+                repository.instancesWithout(spanRange(span.start, span.count, zone), hiddenHere),
                 today,
             ) { calendars, instances, today ->
                 buildState(span, calendars, instances, today, zone)
@@ -240,6 +246,7 @@ class WeekViewModel @Inject constructor(
         rule
     },
     initialRule = { DaysGrid.weeks(DayOfWeek.MONDAY) },
+    view = CalendarView.Week,
 )
 
 /**
@@ -264,6 +271,7 @@ class MultiDayViewModel @Inject constructor(
         { anchor: LocalDate -> DaysGrid.startingAt(anchor, count) }
     },
     initialRule = { DaysGrid.startingAt(it, SettingsPrefs.DEFAULT_MULTI_DAY_COUNT) },
+    view = CalendarView.MultiDay,
 )
 
 /** The day view: the timeline one day at a time. */
@@ -282,6 +290,7 @@ class DayViewModel @Inject constructor(
     io = io,
     gridRule = flowOf { _: LocalDate -> DaysGrid.days },
     initialRule = { DaysGrid.days },
+    view = CalendarView.Day,
 )
 
 /**

app/src/main/java/de/jeanlucmakiola/calendula/widget/WidgetConfig.kt

@@ -11,7 +11,6 @@ import androidx.glance.GlanceId
 import androidx.glance.appwidget.state.getAppWidgetState
 import androidx.glance.state.PreferencesGlanceStateDefinition
 import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
-import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.agenda.parseAgendaRange
 import de.jeanlucmakiola.calendula.ui.agenda.storageValue
@@ -116,8 +115,5 @@ internal fun MutablePreferences.putHiddenCalendars(ids: Set<Long>) {
     this[HiddenCalendarsKey] = ids.map(Long::toString).toSet()
 }
 
-internal fun List<EventInstance>.withoutCalendars(hidden: Set<Long>): List<EventInstance> =
-    if (hidden.isEmpty()) this else filterNot { it.calendarId in hidden }
-
 internal suspend fun Context.widgetState(id: GlanceId): Preferences =
     getAppWidgetState(this, PreferencesGlanceStateDefinition, id)

app/src/main/java/de/jeanlucmakiola/calendula/widget/WidgetData.kt

@@ -14,6 +14,7 @@ import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
 import de.jeanlucmakiola.calendula.data.prefs.is24Hour
 import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.withoutCalendars
 import de.jeanlucmakiola.calendula.ui.agenda.AgendaDay
 import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.agenda.agendaRange

app/src/main/java/de/jeanlucmakiola/calendula/widget/countdown/CountdownData.kt

@@ -12,6 +12,7 @@ import de.jeanlucmakiola.floret.glance.updateWithRefresh
 import kotlinx.coroutines.CancellationException
 import de.jeanlucmakiola.calendula.data.prefs.is24Hour
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.withoutCalendars
 import de.jeanlucmakiola.calendula.widget.Themed
 import de.jeanlucmakiola.calendula.widget.WidgetKind
 import de.jeanlucmakiola.calendula.widget.WidgetLoadContext
@@ -22,7 +23,6 @@ import de.jeanlucmakiola.calendula.widget.today
 import de.jeanlucmakiola.calendula.widget.widgetEntryPoint
 import de.jeanlucmakiola.calendula.widget.widgetLoadContext
 import de.jeanlucmakiola.calendula.widget.widgetState
-import de.jeanlucmakiola.calendula.widget.withoutCalendars
 import de.jeanlucmakiola.floret.prefs.toEnum
 import kotlinx.coroutines.flow.first
 import kotlinx.datetime.LocalDate

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

@@ -110,6 +110,9 @@
     <string name="event_move_failed">Couldn\'t move the event</string>
     <string name="event_move_write_denied">Calendula needs write access to move events</string>
     <string name="event_move_gone">That event no longer exists</string>
+    <string name="event_move_stale">That event moved before your drop could be saved</string>
+    <string name="event_move_queue_full">Too many moves at once, so that one wasn\'t saved</string>
+    <string name="event_move_skipped">Moves made while the question was open weren\'t saved</string>
     <string name="event_move_blocked_series_end">Can\'t move an event past the end of its series</string>
     <string name="event_move_blocked_cancelled_series">A cancelled series can only move as a whole, and this would change which days it falls on</string>
 
@@ -846,7 +849,7 @@
     <string name="calendars_state_managed">Filled from your contacts</string>
     <string name="calendars_managed_delete_locked">This calendar is filled from your contacts, so Calendula would create it again on the next sync. Turn special dates off under Settings → Special dates to delete it.</string>
     <string name="calendars_synced_header">Synced calendars</string>
-    <string name="calendars_synced_hint">These come from accounts on your device. Create and edit them in their own app.</string>
+    <string name="calendars_synced_hint">These come from accounts on your device. Create and edit them in their own app; tap one here to hide it in some views.</string>
     <string name="calendars_manage_in_app">Manage in app</string>
     <!-- Account header when two accounts share a name: %1$s is the account, %2$s the app it comes from. -->
     <string name="calendars_account_from_source">%1$s (%2$s)</string>
@@ -860,6 +863,19 @@
     <string name="calendars_color_label">Color</string>
     <string name="calendars_description_label">Description</string>
     <string name="calendars_description_hint">Add a description</string>
+    <string name="calendars_hide_in_views">Hide in views</string>
+    <string name="calendars_hide_in_views_hint">Events from “%1$s” stay out of the views checked here. Reminders, search and widgets still include them.</string>
+    <string name="calendars_hide_in_views_none">Shown in every view</string>
+    <string name="calendars_hidden_in">Hidden in %1$s</string>
+    <string name="filter_hidden_in_view">Hidden in this view</string>
+    <string name="view_calendars_title">Hide in this view</string>
+    <plurals name="drawer_hidden_in_view_count">
+        <item quantity="one">%d calendar hidden in this view</item>
+        <item quantity="other">%d calendars hidden in this view</item>
+    </plurals>
+    <string name="drawer_hidden_in_view_none">Leave calendars out of this view only</string>
+    <string name="view_calendars_hint">Checked calendars stay out of this view only. Reminders, search and widgets still include them.</string>
+    <string name="view_calendars_hidden_everywhere">Hidden in every view from the menu</string>
     <string name="color_name_mauve">Mauve</string>
     <string name="color_name_red">Red</string>
     <string name="color_name_orange">Orange</string>

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

@@ -616,6 +616,66 @@ class SettingsPrefsTest {
         assertThat(prefs.perCalendarEventDuration.first()).containsExactly(9L, 45)
     }
 
+    @Test
+    fun `per-calendar hidden views round-trip and clear back to every view`(
+        @TempDir tempDir: Path,
+    ) = runTest {
+        val prefs = testSettings(tempDir)
+        assertThat(prefs.perCalendarHiddenViews.first()).isEmpty()
+        prefs.applyCalendarHiddenChanges(7L, listOf(CalendarView.Month, CalendarView.Agenda).associateWith { true })
+        prefs.applyCalendarHiddenChanges(9L, listOf(CalendarView.MultiDay).associateWith { true })
+        assertThat(prefs.perCalendarHiddenViews.first()).containsExactly(
+            7L, setOf(CalendarView.Month, CalendarView.Agenda),
+            9L, setOf(CalendarView.MultiDay),
+        )
+        prefs.clearCalendarHiddenViews(7L)
+        assertThat(prefs.perCalendarHiddenViews.first()).containsExactly(9L, setOf(CalendarView.MultiDay))
+        // One write can hide some views and show others, leaving the rest alone.
+        prefs.applyCalendarHiddenChanges(9L, mapOf(CalendarView.MultiDay to false, CalendarView.Day to true))
+        assertThat(prefs.perCalendarHiddenViews.first()).containsExactly(9L, setOf(CalendarView.Day))
+    }
+
+    @Test
+    fun `toggling one hidden view keeps the others and clears the entry when empty`(
+        @TempDir tempDir: Path,
+    ) = runTest {
+        val prefs = testSettings(tempDir)
+        prefs.setCalendarHiddenIn(7L, CalendarView.Month, hidden = true)
+        prefs.setCalendarHiddenIn(7L, CalendarView.Week, hidden = true)
+        assertThat(prefs.perCalendarHiddenViews.first())
+            .containsExactly(7L, setOf(CalendarView.Month, CalendarView.Week))
+        prefs.setCalendarHiddenIn(7L, CalendarView.Month, hidden = false)
+        prefs.setCalendarHiddenIn(7L, CalendarView.Week, hidden = false)
+        assertThat(prefs.perCalendarHiddenViews.first()).isEmpty()
+    }
+
+    @Test
+    fun `garbage hidden-views entries are dropped, the rest survive`(
+        @TempDir tempDir: Path,
+    ) = runTest {
+        val store = testDataStore(tempDir, "test_settings")
+        val prefs = SettingsPrefs(store)
+        store.updateData { p ->
+            val m = p.toMutablePreferences()
+            // A bad id, only an unknown view, no separator, and a good entry with one unknown view.
+            m[stringPreferencesKey("per_calendar_hidden_views")] = "x=Month;7=Year;8;9=Month,Year,Agenda"
+            m
+        }
+        assertThat(prefs.perCalendarHiddenViews.first())
+            .containsExactly(9L, setOf(CalendarView.Month, CalendarView.Agenda))
+    }
+
+    @Test
+    fun `hidden views serialise in view order and drop empty entries`() {
+        val stored = mapOf(
+            3L to setOf(CalendarView.Agenda, CalendarView.Month),
+            1L to emptySet(),
+        ).toStoredHiddenViews()
+        assertThat(stored).isEqualTo("3=Month,Agenda")
+        assertThat(emptyMap<Long, Set<CalendarView>>().toStoredHiddenViews()).isNull()
+        assertThat(parseHiddenViews(stored)).containsExactly(3L, setOf(CalendarView.Month, CalendarView.Agenda))
+    }
+
     @Test
     fun `resolveDefaultEventDuration prefers the calendar's own length`() {
         val overrides = mapOf(7L to 480)

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

@@ -13,10 +13,12 @@ import de.jeanlucmakiola.calendula.testEvent
 import de.jeanlucmakiola.calendula.testPrefs
 import de.jeanlucmakiola.calendula.testRepository
 import de.jeanlucmakiola.calendula.testSettings
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.advanceUntilIdle
 import kotlinx.coroutines.test.runTest
 import kotlinx.datetime.LocalDate
@@ -79,15 +81,43 @@ class RescheduleViewModelTest {
         status = status,
     )
 
-    private fun viewModel(tempDir: Path, fake: FakeCalendarDataSource): RescheduleViewModel {
+    /**
+     * [present] are the events whose occurrence the provider still reports where
+     * a drop picked it up; [io] a [StandardTestDispatcher] keeps a drop in flight.
+     */
+    private fun viewModel(
+        tempDir: Path,
+        fake: FakeCalendarDataSource,
+        present: List<Long> = listOf(42L, 7L),
+        io: CoroutineDispatcher = dispatcher,
+    ): RescheduleViewModel {
+        fake.occurrencesAt(present)
         val repo = testRepository(
-            fake, tempDir, dispatcher,
+            fake, tempDir, io,
             prefs = testPrefs(tempDir, CoroutineScope(dispatcher)),
             settings = testSettings(tempDir, CoroutineScope(dispatcher)),
         )
-        return RescheduleViewModel(repo, dispatcher, FakeZoneSource())
+        return RescheduleViewModel(repo, io, FakeZoneSource())
     }
 
+    private fun slowViewModel(tempDir: Path, fake: FakeCalendarDataSource): RescheduleViewModel =
+        viewModel(tempDir, fake, io = StandardTestDispatcher(dispatcher.scheduler))
+
+    /** Every query answers with an occurrence of each of [ids] exactly at the queried span. */
+    private fun FakeCalendarDataSource.occurrencesAt(ids: List<Long>) {
+        instancesResult = { begin, end ->
+            ids.map { id ->
+                testEvent(
+                    id = id,
+                    start = Instant.fromEpochMilliseconds(begin),
+                    end = Instant.fromEpochMilliseconds(end),
+                )
+            }
+        }
+    }
+
+    private val RescheduleViewModel.abandonedCount: Int get() = drops.value.abandoned.size
+
     private fun CoroutineScope.activate(vm: RescheduleViewModel): Job =
         launch { vm.movableCalendarIds.collect {} }
 
@@ -97,6 +127,8 @@ class RescheduleViewModelTest {
         beginMillis = beginMillis,
         endMillis = endMillis,
         target = MoveTarget.ByDays(2),
+        isAllDay = false,
+        token = nextMoveToken(),
     )
 
     /** A drop an hour later, expressed the way a timeline drag expresses one. */
@@ -105,6 +137,8 @@ class RescheduleViewModelTest {
         beginMillis = beginMillis,
         endMillis = endMillis,
         target = MoveTarget.Start(Instant.fromEpochMilliseconds(beginMillis + 3_600_000L)),
+        isAllDay = false,
+        token = nextMoveToken(),
     )
 
     /** The end dragged an hour later, the start left where it is. */
@@ -116,6 +150,8 @@ class RescheduleViewModelTest {
             Instant.fromEpochMilliseconds(beginMillis),
             Instant.fromEpochMilliseconds(endMillis + 3_600_000L),
         ),
+        isAllDay = false,
+        token = nextMoveToken(),
     )
 
     @Test
@@ -259,21 +295,228 @@ class RescheduleViewModelTest {
     }
 
     @Test
-    fun `a second drop is refused while the first is still in flight`(
+    fun `a drop of another event waits for the one in flight, then lands`(
         @TempDir tempDir: Path,
     ) = runTest(dispatcher) {
         val fake = FakeCalendarDataSource().apply {
-            eventDetailResult = { detail(rrule = "FREQ=WEEKLY;BYDAY=MO") }
+            eventDetailResult = { detail() }
         }
+        val vm = slowViewModel(tempDir, fake)
+
+        val first = oneHourLater()
+        val second = toWednesday().copy(eventId = 7L, token = nextMoveToken())
+        assertThat(vm.move(first)).isTrue()
+        assertThat(vm.move(second)).isTrue()
+        assertThat(vm.drops.value.pending).containsExactly(first.token, second.token)
+        advanceUntilIdle()
+
+        assertThat(fake.updatedEvents.map { it.first }).containsExactly(42L, 7L).inOrder()
+        assertThat(vm.drops.value).isEqualTo(DropStates())
+        assertThat(vm.inFlight.value).isFalse()
+    }
+
+    @Test
+    fun `a failed drop lets go of its own copy only, not the one queued behind it`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            eventDetailResult = { detail() }
+        }
+        val vm = slowViewModel(tempDir, fake)
+
+        // Zero distance: refused in prepare.
+        val nowhere = oneHourLater().copy(
+            target = MoveTarget.Start(Instant.fromEpochMilliseconds(beginMillis)),
+            token = nextMoveToken(),
+        )
+        val queued = toWednesday().copy(eventId = 7L, token = nextMoveToken())
+        vm.move(nowhere)
+        vm.move(queued)
+        advanceUntilIdle()
+
+        assertThat(vm.drops.value.abandoned).containsExactly(nowhere.token)
+        assertThat(fake.updatedEvents.map { it.first }).containsExactly(7L)
+    }
+
+    @Test
+    fun `the same event dropped twice ends up where it was dropped last`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val hour = 3_600_000L
+        val fake = FakeCalendarDataSource()
+        val vm = slowViewModel(tempDir, fake)
+        // Once the first drop is written, the event sits an hour later.
+        fake.eventDetailResult = {
+            if (fake.updatedEvents.isEmpty()) detail() else detail(anchorMillis = beginMillis + hour)
+        }
+        fake.instancesResult = { _, _ ->
+            val shift = if (fake.updatedEvents.isEmpty()) 0L else hour
+            listOf(
+                testEvent(
+                    id = 42L,
+                    start = Instant.fromEpochMilliseconds(beginMillis + shift),
+                    end = Instant.fromEpochMilliseconds(endMillis + shift),
+                ),
+            )
+        }
+
+        vm.move(oneHourLater())
+        // Picked up from where the grid still drew it, and dropped two days on.
+        vm.move(toWednesday())
+        advanceUntilIdle()
+
+        assertThat(fake.updatedEvents).hasSize(2)
+        val last = fake.updatedEvents.last().third
+        assertThat(last.start.dateTime).isEqualTo(LocalDateTime(LocalDate(2026, 6, 10), LocalTime(13, 0)))
+    }
+
+    @Test
+    fun `a drop on a series written moments ago is not written`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        // A whole-series write shifts every occurrence; the grid still draws the
+        // old ones, and another occurrence may now sit at the dragged time.
+        val fake = FakeCalendarDataSource().apply { eventDetailResult = { detail(rrule = "FREQ=DAILY") } }
         val vm = viewModel(tempDir, fake)
+        vm.move(oneHourLater())
+        advanceUntilIdle()
+        vm.moveWithScope(RecurringWriteScope.AllEvents)
+        advanceUntilIdle()
+        vm.consumeOutcome()
 
-        assertThat(vm.move(toWednesday())).isTrue()
+        val again = toWednesday()
+        vm.move(again)
         advanceUntilIdle()
 
-        // Parked on the scope dialog, so the first drop still owns the pipeline.
-        assertThat(vm.move(oneHourLater())).isFalse()
+        assertThat(vm.scopePrompt.value).isNull()
+        assertThat(vm.outcome.value).isEqualTo(MoveOutcome.Stale)
+        assertThat(vm.drops.value.abandoned).containsExactly(again.token)
+        assertThat(fake.updatedEvents).hasSize(1)
+    }
+
+    @Test
+    fun `a single occurrence written leaves the rest of its series movable`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply { eventDetailResult = { detail(rrule = "FREQ=WEEKLY") } }
+        val vm = viewModel(tempDir, fake)
+        vm.move(oneHourLater())
         advanceUntilIdle()
-        assertThat(fake.updatedEvents).isEmpty()
+        vm.moveWithScope(RecurringWriteScope.ThisEvent)
+        advanceUntilIdle()
+
+        // Another occurrence, a week on.
+        val week = 7 * 86_400_000L
+        vm.move(oneHourLater().copy(beginMillis = beginMillis + week, endMillis = endMillis + week, token = nextMoveToken()))
+        advanceUntilIdle()
+
+        assertThat(vm.scopePrompt.value).isNotNull()
+    }
+
+    @Test
+    fun `chip messages wait their turn instead of replacing each other`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            eventDetailResult = { id ->
+                if (id == 42L) detail(rrule = "FREQ=WEEKLY;BYDAY=MO,WE", status = EventStatus.Cancelled) else detail()
+            }
+        }
+        val vm = slowViewModel(tempDir, fake)
+
+        vm.move(toWednesday())
+        vm.move(toWednesday().copy(eventId = 7L, token = nextMoveToken()))
+        advanceUntilIdle()
+
+        assertThat(vm.outcome.value).isEqualTo(MoveOutcome.BlockedCancelledSeries)
+        vm.consumeOutcome()
+        assertThat((vm.outcome.value as MoveOutcome.Moved).undo?.eventId).isEqualTo(7L)
+        vm.consumeOutcome()
+        assertThat(vm.outcome.value).isNull()
+    }
+
+    @Test
+    fun `a full queue says so`(@TempDir tempDir: Path) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply { eventDetailResult = { detail() } }
+        val vm = slowViewModel(tempDir, fake)
+
+        repeat(9) { i -> vm.move(toWednesday().copy(eventId = 100L + i, token = nextMoveToken())) }
+        val refused = toWednesday().copy(eventId = 200L, token = nextMoveToken())
+        assertThat(vm.move(refused)).isFalse()
+
+        assertThat(vm.drops.value.abandoned).containsExactly(refused.token)
+        assertThat(vm.outcome.value).isEqualTo(MoveOutcome.QueueFull)
+    }
+
+    @Test
+    fun `a deleted event reports itself as gone, not moved`(@TempDir tempDir: Path) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply { eventDetailResult = { null } }
+        val vm = viewModel(tempDir, fake, present = emptyList())
+
+        vm.move(oneHourLater())
+        advanceUntilIdle()
+
+        assertThat(vm.outcome.value).isEqualTo(MoveOutcome.Gone)
+    }
+
+    @Test
+    fun `drops waiting when a scope dialog opens are cancelled, not held behind it`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply {
+            eventDetailResult = { id -> if (id == 42L) detail(rrule = "FREQ=WEEKLY") else detail() }
+        }
+        val vm = slowViewModel(tempDir, fake)
+
+        vm.move(oneHourLater())
+        val queued = toWednesday().copy(eventId = 7L, token = nextMoveToken())
+        vm.move(queued)
+        advanceUntilIdle()
+
+        assertThat(vm.scopePrompt.value).isNotNull()
+        assertThat(vm.drops.value.abandoned).containsExactly(queued.token)
+        assertThat(vm.outcome.value).isEqualTo(MoveOutcome.Skipped)
+
+        // One made while the dialog is up is refused the same way.
+        val during = toWednesday().copy(eventId = 7L, token = nextMoveToken())
+        assertThat(vm.move(during)).isFalse()
+
+        vm.moveWithScope(RecurringWriteScope.AllEvents)
+        advanceUntilIdle()
+        assertThat(fake.updatedEvents.map { it.first }).containsExactly(42L)
+        // The skip has its turn, then the move it waited on, with its Undo.
+        assertThat(vm.outcome.value).isEqualTo(MoveOutcome.Skipped)
+        vm.consumeOutcome()
+        assertThat((vm.outcome.value as MoveOutcome.Moved).undo?.eventId).isEqualTo(42L)
+    }
+
+    @Test
+    fun `the first move of a run keeps the chip and its undo`(@TempDir tempDir: Path) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply { eventDetailResult = { detail() } }
+        val vm = slowViewModel(tempDir, fake)
+
+        vm.move(oneHourLater())
+        vm.move(toWednesday().copy(eventId = 7L, token = nextMoveToken()))
+        advanceUntilIdle()
+
+        val shown = vm.outcome.value as MoveOutcome.Moved
+        assertThat(fake.updatedEvents).hasSize(2)
+        assertThat(shown.undo?.eventId).isEqualTo(42L)
+    }
+
+    @Test
+    fun `a later move of the same event takes the first move's undo away`(
+        @TempDir tempDir: Path,
+    ) = runTest(dispatcher) {
+        val fake = FakeCalendarDataSource().apply { eventDetailResult = { detail() } }
+        val vm = slowViewModel(tempDir, fake)
+
+        vm.move(oneHourLater())
+        vm.move(toWednesday())
+        advanceUntilIdle()
+
+        assertThat(fake.updatedEvents).hasSize(2)
+        assertThat((vm.outcome.value as MoveOutcome.Moved).undo).isNull()
     }
 
     @Test
@@ -284,19 +527,19 @@ class RescheduleViewModelTest {
         advanceUntilIdle()
         val undo = (vm.outcome.value as MoveOutcome.Moved).undo!!
 
-        // A second drop parks on its scope dialog, which holds the pipeline.
+        // A second drop, of another event, parks on its scope dialog, which holds the pipeline.
         fake.eventDetailResult = { detail(rrule = "FREQ=WEEKLY;BYDAY=MO") }
-        vm.move(toWednesday())
+        vm.move(toWednesday().copy(eventId = 7L, token = nextMoveToken()))
         advanceUntilIdle()
 
-        val abandoned = vm.abandoned.value
+        val abandoned = vm.abandonedCount
         assertThat(vm.undo(undo)).isFalse()
         advanceUntilIdle()
         assertThat(fake.updatedEvents).hasSize(1)
         // Nothing ticks: the refusal started no journey of its own, and the
         // counter is global — a tick here would release the copy the drop that
         // *is* in flight is holding, before the grid has drawn it.
-        assertThat(vm.abandoned.value).isEqualTo(abandoned)
+        assertThat(vm.abandonedCount).isEqualTo(abandoned)
     }
 
     @Test
@@ -311,13 +554,13 @@ class RescheduleViewModelTest {
         advanceUntilIdle()
         val undo = (vm.outcome.value as MoveOutcome.Moved).undo!!
 
-        val abandoned = vm.abandoned.value
+        val abandoned = vm.abandonedCount
         fake.writeError = SecurityException("permission revoked")
         assertThat(vm.undo(undo)).isTrue()
         advanceUntilIdle()
 
         assertThat(vm.outcome.value).isEqualTo(MoveOutcome.WriteDenied)
-        assertThat(vm.abandoned.value).isEqualTo(abandoned + 1)
+        assertThat(vm.abandonedCount).isEqualTo(abandoned + 1)
     }
 
     @Test
@@ -330,12 +573,12 @@ class RescheduleViewModelTest {
         advanceUntilIdle()
         val undo = (vm.outcome.value as MoveOutcome.Moved).undo!!
 
-        val abandoned = vm.abandoned.value
+        val abandoned = vm.abandonedCount
         vm.undo(undo)
         advanceUntilIdle()
 
         assertThat(vm.outcome.value).isEqualTo(MoveOutcome.Undone)
-        assertThat(vm.abandoned.value).isEqualTo(abandoned)
+        assertThat(vm.abandonedCount).isEqualTo(abandoned)
     }
 
     @Test
@@ -415,6 +658,8 @@ class RescheduleViewModelTest {
                 target = MoveTarget.Start(
                     Instant.fromEpochMilliseconds(beginMillis + 26 * 3_600_000L),
                 ),
+                isAllDay = false,
+                token = nextMoveToken(),
             ),
         )
         advanceUntilIdle()
@@ -435,6 +680,8 @@ class RescheduleViewModelTest {
                 beginMillis = beginMillis,
                 endMillis = endMillis,
                 target = MoveTarget.Start(Instant.fromEpochMilliseconds(beginMillis)),
+                isAllDay = false,
+                token = nextMoveToken(),
             ),
         )
         advanceUntilIdle()
@@ -556,17 +803,19 @@ class RescheduleViewModelTest {
                 beginMillis = beginMillis,
                 endMillis = endMillis,
                 target = MoveTarget.Start(Instant.fromEpochMilliseconds(beginMillis)),
+                isAllDay = false,
+                token = nextMoveToken(),
             ),
         )).isTrue()
         advanceUntilIdle()
-        assertThat(vm.abandoned.value).isEqualTo(1)
+        assertThat(vm.abandonedCount).isEqualTo(1)
 
         // Refused by the provider, after the write was attempted.
         fake.writeError = SecurityException("revoked")
         vm.move(oneHourLater())
         advanceUntilIdle()
         assertThat(vm.outcome.value).isEqualTo(MoveOutcome.WriteDenied)
-        assertThat(vm.abandoned.value).isEqualTo(2)
+        assertThat(vm.abandonedCount).isEqualTo(2)
     }
 
     @Test
@@ -580,11 +829,11 @@ class RescheduleViewModelTest {
 
         vm.move(oneHourLater())
         advanceUntilIdle()
-        assertThat(vm.abandoned.value).isEqualTo(0)
+        assertThat(vm.abandonedCount).isEqualTo(0)
 
         vm.cancelScope()
         advanceUntilIdle()
-        assertThat(vm.abandoned.value).isEqualTo(1)
+        assertThat(vm.abandonedCount).isEqualTo(1)
     }
 
     @Test
@@ -596,7 +845,7 @@ class RescheduleViewModelTest {
         advanceUntilIdle()
 
         assertThat(vm.outcome.value).isInstanceOf(MoveOutcome.Moved::class.java)
-        assertThat(vm.abandoned.value).isEqualTo(0)
+        assertThat(vm.abandonedCount).isEqualTo(0)
     }
 
     @Test
@@ -668,6 +917,8 @@ class RescheduleViewModelTest {
                 beginMillis = beginMillis,
                 endMillis = endMillis,
                 target = MoveTarget.Span(sundayEvening, Instant.fromEpochMilliseconds(endMillis)),
+                isAllDay = false,
+                token = nextMoveToken(),
             ),
         )
         advanceUntilIdle()
@@ -709,7 +960,7 @@ class RescheduleViewModelTest {
 
         assertThat(vm.scopePrompt.value).isNull()
         assertThat(vm.outcome.value).isEqualTo(MoveOutcome.BlockedCancelledSeries)
-        assertThat(vm.abandoned.value).isEqualTo(1)
+        assertThat(vm.abandonedCount).isEqualTo(1)
         assertThat(fake.updatedEvents).isEmpty()
         assertThat(fake.updatedOccurrences).isEmpty()
     }
@@ -739,6 +990,8 @@ class RescheduleViewModelTest {
                 beginMillis = dayStart,
                 endMillis = dayStart + 86_400_000L,
                 target = MoveTarget.Span(start, Instant.fromEpochMilliseconds(endMillis)),
+                isAllDay = true,
+                token = nextMoveToken(),
             ),
         )
         advanceUntilIdle()
@@ -775,6 +1028,8 @@ class RescheduleViewModelTest {
                 beginMillis = dayStart,
                 endMillis = dayStart + 86_400_000L,
                 target = MoveTarget.Span(eight, eight + 1.hours),
+                isAllDay = true,
+                token = nextMoveToken(),
             ),
         )
         advanceUntilIdle()

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

@@ -53,7 +53,7 @@ class TimelineDropTest {
     @Test
     fun `dropping the head asks for exactly where it landed`() {
         val target = LocalDate(2026, 9, 2)
-        val drop = TimelineDrop(overnight, target, 20 * 60, clipOffsetMin = 0)
+        val drop = TimelineDrop(overnight, target, 20 * 60, clipOffsetMin = 0, token = 0L)
 
         assertThat(drop.startInstant(zone)).isEqualTo(target.atTime(20, 0).toInstant(zone))
     }
@@ -63,7 +63,7 @@ class TimelineDropTest {
         val tail = blockOn(sun)
         val offset = tail.clipOffsetMinutes(sun, zone)
         // Dragged three days back, same height in the column: Sun 6 -> Thu 3.
-        val drop = TimelineDrop(overnight, LocalDate(2026, 9, 3), 0, offset)
+        val drop = TimelineDrop(overnight, LocalDate(2026, 9, 3), 0, offset, token = 0L)
 
         // The event began Sat 5 Sep 20:00, so it now begins Wed 2 Sep 20:00 —
         // the whole event moved three days, and no time of day was invented.
@@ -75,7 +75,7 @@ class TimelineDropTest {
     fun `dragging the tail down the column re-times the event across midnight`() {
         val offset = blockOn(sun).clipOffsetMinutes(sun, zone)
         // Tail top pulled from 00:00 to 03:00 on its own day.
-        val drop = TimelineDrop(overnight, sun, 3 * 60, offset)
+        val drop = TimelineDrop(overnight, sun, 3 * 60, offset, token = 0L)
 
         assertThat(drop.startInstant(zone)).isEqualTo(sat.atTime(23, 0).toInstant(zone))
     }
@@ -84,7 +84,7 @@ class TimelineDropTest {
     fun `pulling the tail above its own midnight moves the event earlier`() {
         val offset = blockOn(sun).clipOffsetMinutes(sun, zone)
         // The tail's top edge dragged an hour above the midnight it rests on.
-        val drop = TimelineDrop(overnight, sun, -60, offset)
+        val drop = TimelineDrop(overnight, sun, -60, offset, token = 0L)
 
         // Event was Sat 20:00 to Sun 08:00; it now begins an hour earlier.
         assertThat(drop.startInstant(zone)).isEqualTo(sat.atTime(19, 0).toInstant(zone))
@@ -92,7 +92,7 @@ class TimelineDropTest {
 
     @Test
     fun `a top edge dragged past the next midnight resolves onto the day after`() {
-        val drop = TimelineDrop(overnight, sat, 25 * 60, clipOffsetMin = 0)
+        val drop = TimelineDrop(overnight, sat, 25 * 60, clipOffsetMin = 0, token = 0L)
 
         assertThat(drop.startInstant(zone)).isEqualTo(sun.atTime(1, 0).toInstant(zone))
     }
@@ -130,7 +130,7 @@ class TimelineDropTest {
         val tail = layoutDay(listOf(overnightIntoDst), sun, berlin).single()
         val offset = tail.clipOffsetMinutes(sun, berlin)
         // Dropped back onto its own slot a week earlier, clear of the boundary.
-        val drop = TimelineDrop(overnightIntoDst, LocalDate(2026, 3, 22), 0, offset)
+        val drop = TimelineDrop(overnightIntoDst, LocalDate(2026, 3, 22), 0, offset, token = 0L)
 
         assertThat(drop.startInstant(berlin))
             .isEqualTo(LocalDate(2026, 3, 21).atTime(22, 0).toInstant(berlin))
@@ -155,7 +155,7 @@ class TimelineDropTest {
         )
         val block = layoutDay(listOf(event), fallBack, brussels).single()
         assertThat(block.clipOffsetMinutes(fallBack, brussels)).isEqualTo(0)
-        val drop = TimelineDrop(event, fallBack, block.startMin, clipOffsetMin = 0)
+        val drop = TimelineDrop(event, fallBack, block.startMin, clipOffsetMin = 0, token = 0L)
         assertThat(drop.startInstant(brussels)).isEqualTo(event.start)
     }
 
@@ -168,7 +168,7 @@ class TimelineDropTest {
         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)
+        val drop = TimelineDrop(event, fallBack, tail.startMin, clipOffsetMin = offset, token = 0L)
         assertThat(drop.startInstant(brussels)).isEqualTo(event.start)
     }
 
@@ -189,7 +189,7 @@ class TimelineDropTest {
             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)
+        val drop = TimelineDrop(event, fallBack, block.startMin + 15, clipOffsetMin = 0, token = 0L)
         assertThat(drop.startInstant(brussels)).isEqualTo(Instant.parse("2026-10-25T01:45:00Z"))
     }
 
@@ -234,7 +234,7 @@ class TimelineDropTest {
             start = Instant.parse("2026-10-25T01:30:00Z"),
             end = Instant.parse("2026-10-25T03:00:00Z"),
         )
-        val drop = resizedDrop(event, ResizeEdge.Bottom, fallBack, 2 * 60 + 30, 15, brussels)
+        val drop = resizedSpan(event, ResizeEdge.Bottom, fallBack, 2 * 60 + 30, 15, brussels)
         assertThat(drop.start).isEqualTo(event.start)
         assertThat(drop.end).isEqualTo(Instant.parse("2026-10-25T01:45:00Z"))
     }
@@ -246,7 +246,7 @@ class TimelineDropTest {
             start = Instant.parse("2026-10-25T00:30:00Z"),
             end = Instant.parse("2026-10-25T01:15:00Z"),
         )
-        val drop = resizedDrop(event, ResizeEdge.Top, fallBack, 2 * 60, 60, brussels)
+        val drop = resizedSpan(event, ResizeEdge.Top, fallBack, 2 * 60, 60, brussels)
         assertThat(drop.start).isEqualTo(Instant.parse("2026-10-25T00:00:00Z"))
         assertThat(drop.end).isEqualTo(event.end)
     }
@@ -258,7 +258,7 @@ class TimelineDropTest {
             start = Instant.parse("2026-10-25T00:20:00Z"),
             end = Instant.parse("2026-10-25T01:10:00Z"),
         )
-        val drop = resizedDrop(event, ResizeEdge.Bottom, fallBack, 2 * 60 + 20, 30, brussels)
+        val drop = resizedSpan(event, ResizeEdge.Bottom, fallBack, 2 * 60 + 20, 30, brussels)
         assertThat(drop.end).isEqualTo(Instant.parse("2026-10-25T00:50:00Z"))
     }
 
@@ -270,7 +270,7 @@ class TimelineDropTest {
             start = Instant.parse("2026-10-24T23:00:00Z"),
             end = Instant.parse("2026-10-25T03:00:00Z"),
         )
-        val drop = resizedDrop(event, ResizeEdge.Bottom, fallBack, 60, 75, brussels)
+        val drop = resizedSpan(event, ResizeEdge.Bottom, fallBack, 60, 75, brussels)
         assertThat(drop.end).isEqualTo(Instant.parse("2026-10-25T00:15:00Z"))
     }
 }

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

@@ -0,0 +1,100 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.data.calendar.FakeCalendarDataSource
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.testEvent
+import de.jeanlucmakiola.calendula.testRepository
+import de.jeanlucmakiola.calendula.testSettings
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.io.TempDir
+import java.nio.file.Path
+import kotlin.time.Instant
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class ViewHiddenCalendarsTest {
+
+    private val range = Instant.fromEpochMilliseconds(0)..Instant.fromEpochMilliseconds(10_000_000_000L)
+
+    private fun event(id: Long, calendarId: Long) = testEvent(
+        id = id,
+        calendarId = calendarId,
+        title = "E $id",
+        start = Instant.fromEpochMilliseconds(1_000_000_000L),
+        end = Instant.fromEpochMilliseconds(1_000_003_600L),
+        color = 0,
+    )
+
+    private fun calendar(id: Long) = CalendarSource(id, "Cal $id", "x@y", "LOCAL", 0, true)
+
+    @Test
+    fun `calendarsHiddenIn picks only the calendars hidden in that view`() {
+        val map = mapOf(
+            1L to setOf(CalendarView.Month),
+            2L to setOf(CalendarView.Month, CalendarView.Agenda),
+            3L to setOf(CalendarView.Week),
+        )
+        assertThat(map.calendarsHiddenIn(CalendarView.Month)).containsExactly(1L, 2L)
+        assertThat(map.calendarsHiddenIn(CalendarView.Agenda)).containsExactly(2L)
+        assertThat(map.calendarsHiddenIn(CalendarView.Day)).isEmpty()
+    }
+
+    @Test
+    fun `instancesWithout drops a calendar only in the views it is hidden in`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(calendar(1L), calendar(2L))
+            instancesResult = { _, _ -> listOf(event(10L, 1L), event(20L, 2L)) }
+        }
+        val settings = testSettings(tempDir)
+        val repo = testRepository(fake, tempDir, UnconfinedTestDispatcher(testScheduler), settings = settings)
+        settings.applyCalendarHiddenChanges(2L, listOf(CalendarView.Month).associateWith { true })
+        val hidden = settings.perCalendarHiddenViews
+
+        assertThat(repo.instancesWithout(range, hidden.calendarsHiddenIn(CalendarView.Month, backgroundScope)).first().map { it.eventId })
+            .containsExactly(10L)
+        assertThat(repo.instancesWithout(range, hidden.calendarsHiddenIn(CalendarView.Week, backgroundScope)).first().map { it.eventId })
+            .containsExactly(10L, 20L)
+        // The repository itself, which reminders and search build on, is untouched.
+        assertThat(repo.instances(range).first().map { it.eventId }).containsExactly(10L, 20L)
+    }
+
+    @Test
+    fun `instancesWithout re-filters live when the setting changes`(@TempDir tempDir: Path) = runTest {
+        val fake = FakeCalendarDataSource().apply {
+            calendarsResult = listOf(calendar(1L), calendar(2L))
+            instancesResult = { _, _ -> listOf(event(10L, 1L), event(20L, 2L)) }
+        }
+        val settings = testSettings(tempDir)
+        val repo = testRepository(fake, tempDir, UnconfinedTestDispatcher(testScheduler), settings = settings)
+
+        val hidden = settings.perCalendarHiddenViews.calendarsHiddenIn(CalendarView.Agenda, backgroundScope)
+        repo.instancesWithout(range, hidden).test {
+            assertThat(awaitItem().map { it.eventId }).containsExactly(10L, 20L)
+            settings.setCalendarHiddenIn(1L, CalendarView.Agenda, hidden = true)
+            assertThat(awaitItem().map { it.eventId }).containsExactly(20L)
+            settings.setCalendarHiddenIn(1L, CalendarView.Agenda, hidden = false)
+            assertThat(awaitItem().map { it.eventId }).containsExactly(10L, 20L)
+            cancelAndIgnoreRemainingEvents()
+        }
+    }
+
+    @Test
+    fun `a failed read hides nothing and keeps reading`() = runTest {
+        var reads = 0
+        val source = kotlinx.coroutines.flow.flow {
+            reads++
+            if (reads == 1) throw java.io.IOException("disk")
+            emit(mapOf(1L to setOf(CalendarView.Month)))
+        }
+        source.hidingNothingOnError().test {
+            assertThat(awaitItem()).isEmpty()
+            assertThat(awaitItem()).containsExactly(1L, setOf(CalendarView.Month))
+            awaitComplete()
+        }
+    }
+}

app/src/test/java/de/jeanlucmakiola/calendula/ui/filter/FilterUiStateTest.kt

@@ -0,0 +1,31 @@
+package de.jeanlucmakiola.calendula.ui.filter
+
+import com.google.common.truth.Truth.assertThat
+import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.ui.common.CalendarView
+import de.jeanlucmakiola.calendula.ui.common.groupByAccount
+import org.junit.jupiter.api.Test
+
+class FilterUiStateTest {
+
+    private fun calendar(id: Long) = CalendarSource(id, "Cal $id", "x@y", "LOCAL", 0, true)
+
+    @Test
+    fun `hiddenOnlyIn lists the calendars the view hides on its own`() {
+        val state = FilterUiState.Success(
+            groups = listOf(calendar(1L), calendar(2L), calendar(3L)).groupByAccount(),
+            // 3 is hidden everywhere from the drawer already.
+            hidden = setOf(3L),
+            hiddenViews = mapOf(
+                1L to setOf(CalendarView.Month),
+                2L to setOf(CalendarView.Month, CalendarView.Week),
+                3L to setOf(CalendarView.Month),
+                // Not listed (switched off device-wide).
+                9L to setOf(CalendarView.Month),
+            ),
+        )
+        assertThat(state.hiddenOnlyIn(CalendarView.Month)).containsExactly(1L, 2L)
+        assertThat(state.hiddenOnlyIn(CalendarView.Week)).containsExactly(2L)
+        assertThat(state.hiddenOnlyIn(CalendarView.Agenda)).isEmpty()
+    }
+}

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

@@ -356,12 +356,12 @@ class WeekLayoutTest {
         )
         assertThat(state.allDaySpans.map { it.lane }).containsExactly(0, 0)
 
-        val preview = state.withStripPreview(StripDrag(held, dayShift = 2), zone).allDaySpans
+        val preview = state.withStripPreview(listOf(StripDrag(held, dayShift = 2)), zone).allDaySpans
         val moved = preview.single { it.event.instanceId == held.instanceId }
 
         assertThat(moved.event).isEqualTo(held)
         assertThat(moved.startCol).isEqualTo(2)
         assertThat(preview.map { it.lane }).containsExactly(0, 1)
-        assertThat(state.withStripPreview(StripDrag(held, dayShift = 2, overGrid = true), zone)).isSameInstanceAs(state)
+        assertThat(state.withStripPreview(listOf(StripDrag(held, dayShift = 2, overGrid = true)), zone)).isSameInstanceAs(state)
     }
 }

docs/ARCHITECTURE.md

@@ -389,7 +389,12 @@ pre-permission launch); `CalendarVisibilityReconciler` drains it entry by entry,
 and until it does, the repository and `ReminderNotifier.post` honour it. That
 gate also covers a snooze re-shown from our own alarm after its calendar was
 switched off. The drawer's filter sheet (`CalendarPrefs.hiddenCalendarIds`) is a
-separate in-app declutter that never touches reminders.
+separate in-app declutter that never touches reminders. Narrower still is the per-view hide
+(`SettingsPrefs.perCalendarHiddenViews`, #270): each view model asks for its
+events through `instancesWithout(range, calendarsHiddenIn(view, …))`, which drops
+the calendars hidden in that one view on top of the repository's filters; reminders, search and widgets read
+the repository and never see it. The drawer's "Hide in this view" entry (#517) edits the same
+set for the view on show, and the drawer's per-row "Hidden in this view" notes read it.
 
 Deliberately absent: a fallback to the provider's `EVENT_REMINDER` broadcast.
 Keeping both would double-post wherever the provider works, and Etar's way out —

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

@@ -0,0 +1,6 @@
+الإصلاحات
+• لم تعد الأحداث المنقولة بسرعة متتالية تضيع: تُحفظ عمليات النقل بالترتيب.
+• تظهر رسالة عند تعذّر حفظ عملية نقل.
+
+التغييرات
+• يعرض عنوان عرض اليوم الشهر.

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

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

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

@@ -0,0 +1,6 @@
+Opraveno
+• Události rychle přesunuté za sebou se už neztrácí: přesuny se ukládají postupně.
+• Zpráva upozorní, když přesun nešel uložit.
+
+Změněno
+• Název denního zobrazení ukazuje měsíc.

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

@@ -0,0 +1,6 @@
+Behoben
+• Schnell hintereinander verschobene Termine gehen nicht mehr verloren: Verschiebungen werden der Reihe nach gespeichert.
+• Eine Meldung sagt, wenn eine Verschiebung nicht gespeichert werden konnte.
+
+Geändert
+• Der Titel der Tagesansicht zeigt den Monat.

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

@@ -0,0 +1,6 @@
+Fixed
+• Events moved in quick succession are no longer lost: moves are saved in order.
+• A message says when a move could not be saved.
+
+Changed
+• The day view title shows the month.

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

@@ -0,0 +1,6 @@
+Correcciones
+• Los eventos movidos rápidamente uno tras otro ya no se pierden: los cambios se guardan en orden.
+• Un mensaje avisa cuando no se pudo guardar un cambio.
+
+Cambios
+• El título de la vista diaria muestra el mes.

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

@@ -0,0 +1,6 @@
+Corrections
+• Les événements déplacés rapidement à la suite ne sont plus perdus : les déplacements sont enregistrés dans l’ordre.
+• Un message indique quand un déplacement n’a pas pu être enregistré.
+
+Modifications
+• Le titre de la vue jour affiche le mois.

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

@@ -0,0 +1,6 @@
+Javítva
+• A gyors egymásutánban áthelyezett események többé nem vesznek el: az áthelyezések sorban mentődnek.
+• Üzenet jelzi, ha egy áthelyezést nem sikerült menteni.
+
+Változások
+• A napi nézet címe a hónapot mutatja.

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

@@ -0,0 +1,6 @@
+Correzioni
+• Gli eventi spostati rapidamente uno dopo l’altro non vanno più persi: gli spostamenti vengono salvati in ordine.
+• Un messaggio avvisa quando uno spostamento non è stato salvato.
+
+Modifiche
+• Il titolo della vista giornaliera mostra il mese.

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

@@ -0,0 +1,6 @@
+修正
+• 続けてすばやく移動した予定が失われなくなりました。移動は順番に保存されます。
+• 移動を保存できなかったときはメッセージが表示されます。
+
+変更
+• 日表示のタイトルに月が表示されるようになりました。

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

@@ -0,0 +1,6 @@
+Opgelost
+• Snel na elkaar verplaatste afspraken gaan niet meer verloren: verplaatsingen worden op volgorde opgeslagen.
+• Een melding laat weten wanneer een verplaatsing niet kon worden opgeslagen.
+
+Gewijzigd
+• De titel van de dagweergave toont de maand.

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

@@ -0,0 +1,6 @@
+Poprawki
+• Wydarzenia szybko przenoszone jedno po drugim już nie giną: przeniesienia są zapisywane po kolei.
+• Komunikat informuje, gdy przeniesienia nie udało się zapisać.
+
+Zmiany
+• Tytuł widoku dnia pokazuje miesiąc.

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

@@ -0,0 +1,6 @@
+Correções
+• Eventos movidos rapidamente um após o outro não se perdem mais: as mudanças são salvas em ordem.
+• Uma mensagem avisa quando uma mudança não pôde ser salva.
+
+Alterações
+• O título da visualização diária mostra o mês.

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

@@ -0,0 +1,6 @@
+Correções
+• Os eventos movidos rapidamente uns após os outros já não se perdem: as alterações são guardadas por ordem.
+• Uma mensagem avisa quando uma alteração não pôde ser guardada.
+
+Alterações
+• O título da vista diária mostra o mês.

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

@@ -0,0 +1,6 @@
+Исправлено
+• События, быстро перенесённые одно за другим, больше не теряются: переносы сохраняются по очереди.
+• Сообщение показывает, если перенос не удалось сохранить.
+
+Изменено
+• Заголовок дневного вида показывает месяц.

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

@@ -0,0 +1,6 @@
+Opravené
+• Udalosti rýchlo presunuté za sebou sa už nestrácajú: presuny sa ukladajú postupne.
+• Správa upozorní, keď sa presun nepodarilo uložiť.
+
+Zmenené
+• Názov denného zobrazenia ukazuje mesiac.

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

@@ -0,0 +1,6 @@
+修复
+• 快速连续移动的日程不再丢失：移动会按顺序保存。
+• 移动无法保存时会显示提示。
+
+变更
+• 日视图标题显示月份。

fastlane/metadata/android/zh-TW/changelogs/2240299.txt

@@ -0,0 +1,6 @@
+修正
+• 快速連續移動的活動不再遺失：移動會依序儲存。
+• 移動無法儲存時會顯示訊息。
+
+變更
+• 日檢視標題會顯示月份。

gradle/libs.versions.toml

@@ -4,7 +4,7 @@ kotlin = "2.4.20"
 ksp = "2.3.11"
 hilt = "2.60.1"
 coreKtx = "1.19.0"
-appcompat = "1.7.1"
+appcompat = "1.8.0"
 lifecycleRuntime = "2.11.0"
 activityCompose = "1.13.0"
 composeBom = "2026.09.00"
@@ -18,7 +18,7 @@ junitPlatform = "6.1.3"
 truth = "1.4.5"
 androidxJunit = "1.3.0"
 espressoCore = "3.7.0"
-kotlinxDatetime = "0.7.0"
+kotlinxDatetime = "0.8.0-0.6.x-compat"
 kotlinxCoroutines = "1.11.0"
 turbine = "1.2.1"
 hiltNavigationCompose = "1.4.0"