Give search results the same width as other lists (#80)

The results list added its own 16dp horizontal inset on top of the one
GroupedRow already applies, so search rows sat 32dp in from each edge while
agenda and settings rows sit at 16dp.

.gitattributes

@@ -5,4 +5,3 @@
 *.jpg binary
 *.gif binary
 *.webp binary
-app/src/test/resources/ics/*.ics -text

.gitea/workflows/release.yaml

@@ -551,11 +551,12 @@ jobs:
     env:
       VERSION: ${{ needs.detect.outputs.version }}
       VERSION_CODE: ${{ needs.detect.outputs.version_code }}
-      # Where the bundle lands. `production` — the release itself is already the
-      # gate (a bumped versionName only reaches main after on-device review), so
-      # a second manual promotion in the Play Console bought nothing but delay.
-      # Override with the PLAY_TRACK repo variable to stage a release instead.
-      PLAY_TRACK: ${{ vars.PLAY_TRACK || 'production' }}
+      # Where the bundle lands. `internal` by default so a release reaches
+      # testers rather than the public, and promotion to production stays a
+      # deliberate human action in the Play Console — the same posture as
+      # holding UI releases for on-device review. Override with the PLAY_TRACK
+      # repo variable once the flow is trusted.
+      PLAY_TRACK: ${{ vars.PLAY_TRACK || 'internal' }}
       PLAY_RELEASE_STATUS: ${{ vars.PLAY_RELEASE_STATUS || 'completed' }}
       # Set PLAY_DRY_RUN=true to validate the edit against the API and discard
       # it instead of committing — used to rehearse the first upload.

CHANGELOG.md

@@ -7,256 +7,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-### Changed
-- Month-view event titles no longer end in an ellipsis. The "…" took the width
-  of a couple of characters and told you nothing you couldn't already see, so
-  the title now simply runs to the edge of its chip — a few more letters per
-  cell, which is often the difference between two events you can tell apart and
-  two you can't ([#164]).
-- Month-view events now show their start time before the title, where the chip
-  is wide enough to keep the title readable — in landscape, on a foldable and on
-  a tablet, and never at the cost of a narrow phone column. All-day events show
-  no time, and neither does a bar carried in from the previous week, whose start
-  is not in that row. Event times across the month, week and day views are also
-  set in a regular weight against the title's, so a time reads as a time rather
-  than as part of the name next to it ([#219]).
-- The calendar titles now shorten instead of being cut off. When the full month
-  name doesn't fit the top bar, the month and week views fall back to its
-  three-letter form and the day view drops the weekday, rather than trailing off
-  mid-word at large font sizes. The view switcher, the title and the agenda's
-  range bar also line up with the grid underneath them ([#165]).
-
-## [2.19.4] — 2026-09-01
-
-### Fixed
-- **A deleted occurrence no longer comes back when the series is re-timed.**
-  Delete a single occurrence of a repeating event, then change the time of the
-  whole series, and the occurrence you had removed reappeared. Doing it the
-  other way round — "This and all following events" — lost every removal in the
-  part of the series being changed. Removals now travel with the event: they
-  keep their place in the series across a time change, a move to a different
-  day, a timezone change and a switch to or from an all-day event, and they
-  carry over when a series is split. Repeating events on your device's own
-  calendars are affected, including the birthday and anniversary calendars
-  Calendula creates from your contacts ([#248]).
-- **Home-screen widgets now turn the page at midnight.** Both the month and the
-  agenda widget kept highlighting yesterday as "today" — and the agenda kept
-  greying out the wrong events as already past — until you paged the month back
-  and forth or removed and re-added the widget. Calendula now wakes itself at the
-  day boundary and redraws, and re-arms after a reboot, a clock change or a
-  flight into another timezone. Paging the month widget forward and back also
-  stops quietly pinning it to that month, so it follows the date again instead of
-  being stranded on the month you happened to be looking at ([#228]).
-- **"Only this event" now actually saves your edit.** On some calendars —
-  including Google ones that still show as on-device, and any local calendar —
-  editing a single occurrence of a repeating event did nothing at all: the scope
-  dialog closed, the edit screen stayed put, and saving again just repeated it.
-  Android can only attach a single-occurrence change to its series once the
-  calendar has been synced at least once, so on those calendars the change had
-  nowhere to go. Calendula now removes that one occurrence from the series and
-  saves the edit as its own event instead, which is what you see either way. A
-  save that does fail also says so for longer, rather than flashing past
-  ([#234]).
-- **A failed import no longer costs you the whole file.** One event the calendar
-  refuses used to abort the entire import with nothing on screen but "couldn't
-  read this file". Events are now added one at a time: anything rejected is
-  counted and shown, and the rest still arrive. A faulty repeat rule in the file
-  is repaired instead of being handed on ([#225]).
-- **All-day reminders survive a backup and an import.** They fire at the hour you
-  chose, not at midnight UTC — the same rule the app already applied to all-day
-  events you create yourself — and an export no longer leaves them out of the
-  file entirely. An imported yearly birthday fires at the right hour too, even
-  though the file dates it back to the year of birth ([#225]).
-- **Birthdays and anniversaries imported from Fossify Calendar now show up.**
-  Fossify writes the ones it mirrors from your contacts as events that start and
-  end on the same day, which the calendar read as lasting no time at all: they
-  imported without complaint and then appeared nowhere. Any all-day event that
-  ends where it starts, or carries no end at all, is now a one-day event
-  ([#225]).
-- **A backup no longer brings back occurrences you had deleted.** Remove a single
-  occurrence of a repeating event, back up, restore — and it was there again,
-  because the removals never made it into the file. They travel with the series
-  now, so a restored calendar looks the way you left it ([#225]).
-- **A reminder left on your account's default no longer went off as the event
-  started.** An event whose reminder says "Default" is the account's to time, not
-  Calendula's — it was reading that setting as a lead time of its own and firing a
-  minute after the event began. It now leaves such a reminder alone, and says so
-  on the event.
-- **"Only this event" on an event that doesn't repeat now edits or deletes it.**
-  Deleting used to write an exclusion onto a one-off event instead — which left
-  the event there and lost its end time — and editing filed the change away as an
-  exception to nothing, so it vanished.
-- **An import that the calendar cuts short now tells you how far it got.** Losing
-  the calendar or the permission part way through a big file reported the whole
-  import as failed, so importing again added everything twice.
-- **An event that runs past midnight can be dragged by either half.** Its second
-  half couldn't be picked up at all, and the first could only be moved later. Both
-  halves now move, and both are previewed while you hold either one, so the event
-  reads as moving rather than growing. The blocks are cut square at midnight
-  instead of rounded off, a month row draws an event crossing into the next week
-  as one bar, and a move across a daylight-saving change no longer lands an hour
-  out ([#253]).
-
-### Added
-- **More of an imported `.ics` survives the trip**: tasks come across as events
-  rather than being dropped in silence, deleted occurrences of a repeating event
-  stay deleted, a calendar named like the one the file came from is preselected,
-  and event colours are carried over — matched to the closest colour your
-  calendar's account offers, so a migrated calendar still reads at a glance
-  ([#225]).
-- **Belarusian, Hungarian and Slovak**, all three contributed as community
-  translations through
-  [Calendula's Weblate](https://weblate.dev.jeanlucmakiola.de/projects/calendula/).
-  Belarusian covers about nine tenths of the app, Slovak about a third and
-  Hungarian is just under way, so untranslated parts still show in English until
-  they fill out. Pick any of them under Settings → Language or in Android's
-  per-app language settings. Thanks to Dmitri Gabinski (Belarusian), Ábel Nagy
-  (Hungarian) and Julie (Slovak); help finishing them is very welcome.
-
-### Changed
-- **Arabic, Polish and Simplified Chinese are now complete**, all three carried
-  the rest of the way this cycle — Simplified Chinese from a fifth of the app to
-  all of it. Czech and Russian grew too — Russian to about half — and still have
-  room. Thanks to Sup99999 (Arabic), Bazyli Cyran (Polish), JeanWenzel
-  (Simplified Chinese), James Trivette (Czech), and SpiritOTHawk and Artur
-  (Russian).
-
-## [2.19.3] — 2026-08-22
-
-### Added
-- **Czech, Japanese and Russian**, all three contributed as community
-  translations through
-  [Calendula's Weblate](https://weblate.dev.jeanlucmakiola.de/projects/calendula/).
-  They are early — Czech covers about a third of the app, Russian a fifth,
-  Japanese has just started — so untranslated parts still show in English until
-  they fill out. Pick any of them under Settings → Language or in Android's
-  per-app language settings. Thanks to James Trivette (Czech), ame0011
-  (Japanese), and chip and Pablo (Russian); help finishing them is very welcome.
-
-### Changed
-- **Brazilian Portuguese is now complete**, covering the whole app. Thanks to
-  bkrz for carrying it the rest of the way.
-
-## [2.19.2] — 2026-08-17
-
-### Changed
-- **A meeting you declined is now struck through** wherever it appears — month,
-  week, day, agenda, search and both widgets — and no longer schedules a
-  reminder. Declining an invitation in Google Calendar left the event looking
-  like any other in Calendula, and it still notified you about a meeting you had
-  said no to. It stays visible rather than disappearing: the organiser still
-  expects an answer from you, and the slot is still spoken for ([#180]).
-
-### Fixed
-- **Tapping an event in month view opens the event**, not the day it sits on.
-  Every month style is affected — page, rolling, seamless weeks — and until now
-  the only way to reach an event from the month was to open its day first and
-  find it again there. Tapping anywhere else in the cell still opens the day
-  ([#187]).
-- **An edit made to an event now shows the moment you re-open it.** Adding a
-  description to an event and opening it again showed the sheet as it was before
-  the save, because the detail was only re-read when a different occurrence was
-  opened ([#196]).
-- **The month widget's arrows stopped working after a couple of taps.** The grid
-  was serialised as roughly 740 views, and one update ran to half a megabyte —
-  more than the launcher's buffer takes. The third update overran it, and Android
-  responded by dropping the whole widget host, which killed updates for *every*
-  widget on the home screen, ours and other apps', until the launcher rebound.
-  The grid now draws 192 views, and a resized widget reflows to its new size
-  instead of clipping ([#214]).
-- Tapping a widget's refresh or month arrows redraws that widget by its own id
-  instead of asking Android to update all of them, which does nothing in a
-  process the tap has just woken from cold ([#18]).
-- **Jump-to-today in seamless weeks lands on the current week** instead of
-  leaving a sliver of the previous row on screen ([#191]).
-- Day and week view no longer run their events flush against the right edge
-  ([#192]).
-
-## [2.19.1] — 2026-08-11
-
-### Added
-- **Drag to reschedule can be turned off.** Settings → Views → *Drag to
-  reschedule*, on by default. Off, no event can be picked up in the month, week
-  or day view — for anyone who kept moving appointments by accident while
-  scrolling ([#173]).
-- An early Brazilian Portuguese translation. Calendula has started speaking
-  Brazilian Portuguese, contributed as a community translation through
-  [Calendula's Weblate](https://weblate.dev.jeanlucmakiola.de/projects/calendula/).
-  About a third of the app is covered, so the rest still shows in English — you
-  can pick it under Settings → Language or in Android's per-app language
-  settings. Thanks to
-  [bkrz](https://weblate.dev.jeanlucmakiola.de/user/bkrz/) for getting it
-  started; help finishing it is very welcome.
-
-### Fixed
-- **The language picker forgot which language was picked.** Android hands the
-  applied language back with its script filled in — Simplified Chinese goes in
-  as `zh-CN` and comes out as `zh-Hans-CN` — so after a restart no entry in
-  Settings → Language showed as selected, and the row above it named the
-  language the long way round. Only languages that imply a script were
-  affected.
-
-## [2.19.0] — 2026-08-10
-
-### Added
-- **Drag an event to reschedule it.** Press and hold an event in the month,
-  week or day view and drop it on another time or day — the only way to move an
-  appointment used to be opening it and editing its start and end by hand. The
-  block follows your finger, the timeline scrolls when you carry it to an edge,
-  and the event's length is preserved: a 90-minute meeting dropped on 09:00 ends
-  at 10:30. In week and day view the drop snaps to 15-minute steps; in month
-  view it moves the event to the day you dropped it on and leaves the time
-  alone. A confirmation names the new slot and offers **Undo** wherever the move
-  can be taken back in one step. Events you can't edit — read-only calendars, and
-  birthdays and anniversaries mirrored from your contacts — can't be picked up.
-  Rescheduling isn't pointer-only: a screen reader gets a **Move…** action on
-  every event that can be moved ([#68]).
-- Dragging a **recurring** event asks what it should apply to, the same *this
-  event / this and following / all events* choice a save does. Where moving the
-  whole series would change which weekday it falls on, the rule is rewritten to
-  match — a weekly Monday event dropped on a Wednesday becomes a weekly
-  Wednesday event. Where it can't be rewritten safely, the prompt says so and
-  offers to move just the one occurrence, rather than quietly leaving the
-  series behind ([#68]).
-- **Delete several search results at once.** Long-press a hit in search to enter
-  selection mode, tap the rest (or **Select all**), and delete the lot in one
-  action — finding and removing, say, every leftover event with the same title
-  no longer means opening them one at a time. Recurring hits in the batch ask
-  once for the whole selection instead of once each, results on read-only
-  calendars can't be selected, and the deletion is confirmed before it runs
-  ([#80]).
-
-### Changed
-- **First launch is now a short wizard** instead of a single permission screen.
-  It counts its steps, each one can be stepped back out of, and beyond granting
-  calendar access it offers two things worth deciding once: turning on automatic
-  backup — chosen inline, folder picker and all, since events that live only on
-  the phone are lost with it — and choosing which view Calendula opens on, with
-  a live preview of the month, week, day and agenda layouts rather than four
-  names in a list. Both are skippable, everything chosen is changeable in
-  Settings afterwards, and the backup step is offered only where nothing
-  writable is being synced anywhere. Existing installs are not re-onboarded —
-  revoking and re-granting the calendar permission later does not restart the
-  wizard ([#163]).
-- The one-time notice about calendars switched off for this device is now a step
-  in the flow rather than a dialog thrown over the app on first open.
-
-### Fixed
-- Removed the deprecated `statusBarColor` / `navigationBarColor` theme
-  attributes the Play Console flags on Android 15 and up, where they no longer
-  do anything. The launch backdrop now picks its status-bar icons from the
-  light/dark resource instead, so they stay legible over it either way
-  ([#123]).
-
-## [2.18.1] — 2026-08-06
-
-### Fixed
-- Tapping an empty slot in week or day view creates the event at the hour you
-  tapped, after the timeline has been zoomed. Pinching the day taller or shorter
-  — or changing **Hour height** in Settings — left the tap still being measured
-  against the old spacing, so the new event landed at some other hour entirely
-  ([#148]).
-
 ## [2.18.0] — 2026-07-31
 
 ### Added
@@ -1573,23 +1323,3 @@ automatically, with zero telemetry and no internet permission.
 [#57]: https://codeberg.org/jlmakiola/calendula/issues/57
 [#56]: https://codeberg.org/jlmakiola/calendula/issues/56
 [#114]: https://codeberg.org/jlmakiola/calendula/issues/114
-[#148]: https://codeberg.org/jlmakiola/calendula/issues/148
-[#68]: https://codeberg.org/jlmakiola/calendula/issues/68
-[#80]: https://codeberg.org/jlmakiola/calendula/issues/80
-[#123]: https://codeberg.org/jlmakiola/calendula/issues/123
-[#163]: https://codeberg.org/jlmakiola/calendula/issues/163
-[#173]: https://codeberg.org/jlmakiola/calendula/issues/173
-[#164]: https://codeberg.org/jlmakiola/calendula/issues/164
-[#165]: https://codeberg.org/jlmakiola/calendula/issues/165
-[#180]: https://codeberg.org/jlmakiola/calendula/issues/180
-[#187]: https://codeberg.org/jlmakiola/calendula/issues/187
-[#191]: https://codeberg.org/jlmakiola/calendula/issues/191
-[#192]: https://codeberg.org/jlmakiola/calendula/issues/192
-[#196]: https://codeberg.org/jlmakiola/calendula/issues/196
-[#214]: https://codeberg.org/jlmakiola/calendula/issues/214
-[#225]: https://codeberg.org/jlmakiola/calendula/issues/225
-[#228]: https://codeberg.org/jlmakiola/calendula/issues/228
-[#234]: https://codeberg.org/jlmakiola/calendula/issues/234
-[#219]: https://codeberg.org/jlmakiola/calendula/issues/219
-[#248]: https://codeberg.org/jlmakiola/calendula/issues/248
-[#253]: https://codeberg.org/jlmakiola/calendula/issues/253

README.md

@@ -18,8 +18,6 @@ Reads, writes, and reminds — on top of the system calendar, with zero network
 <p>
 <a href="https://f-droid.org/packages/de.jeanlucmakiola.calendula/"><img src="https://fdroid.gitlab.io/artwork/badge/get-it-on.png" alt="Get it on F-Droid" height="56"></a>
 &nbsp;
-<a href="https://play.google.com/store/apps/details?id=de.jeanlucmakiola.calendula"><img src="https://play.google.com/intl/en_us/badges/static/images/badges/en_badge_web_generic.png" alt="Get it on Google Play" height="56"></a>
-&nbsp;
 <a href="https://apps.obtainium.imranr.dev/redirect?r=obtainium://add/https://codeberg.org/jlmakiola/calendula"><img src="https://github.com/ImranR98/Obtainium/blob/main/assets/graphics/badge_obtainium.png?raw=true" alt="Get it on Obtainium" height="56"></a>
 &nbsp;
 <a href="https://ko-fi.com/jeanlucmakiola"><img src="https://storage.ko-fi.com/cdn/brandasset/v2/support_me_on_kofi_badge_beige.png" alt="Support me on Ko-fi" height="56"></a>
@@ -88,7 +86,7 @@ Pick whichever channel you already use — they all install the same app:
 | [Official F-Droid](#f-droid-recommended) | On F-Droid's build schedule | Recommended; no extra setup |
 | [Self-hosted F-Droid repo](#self-hosted-f-droid-repo-fastest-updates) | Minutes after a release | Fastest; needs the repo added once |
 | [Codeberg release / Obtainium](#codeberg-release--obtainium) | Per release | Plain APK download, or automated by Obtainium |
-| [Google Play](#google-play) | Per release | Signed with Google's key — see below |
+| [Google Play](#google-play-coming-soon) | — | Coming soon |
 | [Build from source](#build-from-source) | Whenever you build | Full control |
 
 ### F-Droid (recommended)
@@ -133,14 +131,18 @@ or do it by hand: *Add App* → paste `https://codeberg.org/jlmakiola/calendula`
 → *Add*. Either way, Obtainium tracks the releases and prompts you when a new
 one appears.
 
-### Google Play
+### Google Play (coming soon)
 
-Calendula is live on Google Play:
-**[play.google.com/store/apps/details?id=de.jeanlucmakiola.calendula](https://play.google.com/store/apps/details?id=de.jeanlucmakiola.calendula)**.
+Calendula is on its way to Google Play as an additional channel. It isn't live
+yet — this section gets a link once it is. Play builds will be signed with
+Google's key rather than mine, so switching between Play and any other channel
+will require an uninstall.
 
-Play builds are signed with Google's key rather than mine, so switching between
-Play and any other channel requires an uninstall (and with it, a fresh start for
-app settings — your events live in the system calendar and are unaffected).
+> **Testers wanted.** Play requires a round of closed testing before the app can
+> go public, and I'm still looking for testers. If you'd like to help, email
+> **[business@jeanlucmakiola.de](mailto:business@jeanlucmakiola.de)** with the
+> Google account address you want to use — that address is what I need to add you
+> to the closed test.
 
 ### Build from source
 
@@ -149,7 +151,7 @@ The build is a plain Gradle build with no proprietary dependencies — see
 
 <sub>Official F-Droid, the self-hosted repo, and the Codeberg releases all share
 the same signing key, so you can switch freely between them without
-reinstalling. Google Play is the exception — see above.</sub>
+reinstalling.</sub>
 
 ## 📚 Documentation
 

app/build.gradle.kts

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

app/proguard-rules.pro

@@ -50,9 +50,3 @@
 # the real names also survives app updates, which would otherwise renumber the
 # obfuscated name and orphan the stored mapping.
 -keep class * extends androidx.glance.appwidget.GlanceAppWidget
-
-# Belt and braces one level up: the two receivers are nearly as alike, and the
-# provider map is keyed off the receiver component too. Redundant today (AGP's
-# manifest-derived rules cover them), but #89 cost a release to diagnose and the
-# guarantee should not rest on a component staying in the manifest.
--keep class * extends androidx.glance.appwidget.GlanceAppWidgetReceiver

app/src/androidTest/java/de/jeanlucmakiola/calendula/ui/permission/PermissionScreenTest.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.onboarding
+package de.jeanlucmakiola.calendula.ui.permission
 
 import androidx.compose.ui.test.assertIsDisplayed
 import androidx.compose.ui.test.junit4.createComposeRule

app/src/main/AndroidManifest.xml

@@ -330,13 +330,9 @@
         </receiver>
 
         <!-- Keeps both widgets fresh: the calendar provider broadcasts
-             PROVIDER_CHANGED on any data change (our writes and external sync).
-             The day boundary arrives as the app's own ROLLOVER alarm (#228), by
-             explicit PendingIntent, so it needs no filter here; DATE_CHANGED is
-             a free extra only, since Android 8+ withholds it from manifest
-             receivers. The four below re-arm that alarm: TIME_SET /
-             TIMEZONE_CHANGED move the boundary, boot / package-replace wipe it.
-             Exported: the system broadcasts arrive from outside the app. -->
+             PROVIDER_CHANGED on any data change (our writes and external sync),
+             and the system broadcasts the date/time ones at midnight / clock
+             changes so "today" highlighting rolls over. -->
         <receiver
             android:name=".widget.WidgetUpdateReceiver"
             android:exported="true">
@@ -350,8 +346,6 @@
                 <action android:name="android.intent.action.DATE_CHANGED" />
                 <action android:name="android.intent.action.TIME_SET" />
                 <action android:name="android.intent.action.TIMEZONE_CHANGED" />
-                <action android:name="android.intent.action.BOOT_COMPLETED" />
-                <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
             </intent-filter>
         </receiver>
 

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

@@ -10,7 +10,6 @@ import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesScheduler
 import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesSyncWorker
 import de.jeanlucmakiola.calendula.data.reminders.ReminderMaintenanceScheduler
 import de.jeanlucmakiola.calendula.data.reminders.ReminderMaintenanceWorker
-import de.jeanlucmakiola.calendula.widget.WidgetRolloverScheduler
 import de.jeanlucmakiola.floret.crash.CrashConfig
 import de.jeanlucmakiola.floret.crash.CrashReporter
 import kotlinx.coroutines.CoroutineScope
@@ -45,19 +44,6 @@ class CalendulaApp : Application() {
         reconcileSpecialDates()
         reconcileCalendarVisibility()
         startReminderDelivery()
-        reconcileWidgetRollover()
-    }
-
-    /**
-     * Re-arm the widgets' midnight rollover from whatever is actually placed
-     * (#228). Idempotent, and it covers what no broadcast reaches — an alarm
-     * dropped by a force-stop is armed again the next time the app is opened.
-     * Off the main thread: a handful of binder calls on every process start.
-     */
-    private fun reconcileWidgetRollover() {
-        CoroutineScope(SupervisorJob() + Dispatchers.Default).launch {
-            WidgetRolloverScheduler.sync(this@CalendulaApp)
-        }
     }
 
     /**

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

@@ -31,13 +31,9 @@ private const val MILLIS_PER_MINUTE = 60_000L
  * event (a whole-day multiple; sub-day remainders are dropped), so it fires at
  * [timeOfDayMinutes] (minutes from local midnight) in [zone]. The result may be
  * **negative** — e.g. "at time of event" at 09:00 CEST encodes to −420, meaning
- * the provider fires *after* DTSTART; this is valid and must not be clamped. The
- * one negative it never is is [MINUTES_DEFAULT]: the sentinel and the encoding
- * share a value space, so an encoding that lands on it is nudged one minute past
- * it rather than being read back as "use the account default". That sentinel is
- * also the one [semanticMinutes] that passes through unencoded — a lead time may
- * itself be negative (a foreign row firing the day *after* the event), and
- * waving those through would change when they fire.
+ * the provider fires *after* DTSTART; this is valid and must not be clamped.
+ * A negative [semanticMinutes] is the "provider default" sentinel and passes
+ * through unchanged.
  */
 internal fun toProviderAllDayMinutes(
     semanticMinutes: Int,
@@ -45,13 +41,12 @@ internal fun toProviderAllDayMinutes(
     zone: ZoneId,
     timeOfDayMinutes: Int,
 ): Int {
-    if (semanticMinutes == MINUTES_DEFAULT) return semanticMinutes
+    if (semanticMinutes < 0) return semanticMinutes
     val utcMidnight = startDate.atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli()
     val fire = startDate.minusDays((semanticMinutes / MINUTES_PER_DAY).toLong())
         .atTime(LocalTime.of(timeOfDayMinutes / 60, timeOfDayMinutes % 60))
         .atZone(zone).toInstant().toEpochMilli()
-    val raw = ((utcMidnight - fire) / MILLIS_PER_MINUTE).toInt()
-    return if (raw == MINUTES_DEFAULT) MINUTES_DEFAULT - 1 else raw
+    return ((utcMidnight - fire) / MILLIS_PER_MINUTE).toInt()
 }
 
 /**
@@ -75,52 +70,15 @@ internal fun nextYearlyOccurrence(month: Int, day: Int, today: LocalDate): Local
     return LocalDate.of(today.year, month, day)
 }
 
-/**
- * The date an **imported** all-day event's reminder offset is sampled at.
- *
- * A one-off fires once, on its own date. A series' `DTSTART` is only an anchor
- * and may be ancient — Fossify writes a year-less contact birthday at 1970, a
- * year whose rules predate DST across most of Europe, and a real birth year is
- * usually older still — so sampling there skews every modern occurrence by the
- * offset delta (the same trap [nextYearlyOccurrence] exists for). A yearly
- * series is therefore sampled at its next occurrence of the anchor's month/day,
- * which shares the season; any other series at [today], which its upcoming
- * occurrences are near.
- *
- * The decode side ([fromProviderAllDayMinutes]) only asks which local *day* the
- * encoded instant falls on, so it still reads the lead time back correctly from
- * the anchor's own date.
- */
-internal fun importedAllDayReminderDate(
-    startDate: LocalDate,
-    recurrenceRule: String?,
-    today: LocalDate,
-): LocalDate = when {
-    recurrenceRule.isNullOrBlank() -> startDate
-    recurrenceRule.contains("FREQ=YEARLY", ignoreCase = true) ->
-        nextYearlyOccurrence(startDate.monthValue, startDate.dayOfMonth, today)
-    startDate.isBefore(today) -> today
-    else -> startDate
-}
-
 /**
  * Recover the semantic whole-day lead time from a raw all-day reminder
  * [rawMinutes] — the inverse of [toProviderAllDayMinutes], for the form and the
  * detail screen. Delegates to [allDayLeadDays], so the day displayed is the day
  * the reminder actually fires on.
- *
- * [MINUTES_DEFAULT] passes through unchanged, the mirror of the encode side. A
- * real encoding is often negative, so only that exact value may be treated as the
- * sentinel — decoding it would land it on the start date and turn "use the
- * account default" into a concrete at-start alarm.
  */
 internal fun fromProviderAllDayMinutes(
     rawMinutes: Int,
     startDate: LocalDate,
     zone: ZoneId,
     timeOfDayMinutes: Int,
-): Int = if (rawMinutes == MINUTES_DEFAULT) {
-    rawMinutes
-} else {
-    allDayLeadDays(rawMinutes, startDate, zone, timeOfDayMinutes).toInt() * MINUTES_PER_DAY
-}
+): Int = allDayLeadDays(rawMinutes, startDate, zone, timeOfDayMinutes).toInt() * MINUTES_PER_DAY

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

@@ -27,15 +27,12 @@ import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.curatedForPicker
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.domain.EventSearch
 import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.Reminder
-import de.jeanlucmakiola.calendula.domain.SearchCandidate
 import de.jeanlucmakiola.calendula.domain.contacts.MANAGED_UID_PREFIX
 import de.jeanlucmakiola.calendula.domain.contacts.SpecialDateType
 import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
 import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
-import de.jeanlucmakiola.calendula.domain.ics.semanticReminderMinutes
 import de.jeanlucmakiola.calendula.domain.rruleTruncatedAt
 import kotlinx.datetime.toJavaLocalDate
 import java.time.Instant
@@ -65,14 +62,12 @@ interface CalendarDataSource {
     fun eventDetail(eventId: Long, allDayReminderTimeMinutes: Int): EventDetail?
 
     /**
-     * Master/one-off events that may match [query], across all calendars: every
-     * whitespace-separated token has to appear in the title, description or
-     * location. Reads the Events table directly so the search is unbounded in
-     * time; exception rows are excluded (see [SearchProjection]). A deliberate
-     * superset — [EventSearch] makes the final call and orders the hits.
-     * [query] is assumed non-blank.
+     * Master/one-off events whose title, description or location contains
+     * [query] (case-insensitive), across all calendars, newest first. Reads the
+     * Events table directly so the search is unbounded in time; exception rows
+     * are excluded (see [SearchProjection]). [query] is assumed non-blank.
      */
-    fun searchEvents(query: String): List<SearchCandidate>
+    fun searchEvents(query: String): List<EventInstance>
 
     /**
      * The event-colour palette the calendar's account publishes
@@ -85,25 +80,14 @@ interface CalendarDataSource {
      */
     fun eventColorPalette(calendarId: Long): List<EventColorOption>
 
-    /**
-     * The same palette **uncurated** — every key the account publishes, in
-     * provider order. Curation is a display concession (it folds look-alikes and
-     * drops the neutrals outright from an oversized palette), so matching a
-     * colour that came from outside the account has to run against the full set:
-     * those keys are all the calendar accepts. See [eventColorPalette].
-     */
-    fun publishedEventColors(calendarId: Long): List<EventColorOption>
-
     /**
      * Every master/one-off event of the writable local calendars, mapped for a
      * whole-calendar `.ics` backup. Modified-occurrence and cancelled-exception
      * rows are excluded (see [EventExportProjection]). When [calendarIds] is
      * given, only those calendars are exported (still intersected with the
      * eligible set); `null` exports every eligible calendar.
-     * [allDayReminderTimeMinutes]: needed to write all-day reminders as whole-day
-     * lead times rather than raw provider offsets (see [toIcsEvent]).
      */
-    fun exportableEvents(calendarIds: Set<Long>?, allDayReminderTimeMinutes: Int): List<IcsEvent>
+    fun exportableEvents(calendarIds: Set<Long>? = null): List<IcsEvent>
 
     /**
      * The non-empty `Events.UID_2445` values present in [calendarId] — used to
@@ -113,19 +97,10 @@ interface CalendarDataSource {
 
     /**
      * Insert a parsed `.ics` event into [calendarId], preserving its UID (or
-     * minting one when absent); returns the new `Events._ID`.
-     *
-     * [colorPalette] is the target account's published event colours
-     * ([publishedEventColors]), looked up once per import;
-     * [allDayReminderTimeMinutes] is the user's preferred all-day firing time,
-     * applied exactly as a hand-created event's is.
+     * minting one when absent); returns the new `Events._ID`. Reminders are
+     * written as the file's raw lead minutes (METHOD_ALERT).
      */
-    fun insertImportedEvent(
-        event: ParsedIcsEvent,
-        calendarId: Long,
-        allDayReminderTimeMinutes: Int,
-        colorPalette: List<EventColorOption>,
-    ): Long
+    fun insertImportedEvent(event: ParsedIcsEvent, calendarId: Long): Long
 
     /**
      * Create a new device-only (`ACCOUNT_TYPE_LOCAL`) calendar the app owns;
@@ -253,21 +228,14 @@ interface CalendarDataSource {
     ): Long
 
     /**
-     * Change a single occurrence of a recurring event at [beginMillis] (the
-     * occurrence's `Instances.BEGIN`) to [form]'s values; returns the
-     * `Events._ID` of the row now holding them.
-     *
-     * A series with a `_sync_id` gets a modified-occurrence exception. One
-     * without gets the occurrence excluded from the parent via EXDATE plus a
-     * standalone event carrying the edits — an exception cannot link to its
-     * parent there (Codeberg #234, the same constraint as [deleteOccurrence]).
-     * A row that turns out not to recur at all is edited whole, which is what
-     * [original] is for. [allDayReminderTimeMinutes]: see [insertEvent].
+     * Change a single occurrence of a recurring event by inserting a
+     * modified-occurrence exception at [beginMillis] (the occurrence's
+     * `Instances.BEGIN`) carrying [form]'s values; returns the exception
+     * row's `Events._ID`. [allDayReminderTimeMinutes]: see [insertEvent].
      */
     fun updateOccurrence(
         eventId: Long,
         beginMillis: Long,
-        original: EventForm,
         form: EventForm,
         allDayReminderTimeMinutes: Int,
     ): Long
@@ -617,23 +585,20 @@ class AndroidCalendarDataSource @Inject constructor(
         )?.use { c -> c.mapAllNotNull { CursorColumnReader(c).toEventInstance() } } ?: emptyList()
     }
 
-    override fun searchEvents(query: String): List<SearchCandidate> {
+    override fun searchEvents(query: String): List<EventInstance> {
         ensureObserversRegistered()
-        val tokens = EventSearch.tokenize(query).take(MAX_SEARCH_TOKENS)
-        if (tokens.isEmpty()) return emptyList()
-        // Only a pre-filter: EventSearch re-checks every token, including the
-        // ones the cap above dropped.
-        val patterns = tokens.map { likePatterns(it) }
-        val match = patterns.joinToString(" AND ") { variants ->
-            variants.joinToString(" OR ", prefix = "(", postfix = ")") {
-                "${CalendarContract.Events.TITLE} LIKE ? ESCAPE '\\' OR " +
-                    "${CalendarContract.Events.DESCRIPTION} LIKE ? ESCAPE '\\' OR " +
-                    "${CalendarContract.Events.EVENT_LOCATION} LIKE ? ESCAPE '\\'"
-            }
-        }
-        val args = patterns
-            .flatMap { variants -> variants.flatMap { pattern -> List(3) { pattern } } }
-            .toTypedArray()
+        val trimmed = query.trim()
+        if (trimmed.isEmpty()) return emptyList()
+        // Escape the SQL LIKE wildcards so a literal % or _ in the query matches
+        // itself instead of acting as a wildcard.
+        val escaped = trimmed
+            .replace("\\", "\\\\")
+            .replace("%", "\\%")
+            .replace("_", "\\_")
+        val like = "%$escaped%"
+        val match = "${CalendarContract.Events.TITLE} LIKE ? ESCAPE '\\' OR " +
+            "${CalendarContract.Events.DESCRIPTION} LIKE ? ESCAPE '\\' OR " +
+            "${CalendarContract.Events.EVENT_LOCATION} LIKE ? ESCAPE '\\'"
         val selection = "($match) AND " +
             "${CalendarContract.Events.DELETED} = 0 AND " +
             "${CalendarContract.Events.ORIGINAL_ID} IS NULL"
@@ -641,17 +606,17 @@ class AndroidCalendarDataSource @Inject constructor(
             CalendarContract.Events.CONTENT_URI,
             SearchProjection.COLUMNS,
             selection,
-            args,
+            arrayOf(like, like, like),
             CalendarContract.Events.DTSTART + " DESC",
         )?.use { c ->
             val reader = CursorColumnReader(c)
-            val out = ArrayList<SearchCandidate>(c.count)
+            val out = ArrayList<EventInstance>(c.count)
             while (c.moveToNext()) {
-                val description = reader.getString(SearchProjection.IDX_DESCRIPTION)
                 val base = reader.toSearchResult() ?: continue
-                // A recurring master's DTSTART is the series start; date the row
-                // by its nearest occurrence instead.
-                val event = if (base.isRecurring) {
+                // A recurring master's DTSTART is the series start; show its
+                // nearest occurrence instead so the date is the one the user
+                // actually cares about (and sorting reflects it).
+                out += if (base.isRecurring) {
                     nearestOccurrenceMillis(base.eventId)?.let { (begin, end) ->
                         base.copy(
                             start = begin.toKotlinInstantFromEpochMillis(),
@@ -661,44 +626,11 @@ class AndroidCalendarDataSource @Inject constructor(
                 } else {
                     base
                 }
-                // The raw title, so matching can't catch on the placeholder an
-                // untitled event is drawn with.
-                out += SearchCandidate(
-                    event = event,
-                    description = description,
-                    title = reader.getString(SearchProjection.IDX_TITLE),
-                )
             }
             out
         } ?: emptyList()
     }
 
-    /**
-     * One token as the `LIKE` patterns to OR together. SQLite folds case for
-     * ASCII only, so a token with cased non-ASCII letters is also queried lower-,
-     * upper- and title-cased, which is how "ärzte" reaches "Ärzte". Wildcarding
-     * those letters away instead would make "москва" `%______%` — a full scan.
-     */
-    private fun likePatterns(token: String): List<String> {
-        if (token.none { it.code > 127 && (it.isUpperCase() || it.isLowerCase()) }) {
-            return listOf(likePattern(token))
-        }
-        val lower = token.lowercase()
-        return listOf(token, lower, token.uppercase(), lower.replaceFirstChar(Char::uppercaseChar))
-            .distinct()
-            .map(::likePattern)
-    }
-
-    private fun likePattern(token: String): String {
-        val sb = StringBuilder("%")
-        for (c in token) {
-            // A literal wildcard from the query matches itself.
-            if (c == '%' || c == '_' || c == '\\') sb.append('\\')
-            sb.append(c)
-        }
-        return sb.append('%').toString()
-    }
-
     /**
      * The occurrence of [eventId] nearest to now: the soonest upcoming one
      * within [OCCURRENCE_WINDOW_MILLIS] ahead, else the most recent past one
@@ -749,10 +681,7 @@ class AndroidCalendarDataSource @Inject constructor(
         }
     }
 
-    override fun eventColorPalette(calendarId: Long): List<EventColorOption> =
-        publishedEventColors(calendarId).curatedForPicker()
-
-    override fun publishedEventColors(calendarId: Long): List<EventColorOption> {
+    override fun eventColorPalette(calendarId: Long): List<EventColorOption> {
         val account = calendarAccount(calendarId) ?: return emptyList()
         return resolver.query(
             CalendarContract.Colors.CONTENT_URI,
@@ -770,13 +699,11 @@ class AndroidCalendarDataSource @Inject constructor(
             c.mapAll { EventColorOption(key = it.getString(0).orEmpty(), argb = it.getInt(1)) }
         }
             ?.filter { it.key.isNotEmpty() }
+            ?.curatedForPicker()
             ?: emptyList()
     }
 
-    override fun exportableEvents(
-        calendarIds: Set<Long>?,
-        allDayReminderTimeMinutes: Int,
-    ): List<IcsEvent> {
+    override fun exportableEvents(calendarIds: Set<Long>?): List<IcsEvent> {
         // Only the local calendars the app owns and can write — synced calendars
         // already have a backup (their server). Exclude the managed special-dates
         // mirror calendars: their events are derived from contacts, not authored
@@ -811,7 +738,6 @@ class AndroidCalendarDataSource @Inject constructor(
                 reader.toIcsEvent(
                     reminderMinutes = queryReminders(eventId).map { it.minutes },
                     calendarName = names[calendarId],
-                    allDayReminderTimeMinutes = allDayReminderTimeMinutes,
                 )
             }
         } ?: emptyList()
@@ -820,83 +746,76 @@ class AndroidCalendarDataSource @Inject constructor(
     override fun existingUids(calendarId: Long): Set<String> = resolver.query(
         CalendarContract.Events.CONTENT_URI,
         arrayOf(CalendarContract.Events.UID_2445),
-        // DELETED rows linger until a sync adapter purges them; counting those
-        // as present would make a re-import skip everything the user has since
-        // deleted, reporting "all duplicates" and importing nothing.
         "${CalendarContract.Events.CALENDAR_ID} = ? AND " +
-            "${CalendarContract.Events.UID_2445} IS NOT NULL AND " +
-            "${CalendarContract.Events.DELETED} = 0",
+            "${CalendarContract.Events.UID_2445} IS NOT NULL",
         arrayOf(calendarId.toString()),
         null,
     )?.use { c ->
         buildSet { while (c.moveToNext()) c.getString(0)?.takeIf { it.isNotEmpty() }?.let(::add) }
     } ?: emptySet()
 
-    override fun insertImportedEvent(
-        event: ParsedIcsEvent,
-        calendarId: Long,
-        allDayReminderTimeMinutes: Int,
-        colorPalette: List<EventColorOption>,
-    ): Long {
-        val values = buildImportedEventValues(
-            event = event,
-            calendarId = calendarId,
+    override fun insertImportedEvent(event: ParsedIcsEvent, calendarId: Long): Long {
+        val startMillis = event.start.toEpochMillis()
+        val endMillis = event.end.toEpochMillis()
+        val values = ContentValues().apply {
+            put(CalendarContract.Events.CALENDAR_ID, calendarId)
             // Preserve the file's UID so a re-import dedups against it; mint one
             // only when the source event carried none.
-            uid = event.uid?.takeIf { it.isNotBlank() } ?: "${UUID.randomUUID()}@calendula",
-            palette = colorPalette,
-        )
-        val uri = resolver.insert(CalendarContract.Events.CONTENT_URI, values.toContentValues())
+            put(
+                CalendarContract.Events.UID_2445,
+                event.uid?.takeIf { it.isNotBlank() } ?: "${UUID.randomUUID()}@calendula",
+            )
+            put(CalendarContract.Events.TITLE, event.summary.trim())
+            put(CalendarContract.Events.ALL_DAY, if (event.isAllDay) 1 else 0)
+            put(CalendarContract.Events.DTSTART, startMillis)
+            if (event.recurrenceRule == null) {
+                put(CalendarContract.Events.DTEND, endMillis)
+            } else {
+                put(CalendarContract.Events.RRULE, event.recurrenceRule)
+                put(
+                    CalendarContract.Events.DURATION,
+                    importDuration(startMillis, endMillis, event.isAllDay),
+                )
+            }
+            // All-day rows live at UTC midnights (the file already encodes them so);
+            // timed rows keep the event's own zone.
+            put(CalendarContract.Events.EVENT_TIMEZONE, if (event.isAllDay) "UTC" else event.zoneId)
+            put(CalendarContract.Events.AVAILABILITY, event.availability.toProviderValue())
+            put(CalendarContract.Events.STATUS, event.status.toProviderStatus())
+            event.location?.trim()?.takeIf { it.isNotEmpty() }
+                ?.let { put(CalendarContract.Events.EVENT_LOCATION, it) }
+            event.description?.trim()?.takeIf { it.isNotEmpty() }
+                ?.let { put(CalendarContract.Events.DESCRIPTION, it) }
+        }
+        val uri = resolver.insert(CalendarContract.Events.CONTENT_URI, values)
             ?: throw WriteFailedException("import event into calendar id=$calendarId")
         val eventId = ContentUris.parseId(uri)
-        val zone = ZoneId.systemDefault()
-        // An all-day reminder is stored the same way a hand-created one is, so it
-        // fires at the time the user picked rather than at UTC midnight — sampled
-        // where it will actually fire, not at an ancient recurrence anchor
-        // (see [importedAllDayReminderDate]).
-        val reminderDate = if (event.isAllDay) {
-            importedAllDayReminderDate(
-                startDate = Instant.ofEpochMilli(event.start.toEpochMilliseconds())
-                    .atZone(ZoneOffset.UTC).toLocalDate(),
-                recurrenceRule = event.recurrenceRule,
-                today = LocalDate.now(zone),
-            )
-        } else {
-            null
-        }
-        event.semanticReminderMinutes().forEach { minutes ->
-            val providerMinutes = if (reminderDate != null) {
-                toProviderAllDayMinutes(
-                    semanticMinutes = minutes,
-                    startDate = reminderDate,
-                    zone = zone,
-                    timeOfDayMinutes = allDayReminderTimeMinutes,
-                )
-            } else {
-                minutes
-            }
+        // Raw lead minutes straight from the file's VALARMs (best-effort, like insertEvent).
+        event.reminderMinutes.distinct().filter { it >= 0 }.forEach { minutes ->
             val reminder = ContentValues().apply {
                 put(CalendarContract.Reminders.EVENT_ID, eventId)
-                put(CalendarContract.Reminders.MINUTES, providerMinutes)
+                put(CalendarContract.Reminders.MINUTES, minutes)
                 put(CalendarContract.Reminders.METHOD, CalendarContract.Reminders.METHOD_ALERT)
             }
-            // The event row is already in. A reminder that won't attach costs
-            // that one alarm, not the event: throwing here would have the import
-            // count an event it did create as failed, and the retry would then
-            // skip it as a duplicate.
-            val attached = try {
-                resolver.insert(CalendarContract.Reminders.CONTENT_URI, reminder)
-            } catch (e: Exception) {
-                Log.w(TAG, "Reminder insert threw for imported event $eventId", e)
-                null
-            }
-            if (attached == null) {
+            if (resolver.insert(CalendarContract.Reminders.CONTENT_URI, reminder) == null) {
                 Log.w(TAG, "Failed to attach reminder ($minutes min) to imported event $eventId")
             }
         }
         return eventId
     }
 
+    /** Provider DURATION for an imported recurring row: whole days / seconds. */
+    private fun importDuration(startMillis: Long, endMillis: Long, isAllDay: Boolean): String {
+        val span = (endMillis - startMillis).coerceAtLeast(0)
+        return if (isAllDay) "P${span / 86_400_000L}D" else "P${span / 1_000L}S"
+    }
+
+    private fun EventStatus.toProviderStatus(): Int = when (this) {
+        EventStatus.Confirmed -> CalendarContract.Events.STATUS_CONFIRMED
+        EventStatus.Tentative -> CalendarContract.Events.STATUS_TENTATIVE
+        EventStatus.Cancelled -> CalendarContract.Events.STATUS_CANCELED
+    }
+
     /** The account a calendar belongs to, for scoping a `Colors` lookup. */
     private fun calendarAccount(calendarId: Long): CalendarAccount? = resolver.query(
         ContentUris.withAppendedId(CalendarContract.Calendars.CONTENT_URI, calendarId),
@@ -1017,12 +936,10 @@ class AndroidCalendarDataSource @Inject constructor(
         updated: EventForm,
         allDayReminderTimeMinutes: Int,
     ) {
-        val row = querySeriesRow(eventId)
         val values = buildEventUpdateValues(
             original = original,
             updated = updated,
-            seriesDtStartMillis = row.dtStartMillis,
-            seriesExdate = row.exdate,
+            seriesDtStartMillis = querySeriesRow(eventId).dtStartMillis,
             zone = ZoneId.systemDefault(),
         )
         if (values.isNotEmpty()) {
@@ -1234,22 +1151,9 @@ class AndroidCalendarDataSource @Inject constructor(
     override fun updateOccurrence(
         eventId: Long,
         beginMillis: Long,
-        original: EventForm,
         form: EventForm,
         allDayReminderTimeMinutes: Int,
     ): Long {
-        val row = querySeriesRow(eventId)
-        // Not a series, so there is no occurrence to single out: the row *is* the
-        // event, and an exception with nothing to be an exception to would leave
-        // an orphan holding the edit (the same test deleteOccurrence makes).
-        if (!row.recurs) {
-            updateEvent(eventId, original, form, allDayReminderTimeMinutes)
-            return eventId
-        }
-        // EXDATE needs no _sync_id; a modified exception does.
-        if (row.syncId == null) {
-            return detachOccurrence(eventId, beginMillis, row, form, allDayReminderTimeMinutes)
-        }
         // The provider clones the series row and applies these values on top.
         val values = buildOccurrenceExceptionValues(
             form = form,
@@ -1268,90 +1172,6 @@ class AndroidCalendarDataSource @Inject constructor(
         return exceptionId
     }
 
-    /**
-     * "Edit only this event" on a series with **no `_sync_id`**: drop the
-     * occurrence from the parent with EXDATE and insert the edited values as a
-     * standalone event on the same calendar.
-     *
-     * A modified exception attaches to its parent only through `ORIGINAL_SYNC_ID`,
-     * exactly like the cancelled one [deleteOccurrence] documents; with no
-     * `_sync_id` the link never forms and the edit is lost (Codeberg #234).
-     * EXDATE plus a standalone row needs no link — what a detached instance
-     * degrades to without a `RECURRENCE-ID` to carry it.
-     *
-     * The detached row keeps no stored link back to its series, so: it no longer
-     * travels with it ([moveEvent] copies the master and its `ORIGINAL_ID`
-     * children, and this is neither); its EXDATE hole is an absolute instant, so
-     * re-timing the whole series brings the occurrence back beside the copy (a
-     * #47 delete resurrects the same way); and it is built from the form, not
-     * cloned, so `ORGANIZER`, `STATUS` and the attendee rows [reconcileAttendees]
-     * preserves are dropped — the same limitation as [moveEvent].
-     *
-     * Insert first, so a failure leaves the series untouched
-     * ([updateEventFromOccurrence]'s discipline); roll the new row back if the
-     * EXDATE update then fails, since it would be a visible duplicate. The
-     * reverse order risks the worse outcome — an excluded occurrence with no
-     * replacement, i.e. an edit that quietly deletes.
-     */
-    private fun detachOccurrence(
-        eventId: Long,
-        beginMillis: Long,
-        row: SeriesRow,
-        form: EventForm,
-        allDayReminderTimeMinutes: Int,
-    ): Long {
-        // Already detached (or deleted) from a stale screen still pointing at the
-        // parent: the EXDATE merge would fold the repeat away and still report a
-        // changed row, quietly leaving a *second* standalone copy.
-        if (exdateContains(row.exdate, beginMillis, row.allDay != 0, row.timezone)) {
-            throw NoSuchEventException(eventId)
-        }
-        // Reminders, guests and colour come along like any new event, and so does
-        // a fresh UID — the detached row is a separate event now, and sharing the
-        // parent's would collide with it in .ics restore dedup.
-        val detachedId = insertEvent(form.toDetachedOccurrence(), allDayReminderTimeMinutes)
-        val values = buildOccurrenceExdateValues(
-            existingExdate = row.exdate,
-            occurrenceMillis = beginMillis,
-            dtStartMillis = row.dtStartMillis,
-            rrule = row.rrule,
-            rdate = row.rdate,
-            duration = row.duration,
-            timezone = row.timezone,
-            allDay = row.allDay,
-        )
-        // Rows touched, not occurrences excluded — 1 whenever the series row still
-        // exists. It catches the row disappearing under us, not an EXDATE the
-        // provider's expansion fails to match.
-        val updatedRows = try {
-            resolver.update(
-                ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, eventId),
-                values.toContentValues(), null, null,
-            )
-        } catch (t: Throwable) {
-            rollBackDetached(detachedId)
-            throw t
-        }
-        if (updatedRows == 0) {
-            rollBackDetached(detachedId)
-            throw WriteFailedException(
-                "exdate occurrence for edit, event id=$eventId begin=$beginMillis",
-            )
-        }
-        return detachedId
-    }
-
-    /**
-     * Undo the standalone row [detachOccurrence] inserted before its EXDATE
-     * update failed. Best effort: the caller is already throwing, and the worst
-     * case is the duplicate we were avoiding — never a lost occurrence.
-     */
-    private fun rollBackDetached(detachedId: Long) {
-        runCatching { deleteEvent(detachedId) }.onFailure {
-            Log.w(TAG, "Failed to roll back detached occurrence $detachedId", it)
-        }
-    }
-
     override fun updateEventFromOccurrence(
         eventId: Long,
         beginMillis: Long,
@@ -1368,71 +1188,10 @@ class AndroidCalendarDataSource @Inject constructor(
         }
         // Insert the new series first: if it fails, the original is untouched.
         val newEventId = insertEvent(updated, allDayReminderTimeMinutes)
-        carrySplitExdate(newEventId, row, beginMillis, original, updated)
         truncateSeries(eventId, row, beginMillis)
         return newEventId
     }
 
-    /**
-     * Carry the [parent]'s exclusions for occurrences past [beginMillis] onto the
-     * series [newEventId] that now owns them, re-timed by the shift the split
-     * applied ([shiftedExdate]/[exdateAfter]). [insertEvent] builds the new row
-     * from the form, which knows nothing about them, so without this every
-     * occurrence the user had deleted from the tail of the series comes back.
-     *
-     * The whole time/recurrence set rides along with EXDATE for the reason
-     * [buildOccurrenceExdateValues] documents: on its own the provider does not
-     * read an EXDATE write as a recurrence change, and leaves the instances it
-     * expanded on insert standing.
-     *
-     * A failure rolls the new series back and throws, so the split fails whole
-     * rather than landing with the exclusions quietly dropped — the parent is
-     * still untruncated at this point, so the event is left exactly as it was.
-     */
-    private fun carrySplitExdate(
-        newEventId: Long,
-        parent: SeriesRow,
-        beginMillis: Long,
-        original: EventForm,
-        updated: EventForm,
-    ) {
-        // Dropping the recurrence in the same save leaves a one-off tail, and an
-        // exclusion means nothing on a row that doesn't recur.
-        if (updated.rrule.isNullOrBlank()) return
-        val carried = shiftedExdate(
-            existingExdate = exdateAfter(
-                parent.exdate,
-                beginMillis,
-                original.isAllDay,
-                parent.timezone,
-            ),
-            original = original,
-            updated = updated,
-            zone = ZoneId.systemDefault(),
-        ) ?: return
-        val row = querySeriesRow(newEventId)
-        val values = ContentValues().apply {
-            put(CalendarContract.Events.EXDATE, carried)
-            put(CalendarContract.Events.DTSTART, row.dtStartMillis)
-            put(CalendarContract.Events.RRULE, row.rrule)
-            put(CalendarContract.Events.DURATION, row.duration)
-            put(CalendarContract.Events.EVENT_TIMEZONE, row.timezone)
-            put(CalendarContract.Events.ALL_DAY, row.allDay)
-        }
-        try {
-            val rows = resolver.update(
-                ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, newEventId),
-                values, null, null,
-            )
-            if (rows == 0) {
-                throw WriteFailedException("carry exdate onto split series id=$newEventId")
-            }
-        } catch (t: Throwable) {
-            runCatching { deleteEvent(newEventId) }
-            throw t
-        }
-    }
-
     override fun deleteEventFromOccurrence(eventId: Long, beginMillis: Long) {
         val row = querySeriesRow(eventId)
         // From the first occurrence on = the whole series; also the fallback
@@ -1485,7 +1244,6 @@ class AndroidCalendarDataSource @Inject constructor(
             CalendarContract.Events.ALL_DAY,
             CalendarContract.Events._SYNC_ID,
             CalendarContract.Events.EXDATE,
-            CalendarContract.Events.RDATE,
         ),
         null, null, null,
     )?.use { c ->
@@ -1498,7 +1256,6 @@ class AndroidCalendarDataSource @Inject constructor(
                 allDay = c.getInt(4),
                 syncId = c.getString(5),
                 exdate = c.getString(6),
-                rdate = c.getString(7),
             )
         } else {
             null
@@ -1514,16 +1271,7 @@ class AndroidCalendarDataSource @Inject constructor(
         /** Null on a local calendar (and before a synced event's first push). */
         val syncId: String? = null,
         val exdate: String? = null,
-        val rdate: String? = null,
     ) {
-        /**
-         * Whether this row expands into more than itself. RDATE counts as much as
-         * RRULE: a sync adapter may list the occurrences instead of naming a rule,
-         * and the provider expands either — as does the read side, which marks
-         * such a row recurring too.
-         */
-        val recurs: Boolean get() = !rrule.isNullOrBlank() || !rdate.isNullOrBlank()
-
         /** UNTIL cutoff for ending the series before the occurrence at [beginMillis]. */
         fun truncationCutoff(beginMillis: Long): Long = previousLocalDayEndUtcMillis(
             beginMillis = beginMillis,
@@ -1714,12 +1462,6 @@ class AndroidCalendarDataSource @Inject constructor(
 
     override fun deleteOccurrence(eventId: Long, beginMillis: Long) {
         val row = querySeriesRow(eventId)
-        // Not a series, so the row *is* the event: an exclusion would put a
-        // recurrence set on a one-off, an exception would leave an orphan.
-        if (!row.recurs) {
-            deleteEvent(eventId)
-            return
-        }
         if (row.syncId == null) {
             // No _sync_id — a local calendar, or a synced event not pushed yet.
             // A cancelled exception can only attach to its parent through
@@ -1733,7 +1475,6 @@ class AndroidCalendarDataSource @Inject constructor(
                 occurrenceMillis = beginMillis,
                 dtStartMillis = row.dtStartMillis,
                 rrule = row.rrule,
-                rdate = row.rdate,
                 duration = row.duration,
                 timezone = row.timezone,
                 allDay = row.allDay,
@@ -1850,12 +1591,5 @@ class AndroidCalendarDataSource @Inject constructor(
          * next fires beyond it falls back to its series-start date.
          */
         const val OCCURRENCE_WINDOW_MILLIS = 2L * 365 * 24 * 60 * 60 * 1000
-
-        /**
-         * Tokens the SQL pre-filter is built from. Bounds the statement for a
-         * pasted paragraph; the ranker still requires every token, so a capped
-         * search returns fewer rows to check, never more hits.
-         */
-        const val MAX_SEARCH_TOKENS = 8
     }
 }

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

@@ -5,7 +5,6 @@ import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.domain.SearchCandidate
 import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
 import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
 import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
@@ -18,11 +17,11 @@ interface CalendarRepository {
     suspend fun eventDetail(eventId: Long): EventDetail
 
     /**
-     * Candidate matches for [query] with hidden calendars removed; empty when
-     * [query] is blank. Searches the whole history/future and leaves matching
-     * and ranking to [de.jeanlucmakiola.calendula.domain.EventSearch].
+     * Events whose title, description or location contains [query], with hidden
+     * calendars removed and newest first. Empty when [query] is blank. Searches
+     * the whole history/future (see [CalendarDataSource.searchEvents]).
      */
-    suspend fun searchEvents(query: String): List<SearchCandidate>
+    suspend fun searchEvents(query: String): List<EventInstance>
 
     /**
      * The event-colour palette a calendar's account publishes; empty when it
@@ -88,15 +87,9 @@ interface CalendarRepository {
 
     /**
      * Change a single occurrence of a recurring event (exception row with the
-     * form's values); returns the exception's `Events._ID`. [original] is what
-     * the row holds now, for the case where it turns out not to recur.
+     * form's values); returns the exception's `Events._ID`.
      */
-    suspend fun updateOccurrence(
-        eventId: Long,
-        beginMillis: Long,
-        original: EventForm,
-        form: EventForm,
-    ): Long
+    suspend fun updateOccurrence(eventId: Long, beginMillis: Long, form: EventForm): Long
 
     /**
      * Change a recurring event from [beginMillis] onwards (series split);

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

@@ -1,6 +1,5 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
-import android.util.Log
 import de.jeanlucmakiola.floret.time.toEpochMillis
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
@@ -10,7 +9,6 @@ import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventDetail
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.domain.SearchCandidate
 import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
 import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
 import kotlinx.coroutines.CoroutineDispatcher
@@ -27,7 +25,6 @@ import kotlinx.coroutines.flow.merge
 import kotlinx.coroutines.flow.onStart
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.withContext
 import java.util.concurrent.atomic.AtomicLong
 import kotlin.time.Instant
@@ -165,13 +162,13 @@ class CalendarRepositoryImpl @Inject constructor(
             ?: throw NoSuchEventException(eventId)
     }
 
-    override suspend fun searchEvents(query: String): List<SearchCandidate> = withContext(io) {
+    override suspend fun searchEvents(query: String): List<EventInstance> = withContext(io) {
         if (query.isBlank()) return@withContext emptyList()
         val excluded = prefs.hiddenCalendarIds.first() +
             prefs.pendingDisabledCalendarIds.first() +
             invisibleCalendarIds()
         dataSource.searchEvents(query)
-            .let { if (excluded.isEmpty()) it else it.filterNot { c -> c.event.calendarId in excluded } }
+            .let { if (excluded.isEmpty()) it else it.filterNot { e -> e.calendarId in excluded } }
     }
 
     override suspend fun eventColorPalette(calendarId: Long): List<EventColorOption> =
@@ -212,60 +209,26 @@ class CalendarRepositoryImpl @Inject constructor(
         }
 
     override suspend fun exportEvents(calendarIds: Set<Long>?) =
-        withContext(io) { dataSource.exportableEvents(calendarIds, allDayReminderTimeMinutes()) }
+        withContext(io) { dataSource.exportableEvents(calendarIds) }
 
     override suspend fun importEvents(
         targetCalendarId: Long,
         events: List<ParsedIcsEvent>,
     ): IcsImportSummary = withContext(io) {
         val existing = dataSource.existingUids(targetCalendarId)
-        // Both are per-calendar, not per-event: looking them up once keeps a
-        // thousand-event restore to two extra queries. The palette is the
-        // uncurated one — an imported colour is matched against every key the
-        // account accepts, not the subset the picker shows.
-        val palette = dataSource.publishedEventColors(targetCalendarId)
-        val allDayMinutes = allDayReminderTimeMinutes()
         var imported = 0
         var skipped = 0
-        var failed = 0
-        var notAttempted = 0
-        for ((index, event) in events.withIndex()) {
+        for (event in events) {
             // A known UID means the event is already in this calendar — skip,
             // keeping a restore idempotent (no overwrite this pass).
             if (event.uid != null && event.uid in existing) {
                 skipped++
-                continue
-            }
-            try {
-                dataSource.insertImportedEvent(event, targetCalendarId, allDayMinutes, palette)
+            } else {
+                dataSource.insertImportedEvent(event, targetCalendarId)
                 imported++
-            } catch (e: CancellationException) {
-                throw e
-            } catch (e: SecurityException) {
-                // Not this event's fault: the permission or the target calendar is
-                // gone, so every remaining insert would fail the same way.
-                Log.w(TAG, "Import stopped: the calendar is no longer writable", e)
-                // A known UID would have been skipped whatever happened, so it is
-                // no part of what a retry still has to import.
-                val remaining = events.drop(index)
-                val duplicates = remaining.count { it.uid?.let { uid -> uid in existing } == true }
-                skipped += duplicates
-                notAttempted = remaining.size - duplicates
-                break
-            } catch (e: Exception) {
-                // One event the provider won't take must not cost the user the
-                // rest of the file — foreign exports do carry rows it rejects
-                // outright (a malformed RRULE throws straight out of insert).
-                failed++
-                Log.w(TAG, "Skipped an unimportable event", e)
             }
         }
-        IcsImportSummary(
-            imported = imported,
-            skippedDuplicate = skipped,
-            failed = failed,
-            notAttempted = notAttempted,
-        )
+        IcsImportSummary(imported = imported, skippedDuplicate = skipped)
     }
 
     override suspend fun createEvent(form: EventForm): Long = withContext(io) {
@@ -298,12 +261,9 @@ class CalendarRepositoryImpl @Inject constructor(
     override suspend fun updateOccurrence(
         eventId: Long,
         beginMillis: Long,
-        original: EventForm,
         form: EventForm,
     ): Long = withContext(io) {
-        dataSource.updateOccurrence(
-            eventId, beginMillis, original, form, allDayReminderTimeMinutes(),
-        )
+        dataSource.updateOccurrence(eventId, beginMillis, form, allDayReminderTimeMinutes())
     }
 
     override suspend fun updateEventFromOccurrence(
@@ -327,10 +287,6 @@ class CalendarRepositoryImpl @Inject constructor(
     ) = withContext(io) {
         dataSource.deleteEventFromOccurrence(eventId, beginMillis)
     }
-
-    private companion object {
-        const val TAG = "CalendarRepository"
-    }
 }
 
 private fun <T> Flow<Unit>.reQuery(block: suspend () -> T): Flow<T> = flow {

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

@@ -3,23 +3,14 @@ package de.jeanlucmakiola.calendula.data.calendar
 import android.provider.CalendarContract
 import de.jeanlucmakiola.calendula.domain.AccessLevel
 import de.jeanlucmakiola.calendula.domain.Availability
-import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventForm
-import de.jeanlucmakiola.calendula.domain.EventStatus
-import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
-import de.jeanlucmakiola.calendula.domain.nearestTo
 import kotlinx.datetime.toJavaLocalDate
 import kotlinx.datetime.toJavaLocalDateTime
 import java.time.Duration
 import java.time.Instant
 import java.time.ZoneId
 import java.time.ZoneOffset
-import java.time.ZonedDateTime
-import java.time.format.DateTimeFormatter
-import java.time.format.ResolverStyle
-import java.time.LocalDate as JavaLocalDate
 import java.time.LocalDateTime as JavaLocalDateTime
-import java.time.LocalTime as JavaLocalTime
 
 /** Provider-ready DTSTART / DTEND / EVENT_TIMEZONE for an event write. */
 internal data class EventWriteTimes(
@@ -143,21 +134,18 @@ internal fun buildEventInsertValues(
  *
  * Time fields travel together (the provider validates them as a unit):
  * - unchanged times, all-day flag and rrule → no time columns at all;
- * - non-recurring result → DTSTART/DTEND, DURATION, RRULE and EXDATE cleared;
+ * - non-recurring result → DTSTART/DTEND, DURATION and RRULE cleared;
  * - recurring result → the *series* DTSTART moves by the same **wall-clock**
  *   shift the user applied to the displayed occurrence and is re-resolved in the
  *   event's zone ([seriesDtStartMillis] is the row's current DTSTART), DURATION
- *   replaces DTEND, RRULE is written, and the row's exclusions
- *   ([seriesExdate], the current EXDATE) travel with the anchor. This keeps past
- *   occurrences intact when someone edits a later occurrence's time, and keeps
- *   the anchor's time-of-day stable across a DST boundary or a zone change
- *   between the two.
+ *   replaces DTEND, RRULE is written. This keeps past occurrences intact when
+ *   someone edits a later occurrence's time, and keeps the anchor's time-of-day
+ *   stable across a DST boundary or a zone change between the two.
  */
 internal fun buildEventUpdateValues(
     original: EventForm,
     updated: EventForm,
     seriesDtStartMillis: Long,
-    seriesExdate: String?,
     zone: ZoneId,
 ): Map<String, Any?> = buildMap {
     if (updated.title.trim() != original.title.trim()) {
@@ -197,10 +185,6 @@ internal fun buildEventUpdateValues(
         put(CalendarContract.Events.DTEND, newTimes.dtEndMillis)
         put(CalendarContract.Events.RRULE, null)
         put(CalendarContract.Events.DURATION, null)
-        // The exclusions named occurrences of a series that no longer exists.
-        // Left behind they are dormant rather than harmless: adding a recurrence
-        // back later would punch the old holes into the new one.
-        put(CalendarContract.Events.EXDATE, null)
     } else {
         // Move the series anchor by the *wall-clock* shift the user applied to the
         // displayed occurrence, then re-resolve it in the event's (possibly new)
@@ -222,14 +206,6 @@ internal fun buildEventUpdateValues(
         put(CalendarContract.Events.DTEND, null)
         put(CalendarContract.Events.RRULE, updated.rrule)
         put(CalendarContract.Events.DURATION, newTimes.toRfc2445Duration(updated.isAllDay))
-        // An EXDATE stamp is an absolute instant, so it excludes an occurrence
-        // only while the series keeps generating one at exactly that instant. The
-        // anchor has just moved, so every occurrence regenerates elsewhere and a
-        // stamp left behind matches none of them — the occurrence the user deleted
-        // comes back. Move the stamps the same way the anchor moved.
-        shiftedExdate(seriesExdate, original, updated, zone)
-            ?.takeIf { it != seriesExdate }
-            ?.let { put(CalendarContract.Events.EXDATE, it) }
     }
 }
 
@@ -267,21 +243,6 @@ internal fun buildOccurrenceExceptionValues(
     putAll(eventColorColumns(form.colorKey, form.color))
 }
 
-/**
- * The form as a **detached occurrence**: the same edited values, with the
- * series rule dropped so [buildEventInsertValues] writes a standalone one-off
- * row (DTSTART + DTEND, no RRULE/DURATION) at the occurrence's own times.
- *
- * The "edit only this event" shape for a series with **no `_sync_id`**, where an
- * exception row can't attach to its parent at all (Codeberg #234).
- *
- * The exception path gets the rule dropped for free — the provider clears the
- * RRULE it cloned when an exception carries DTSTART + DURATION
- * ([buildOccurrenceExceptionValues]). Here nothing is cloned, so it is stripped
- * by hand; leaving it on would insert a second *series* overlapping the first.
- */
-internal fun EventForm.toDetachedOccurrence(): EventForm = copy(rrule = null)
-
 /**
  * Raw provider snapshot of a master/one-off Events row, enough to re-insert it
  * verbatim on another calendar (a calendar move is copy+delete — `CALENDAR_ID`
@@ -445,336 +406,52 @@ internal fun buildOccurrenceCancelValues(
  * first occurrence. Passing DTSTART + DURATION + RRULE + zone together is what
  * re-expands it correctly. All observed on a Pixel; see the #47 notes.
  *
- * [rdate] travels with [rrule]: a sync adapter may list a series' occurrences
- * instead of naming a rule, and rewriting the recurrence set without it would
- * leave the provider nothing but DTSTART to re-expand from — the collapse this
- * values map exists to avoid.
- *
  * EXDATE is a comma-separated list, so an existing one is appended to (a repeat
- * of the same occurrence is folded away — [mergedExdate]).
+ * of the same occurrence is folded away). All-day series take the `VALUE=DATE`
+ * form (`yyyyMMdd`), timed ones the UTC date-time form (`yyyyMMddTHHmmssZ`).
  */
 internal fun buildOccurrenceExdateValues(
     existingExdate: String?,
     occurrenceMillis: Long,
     dtStartMillis: Long,
     rrule: String?,
-    rdate: String?,
     duration: String?,
     timezone: String?,
     allDay: Int,
-): Map<String, Any?> = mapOf(
-    CalendarContract.Events.EXDATE to
-        mergedExdate(existingExdate, occurrenceMillis, allDay != 0, timezone),
-    CalendarContract.Events.DTSTART to dtStartMillis,
-    CalendarContract.Events.RRULE to rrule,
-    CalendarContract.Events.RDATE to rdate,
-    CalendarContract.Events.DURATION to duration,
-    CalendarContract.Events.EVENT_TIMEZONE to timezone,
-    CalendarContract.Events.ALL_DAY to allDay,
-)
-
-/**
- * [existingExdate] with the occurrence at [occurrenceMillis] excluded as well.
- *
- * Existing stamps are canonicalised first — all-day series take the `VALUE=DATE`
- * form (`yyyyMMdd`), timed ones the UTC date-time form (`yyyyMMddTHHmmssZ`) — so
- * appending to a list a sync adapter wrote in the other accepted form folds the
- * repeat away instead of leaving the same day excluded twice in two spellings.
- *
- * A stamp in no form Calendula reads makes the whole list untouchable: it is kept
- * exactly as it is, behind the parameter prefix that tells a reader how to
- * resolve it, and the new exclusion joins it in the list's own form.
- * Canonicalising the readable stamps around it would leave absolute stamps under
- * a prefix claiming a zone for all of them — which is how the unreadable one
- * quietly changes instant.
- */
-private fun mergedExdate(
-    existingExdate: String?,
-    occurrenceMillis: Long,
-    isAllDay: Boolean,
-    timezone: String?,
-): String {
-    val listZone = exdateListZone(existingExdate, timezone)
-    val stamps = exdateStamps(existingExdate)
-    val canonical = stamps.map { canonicalExdateStamp(it, isAllDay, listZone) }
-    if (canonical.all { it != null }) {
-        val stamp = formatExdateStamp(occurrenceMillis, isAllDay)
-        return (canonical.filterNotNull() + stamp).distinct().joinToString(",")
-    }
-    val prefix = existingExdate?.exdateParameterPrefix().orEmpty()
-    val stamp = if (isAllDay || prefix.isEmpty()) {
-        formatExdateStamp(occurrenceMillis, isAllDay)
-    } else {
-        Instant.ofEpochMilli(occurrenceMillis).atZone(listZone).format(FLOATING_EXDATE)
-    }
-    return prefix + (stamps + stamp).distinct().joinToString(",")
+): Map<String, Any?> {
+    val stamp = formatExdateStamp(occurrenceMillis, isAllDay = allDay != 0)
+    val existing = existingExdate?.split(',')
+        ?.map { it.trim() }
+        ?.filter { it.isNotEmpty() }
+        .orEmpty()
+    val merged = (existing + stamp).distinct().joinToString(",")
+    return mapOf(
+        CalendarContract.Events.EXDATE to merged,
+        CalendarContract.Events.DTSTART to dtStartMillis,
+        CalendarContract.Events.RRULE to rrule,
+        CalendarContract.Events.DURATION to duration,
+        CalendarContract.Events.EVENT_TIMEZONE to timezone,
+        CalendarContract.Events.ALL_DAY to allDay,
+    )
 }
 
-/**
- * Whether [existingExdate] already excludes the occurrence at [occurrenceMillis]
- * — i.e. it has already been dropped from the series, deleted or detached.
- *
- * Guards the detach path against running twice from a stale screen: the EXDATE
- * merge folds the repeat away silently and the update still reports one row
- * changed, so a second save would leave a second standalone copy.
- */
-internal fun exdateContains(
-    existingExdate: String?,
-    occurrenceMillis: Long,
-    isAllDay: Boolean,
-    timezone: String?,
-): Boolean {
-    val stamp = formatExdateStamp(occurrenceMillis, isAllDay)
-    val listZone = exdateListZone(existingExdate, timezone)
-    // Canonicalised rather than compared verbatim: a sync adapter may spell the
-    // same exclusion differently to Calendula, and a guard that misses it lets
-    // the detach run a second time and leave a second standalone copy.
-    return exdateStamps(existingExdate)
-        .any { canonicalExdateStamp(it, isAllDay, listZone) == stamp }
-}
-
-/**
- * [existingExdate] with every stamp re-timed by the same **wall-clock** shift the
- * series anchor takes from [original] to [updated] — the exclusions' half of the
- * anchor move [buildEventUpdateValues] performs, and what carries them onto the
- * new series when "this and following" splits one.
- *
- * A stamp is an absolute instant, so it keeps naming its occurrence only if it
- * moves exactly as the occurrence does: shifted in wall clock and re-resolved in
- * the event's (possibly new) zone. A millisecond delta would instead bake in the
- * offset that happened to apply at the edited occurrence — an hour off for any
- * exclusion on the far side of a DST boundary. All-day-ness is read from
- * [original] and written from [updated], so the `VALUE=DATE` and date-time forms
- * convert into each other when the event switches.
- *
- * A zoned list is read in the zone its prefix names ([exdateListZone]). Null
- * when there is nothing to carry: no stamps, or a stamp in a form Calendula
- * cannot read at all. Those are left exactly as they are rather than guessed at —
- * a stale stamp excludes nothing, but a mangled one could exclude the wrong
- * occurrence.
- */
-internal fun shiftedExdate(
-    existingExdate: String?,
-    original: EventForm,
-    updated: EventForm,
-    zone: ZoneId,
-): String? {
-    val stamps = exdateStamps(existingExdate)
-    if (stamps.isEmpty()) return null
-    val fromZone = original.writeZone(zone)
-    val toZone = updated.writeZone(zone)
-    val listZone = exdateListZone(existingExdate, fromZone.id)
-    val wallClockShift = Duration.between(original.anchorLocal(), updated.anchorLocal())
-    return stamps
-        .map { stamp ->
-            val local = parseExdateStamp(stamp, original.isAllDay, fromZone, listZone)
-                ?: return null
-            formatExdateStamp(local.plus(wallClockShift), updated.isAllDay, toZone)
-        }
-        .distinct()
-        .joinToString(",")
-}
-
-/**
- * The stamps of [existingExdate] naming occurrences after [beginMillis] — the ones
- * that belong to the *new* series once "this and following" splits a recurring
- * event there. The parent keeps the full list; its stamps past the split point are
- * simply inert once it stops generating those occurrences.
- *
- * The occurrence at [beginMillis] itself is never carried. It is the one the user
- * is editing, so it exists by definition, and honouring a stale exclusion for it
- * would swallow the edit whole.
- *
- * The stamps that qualify come back canonicalised, since the zone prefix that
- * told the reader how to resolve them does not survive the filter.
- *
- * Null when nothing qualifies, or when a stamp can't be read (see [shiftedExdate]).
- */
-internal fun exdateAfter(
-    existingExdate: String?,
-    beginMillis: Long,
-    isAllDay: Boolean,
-    timezone: String?,
-): String? {
-    val stamps = exdateStamps(existingExdate)
-    if (stamps.isEmpty()) return null
-    val listZone = exdateListZone(existingExdate, timezone)
-    return stamps
-        .mapNotNull { stamp ->
-            val utc = parseExdateStamp(stamp, isAllDay, ZoneOffset.UTC, listZone) ?: return null
-            utc.takeIf { it.toInstant(ZoneOffset.UTC).toEpochMilli() > beginMillis }
-        }
-        .map { formatExdateStamp(it, isAllDay, ZoneOffset.UTC) }
-        .takeIf { it.isNotEmpty() }
-        ?.joinToString(",")
-}
-
-/**
- * The individual stamps of an EXDATE column value; it is a comma-separated list,
- * optionally behind the parameter prefix AOSP's `RecurrenceSet` puts in front of
- * a zoned one ([exdateListZone] reads that half).
- */
-private fun exdateStamps(exdate: String?): List<String> = exdate
-    ?.withoutExdateParameters()
-    ?.split(',')
-    ?.map { it.trim() }
-    ?.filter { it.isNotEmpty() }
-    .orEmpty()
-
-/**
- * An EXDATE column value with the parameter section its stamps sit behind taken
- * off.
- */
-internal fun String.withoutExdateParameters(): String = substring(exdateParameterPrefix().length)
-
-/**
- * The parameter section an EXDATE list's stamps sit behind, its `;` included, or
- * empty when it has none. Only a `;` before the first stamp separator is one —
- * anything later belongs to a stamp, and cutting there would drop every stamp in
- * front of it.
- */
-private fun String.exdateParameterPrefix(): String {
-    val semicolon = indexOf(';')
-    val comma = indexOf(',')
-    return if (semicolon >= 0 && (comma < 0 || semicolon < comma)) {
-        substring(0, semicolon + 1)
-    } else {
-        ""
-    }
-}
-
-/**
- * The zone the floating stamps of [exdate] are wall clock in: the one its
- * parameter prefix names, or [fallback] — the event's own `EVENT_TIMEZONE` —
- * when there is no prefix, or the device's tz database doesn't know the name it
- * uses (Exchange spells zones its own way). The series' own zone is the right
- * guess, since a zoned exclusion list is written in it. UTC last, for a row that
- * carries no zone either. Stamps already written as UTC instants ignore all this.
- *
- * Both spellings of the prefix are read. AOSP's `RecurrenceSet` stores the TZID
- * parameter's *value* alone (`Europe/Berlin;<stamps>`), and so does DAVx5; the
- * iCalendar `TZID=<zone>;` some writers keep is the other one. Only matching the
- * second would miss every list the provider itself wrote.
- */
-internal fun exdateListZone(exdate: String?, fallback: String?): ZoneId =
-    exdate?.exdateZoneName()?.toZoneIdOrNull()
-        ?: fallback?.toZoneIdOrNull()
-        ?: ZoneOffset.UTC
-
-/** The zone id an EXDATE list's parameter prefix names, with or without `TZID=`. */
-private fun String.exdateZoneName(): String {
-    val prefix = exdateParameterPrefix().dropLast(1)
-    return if (prefix.startsWith(TZID_PREFIX, ignoreCase = true)) {
-        prefix.drop(TZID_PREFIX.length)
-    } else {
-        prefix
-    }
-}
-
-private fun String.toZoneIdOrNull(): ZoneId? = runCatching { ZoneId.of(this) }.getOrNull()
-
-/** The optional `TZID=` a zoned EXDATE list's zone id may sit behind. */
-private const val TZID_PREFIX = "TZID="
-
 /**
  * One EXDATE entry for the occurrence starting at [occurrenceMillis]. Both forms
  * are UTC: the provider stores an all-day DTSTART at UTC midnight, so its date
  * reads off the UTC calendar day.
  */
-private fun formatExdateStamp(occurrenceMillis: Long, isAllDay: Boolean): String =
-    formatExdateStamp(
-        local = Instant.ofEpochMilli(occurrenceMillis).atZone(ZoneOffset.UTC).toLocalDateTime(),
-        isAllDay = isAllDay,
-        zone = ZoneOffset.UTC,
-    )
-
-/**
- * One EXDATE entry for the occurrence whose wall clock in [zone] is [local]. An
- * all-day entry keeps only the date (its time-of-day is the anchor's, not the
- * occurrence's); a timed one is resolved in [zone] and written as a UTC instant.
- */
-private fun formatExdateStamp(local: JavaLocalDateTime, isAllDay: Boolean, zone: ZoneId): String =
-    if (isAllDay) {
-        local.toLocalDate().format(ALL_DAY_EXDATE)
+private fun formatExdateStamp(occurrenceMillis: Long, isAllDay: Boolean): String {
+    val utc = Instant.ofEpochMilli(occurrenceMillis).atZone(ZoneOffset.UTC)
+    return if (isAllDay) {
+        "%04d%02d%02d".format(utc.year, utc.monthValue, utc.dayOfMonth)
     } else {
-        local.atZone(zone).withZoneSameInstant(ZoneOffset.UTC).format(TIMED_EXDATE)
+        "%04d%02d%02dT%02d%02d%02dZ".format(
+            utc.year, utc.monthValue, utc.dayOfMonth,
+            utc.hour, utc.minute, utc.second,
+        )
     }
-
-/**
- * [stamp] as the wall clock it names in [zone] — the inverse of
- * [formatExdateStamp]. Null for anything Calendula cannot read, so a caller can
- * tell "not ours, leave it alone" from a value it may safely re-time.
- *
- * A timed exclusion is read both as the UTC instant Calendula writes and as a
- * floating stamp, which [listZone] then resolves. An all-day one is read both
- * bare (`yyyyMMdd`, what Calendula writes) and padded to a midnight stamp, in
- * either spelling: sync adapters are inconsistent about which they store — the
- * same forms [exportExDates] reshapes on the way out — and refusing one would
- * drop every exclusion of a foreign all-day series the moment it is re-timed.
- */
-private fun parseExdateStamp(
-    stamp: String,
-    isAllDay: Boolean,
-    zone: ZoneId,
-    listZone: ZoneId,
-): JavaLocalDateTime? =
-    if (isAllDay) {
-        parseAllDayExdate(stamp)?.atStartOfDay()
-    } else {
-        parseTimedExdate(stamp, listZone)?.withZoneSameInstant(zone)?.toLocalDateTime()
-    }
-
-/**
- * A timed EXDATE stamp as the instant it names: the trailing `Z` form resolved in
- * UTC, or the floating one resolved in [listZone].
- */
-private fun parseTimedExdate(stamp: String, listZone: ZoneId): ZonedDateTime? =
-    runCatching { JavaLocalDateTime.parse(stamp, TIMED_EXDATE).atZone(ZoneOffset.UTC) }.getOrNull()
-        ?: runCatching {
-            JavaLocalDateTime.parse(stamp, FLOATING_EXDATE).atZone(listZone)
-        }.getOrNull()
-
-/**
- * The calendar day an all-day EXDATE stamp names, bare or padded to a midnight
- * stamp. A padded stamp naming any other time of day is refused rather than
- * rounded: it is not a form an all-day series is written in, so it could be
- * naming something else entirely. Midnight is midnight in any zone, so the
- * padding's own spelling — trailing `Z` or floating — makes no difference.
- */
-private fun parseAllDayExdate(stamp: String): JavaLocalDate? {
-    runCatching { JavaLocalDate.parse(stamp, ALL_DAY_EXDATE) }.getOrNull()?.let { return it }
-    val padded = parsePaddedExdate(stamp) ?: return null
-    return padded.toLocalDate().takeIf { padded.toLocalTime() == JavaLocalTime.MIDNIGHT }
 }
 
-/** An `uuuuMMddTHHmmss` stamp, with or without the trailing `Z`, as its own wall clock. */
-private fun parsePaddedExdate(stamp: String): JavaLocalDateTime? =
-    runCatching { JavaLocalDateTime.parse(stamp, TIMED_EXDATE) }.getOrNull()
-        ?: runCatching { JavaLocalDateTime.parse(stamp, FLOATING_EXDATE) }.getOrNull()
-
-/**
- * [stamp] in the form Calendula writes, so two spellings of the same exclusion
- * compare equal. Null for a stamp in no form it reads.
- */
-internal fun canonicalExdateStamp(
-    stamp: String,
-    isAllDay: Boolean,
-    listZone: ZoneId,
-): String? = parseExdateStamp(stamp, isAllDay, ZoneOffset.UTC, listZone)
-    ?.let { formatExdateStamp(it, isAllDay, ZoneOffset.UTC) }
-
-/** `VALUE=DATE` EXDATE form, for an all-day series. */
-private val ALL_DAY_EXDATE: DateTimeFormatter =
-    DateTimeFormatter.ofPattern("uuuuMMdd").withResolverStyle(ResolverStyle.STRICT)
-
-/** UTC date-time EXDATE form, for a timed series. */
-private val TIMED_EXDATE: DateTimeFormatter =
-    DateTimeFormatter.ofPattern("uuuuMMdd'T'HHmmss'Z'").withResolverStyle(ResolverStyle.STRICT)
-
-/** The same form without the `Z`, wall clock in the list's zone rather than UTC. */
-private val FLOATING_EXDATE: DateTimeFormatter =
-    DateTimeFormatter.ofPattern("uuuuMMdd'T'HHmmss").withResolverStyle(ResolverStyle.STRICT)
-
 /**
  * The `EVENT_COLOR` / `EVENT_COLOR_KEY` columns for a colour selection. A
  * [colorKey] writes the key alone (the provider derives `EVENT_COLOR` from the
@@ -822,73 +499,3 @@ internal fun AccessLevel.toProviderValue(): Int = when (this) {
     AccessLevel.Private -> CalendarContract.Events.ACCESS_PRIVATE
     AccessLevel.Public -> CalendarContract.Events.ACCESS_PUBLIC
 }
-
-/**
- * The `Events` row for a `.ics` event being imported into [calendarId].
- *
- * A recurring row carries RRULE + DURATION (and any EXDATE) with no DTEND; a
- * one-off carries DTEND. All-day rows live at UTC midnights, exactly as the
- * parser hands them over.
- *
- * [palette] is the target account's published event colours. A calendar that
- * publishes one rejects a raw `EVENT_COLOR`, so an imported colour — which is
- * an arbitrary ARGB from a foreign app — is snapped to the nearest key it does
- * accept; accounts with no palette take the raw value (see [eventColorColumns]).
- */
-internal fun buildImportedEventValues(
-    event: ParsedIcsEvent,
-    calendarId: Long,
-    uid: String,
-    palette: List<EventColorOption>,
-): Map<String, Any?> = buildMap {
-    val startMillis = event.start.toEpochMilliseconds()
-    val endMillis = event.end.toEpochMilliseconds()
-    put(CalendarContract.Events.CALENDAR_ID, calendarId)
-    put(CalendarContract.Events.UID_2445, uid)
-    put(CalendarContract.Events.TITLE, event.summary.trim())
-    put(CalendarContract.Events.ALL_DAY, if (event.isAllDay) 1 else 0)
-    put(CalendarContract.Events.DTSTART, startMillis)
-    if (event.recurrenceRule == null) {
-        put(CalendarContract.Events.DTEND, endMillis)
-    } else {
-        put(CalendarContract.Events.RRULE, event.recurrenceRule)
-        put(
-            CalendarContract.Events.DURATION,
-            importDuration(startMillis, endMillis, event.isAllDay),
-        )
-        event.exDates.takeIf { it.isNotEmpty() }
-            ?.let { put(CalendarContract.Events.EXDATE, it.joinToString(",")) }
-    }
-    // All-day rows live at UTC midnights (the file already encodes them so);
-    // timed rows keep the event's own zone.
-    put(CalendarContract.Events.EVENT_TIMEZONE, if (event.isAllDay) "UTC" else event.zoneId)
-    put(CalendarContract.Events.AVAILABILITY, event.availability.toProviderValue())
-    put(CalendarContract.Events.STATUS, event.status.toProviderStatus())
-    event.location?.trim()?.takeIf { it.isNotEmpty() }
-        ?.let { put(CalendarContract.Events.EVENT_LOCATION, it) }
-    event.description?.trim()?.takeIf { it.isNotEmpty() }
-        ?.let { put(CalendarContract.Events.DESCRIPTION, it) }
-    event.color?.let { color ->
-        val key = palette.nearestTo(color)?.key
-        putAll(eventColorColumns(colorKey = key, color = if (key == null) color else null))
-    }
-}
-
-/**
- * Provider `DURATION` for an imported recurring row: whole days for an all-day
- * series, seconds otherwise. An all-day series is never shorter than a day —
- * the provider expands a zero-length one into no instances at all, so the
- * series would vanish (which is what a literal read of the Fossify family's
- * inclusive DTEND used to produce; see "Importing foreign .ics" in
- * docs/ARCHITECTURE.md).
- */
-private fun importDuration(startMillis: Long, endMillis: Long, isAllDay: Boolean): String {
-    val span = (endMillis - startMillis).coerceAtLeast(0)
-    return if (isAllDay) "P${(span / 86_400_000L).coerceAtLeast(1)}D" else "P${span / 1_000L}S"
-}
-
-private fun EventStatus.toProviderStatus(): Int = when (this) {
-    EventStatus.Confirmed -> CalendarContract.Events.STATUS_CONFIRMED
-    EventStatus.Tentative -> CalendarContract.Events.STATUS_TENTATIVE
-    EventStatus.Cancelled -> CalendarContract.Events.STATUS_CANCELED
-}

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

@@ -5,9 +5,6 @@ import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
 import de.jeanlucmakiola.calendula.domain.ics.deriveIcsUid
 import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
-import java.time.Instant
-import java.time.ZoneId
-import java.time.ZoneOffset
 
 /**
  * Map one Events row (read through [EventExportProjection]) into an [IcsEvent]
@@ -15,23 +12,14 @@ import java.time.ZoneOffset
  * [calendarName] the display name of its calendar (emitted as
  * `X-CALENDULA-CALENDAR`). Pure given a [ColumnReader] — JVM-tested with
  * MapColumnReader.
- *
- * An all-day row's raw offset has the firing time of day encoded into it and is
- * normally *negative* (see [AllDayReminderEncoding]); written out literally it
- * would be dropped as a trigger that fires after the event, losing the reminder.
- * [allDayReminderTimeMinutes] and [zone] decode it back to the whole-day lead
- * time the file should carry, which an import re-encodes for its own device.
  */
 internal fun ColumnReader.toIcsEvent(
     reminderMinutes: List<Int>,
     calendarName: String?,
-    allDayReminderTimeMinutes: Int,
-    zone: ZoneId = ZoneId.systemDefault(),
 ): IcsEvent {
     val eventId = getLong(EventExportProjection.IDX_ID)
     val dtStart = getLong(EventExportProjection.IDX_DTSTART)
     val rrule = getString(EventExportProjection.IDX_RRULE)?.takeIf { it.isNotBlank() }
-    val isAllDay = getInt(EventExportProjection.IDX_ALL_DAY) != 0
 
     // Recurring rows store DURATION instead of DTEND; reconstruct the end from it
     // so the writer can render DTEND. A missing/blank both means a zero-length event.
@@ -52,77 +40,16 @@ internal fun ColumnReader.toIcsEvent(
         summary = getString(EventExportProjection.IDX_TITLE).orEmpty(),
         start = dtStart.toKotlinInstantFromEpochMillis(),
         end = end.toKotlinInstantFromEpochMillis(),
-        isAllDay = isAllDay,
+        isAllDay = getInt(EventExportProjection.IDX_ALL_DAY) != 0,
         zoneId = getString(EventExportProjection.IDX_EVENT_TIMEZONE)?.takeIf { it.isNotBlank() }
             ?: "UTC",
         recurrenceRule = rrule,
-        exDates = if (rrule == null) {
-            emptyList()
-        } else {
-            exportExDates(
-                getString(EventExportProjection.IDX_EXDATE),
-                isAllDay,
-                getString(EventExportProjection.IDX_EVENT_TIMEZONE),
-            )
-        },
         location = getString(EventExportProjection.IDX_LOCATION),
         description = getString(EventExportProjection.IDX_DESCRIPTION),
-        reminderMinutes = if (isAllDay) {
-            val startDate = Instant.ofEpochMilli(dtStart).atZone(ZoneOffset.UTC).toLocalDate()
-            reminderMinutes.map {
-                fromProviderAllDayMinutes(it, startDate, zone, allDayReminderTimeMinutes)
-            }
-        } else {
-            reminderMinutes
-        },
+        reminderMinutes = reminderMinutes,
         status = status,
         availability = mapAvailability(getInt(EventExportProjection.IDX_AVAILABILITY)),
         calendarName = calendarName,
     )
 }
 
-/**
- * The row's `EXDATE` as the writer wants it: one stamp per entry, empties
- * dropped.
- *
- * An all-day exclusion names a calendar day, and sync adapters are inconsistent
- * about whether they write it as a bare `yyyyMMdd` or pad it to a midnight
- * stamp; the time part is dropped so the exported value is the day either way.
- * Calendula's own writes ([buildOccurrenceExdateValues]) are already bare.
- *
- * A zoned exclusion arrives in AOSP's `RecurrenceSet` form, `<zone>;<stamps>`,
- * where the prefix names the zone the whole list is wall clock in. [IcsWriter]
- * emits one bare `EXDATE:` line, and a parameter belongs before that colon, not
- * inside the value — passed on as-is it would make the line unparseable. The
- * prefix is therefore taken off and its stamps resolved to UTC instants
- * ([canonicalExdateStamp], the same reading the write path does), the form every
- * reader accepts.
- *
- * Which zone that resolution uses is [exdateListZone]'s call, the same one the
- * write path makes: the `TZID=` when this device's tz database knows the name,
- * else the row's own [eventTimezone]. A stamp is never emitted floating just
- * because the prefix named a zone we couldn't place — against a `DTSTART;TZID=…`
- * line every reader would resolve it in its own zone and the exclusion would stop
- * matching its occurrence.
- */
-internal fun exportExDates(
-    exdate: String?,
-    isAllDay: Boolean,
-    eventTimezone: String? = null,
-): List<String> {
-    if (exdate.isNullOrBlank()) return emptyList()
-    val zone = exdateListZone(exdate, eventTimezone)
-    return exdate
-        .withoutExdateParameters()
-        .split(',')
-        .map { it.trim() }
-        .filter { it.isNotEmpty() }
-        .map { stamp ->
-            if (isAllDay) {
-                stamp.substringBefore('T')
-            } else {
-                canonicalExdateStamp(stamp, isAllDay = false, listZone = zone) ?: stamp
-            }
-        }
-        .distinct()
-}

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

@@ -1,10 +1,8 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
 import de.jeanlucmakiola.floret.time.toKotlinInstantFromEpochMillis
-import android.provider.CalendarContract
 import android.util.Log
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.domain.EventResponse
 
 private const val TAG = "InstanceMapper"
 
@@ -40,17 +38,5 @@ internal fun ColumnReader.toEventInstance(): EventInstance? {
         isAllDay = getInt(InstanceProjection.IDX_ALL_DAY) != 0,
         color = color,
         location = getString(InstanceProjection.IDX_LOCATION),
-        response = mapEventResponse(getInt(InstanceProjection.IDX_SELF_ATTENDEE_STATUS)),
     )
 }
-
-/**
- * `SELF_ATTENDEE_STATUS` as the calendar surfaces read it: a tentative "maybe"
- * counts as going, and everything that is not an open or refused invitation —
- * your own events included — falls through to [EventResponse.Going].
- */
-internal fun mapEventResponse(raw: Int): EventResponse = when (raw) {
-    CalendarContract.Attendees.ATTENDEE_STATUS_DECLINED -> EventResponse.Declined
-    CalendarContract.Attendees.ATTENDEE_STATUS_INVITED -> EventResponse.Invited
-    else -> EventResponse.Going
-}

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

@@ -52,7 +52,6 @@ internal object InstanceProjection {
         CalendarContract.Instances.EVENT_COLOR,
         CalendarContract.Instances.CALENDAR_COLOR,
         CalendarContract.Instances.EVENT_LOCATION,
-        CalendarContract.Instances.SELF_ATTENDEE_STATUS,
     )
 
     const val IDX_INSTANCE_ID = 0
@@ -65,7 +64,6 @@ internal object InstanceProjection {
     const val IDX_EVENT_COLOR = 7
     const val IDX_CALENDAR_COLOR = 8
     const val IDX_LOCATION = 9
-    const val IDX_SELF_ATTENDEE_STATUS = 10
 }
 
 internal object EventDetailProjection {
@@ -121,12 +119,10 @@ internal object EventDetailProjection {
 /**
  * Master/one-off Events rows for a whole-calendar backup. Unlike
  * [EventDetailProjection] this reads `UID_2445` (to keep a row's identity across
- * backups) and `DURATION` (recurring rows carry it instead of DTEND), plus
- * `EXDATE` so a series exports the occurrences deleted from it. Modified-
+ * backups) and `DURATION` (recurring rows carry it instead of DTEND). Modified-
  * occurrence and cancelled-exception rows are filtered out by the query
- * (`ORIGINAL_ID IS NULL`), so RECURRENCE-ID overrides aren't exported — a
- * documented v1 limit (import skips them too). EXDATE is unaffected by that
- * filter: it lives on the master row, not on an exception of its own.
+ * (`ORIGINAL_ID IS NULL`), so RECURRENCE-ID overrides and EXDATEs aren't
+ * exported yet — a documented v1 limit (import skips them too).
  */
 internal object EventExportProjection {
     val COLUMNS: Array<String> = arrayOf(
@@ -139,7 +135,6 @@ internal object EventExportProjection {
         CalendarContract.Events.ALL_DAY,
         CalendarContract.Events.EVENT_TIMEZONE,
         CalendarContract.Events.RRULE,
-        CalendarContract.Events.EXDATE,
         CalendarContract.Events.EVENT_LOCATION,
         CalendarContract.Events.DESCRIPTION,
         CalendarContract.Events.STATUS,
@@ -156,12 +151,11 @@ internal object EventExportProjection {
     const val IDX_ALL_DAY = 6
     const val IDX_EVENT_TIMEZONE = 7
     const val IDX_RRULE = 8
-    const val IDX_EXDATE = 9
-    const val IDX_LOCATION = 10
-    const val IDX_DESCRIPTION = 11
-    const val IDX_STATUS = 12
-    const val IDX_AVAILABILITY = 13
-    const val IDX_CALENDAR_ID = 14
+    const val IDX_LOCATION = 9
+    const val IDX_DESCRIPTION = 10
+    const val IDX_STATUS = 11
+    const val IDX_AVAILABILITY = 12
+    const val IDX_CALENDAR_ID = 13
 }
 
 /**
@@ -186,9 +180,6 @@ internal object SearchProjection {
         // display its nearest occurrence, not the series-start DTSTART.
         CalendarContract.Events.RRULE,
         CalendarContract.Events.RDATE,
-        // Excerpted, not just filtered on: a hit has to show what it matched.
-        CalendarContract.Events.DESCRIPTION,
-        CalendarContract.Events.SELF_ATTENDEE_STATUS,
     )
 
     const val IDX_ID = 0
@@ -203,8 +194,6 @@ internal object SearchProjection {
     const val IDX_LOCATION = 9
     const val IDX_RRULE = 10
     const val IDX_RDATE = 11
-    const val IDX_DESCRIPTION = 12
-    const val IDX_SELF_ATTENDEE_STATUS = 13
 }
 
 /**

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

@@ -1,24 +0,0 @@
-package de.jeanlucmakiola.calendula.data.calendar
-
-import android.provider.CalendarContract
-
-/**
- * "Fire at whatever lead time this account defaults to" — a sentinel in the
- * `Reminders.MINUTES` column, not an offset, so nothing may do arithmetic on it.
- * `CalendarContract` never exposes what an account resolves it to, so Calendula
- * neither fires such a row ([withoutProviderDefaults]) nor decodes it
- * ([fromProviderAllDayMinutes]); the detail screen names it instead.
- *
- * It is the **only** negative that means this. A real all-day offset is often
- * negative too — the firing time of day is encoded into it — so a `< 0` test
- * would silence reminders that do fire.
- */
-internal const val MINUTES_DEFAULT = CalendarContract.Reminders.MINUTES_DEFAULT
-
-/**
- * Raw provider offsets with the account-default rows dropped, so the pure
- * planner ([de.jeanlucmakiola.calendula.domain.reminders.planReminders]) only
- * ever sees offsets it can resolve.
- */
-internal fun Map<Long, List<Int>>.withoutProviderDefaults(): Map<Long, List<Int>> =
-    mapValues { (_, minutes) -> minutes.filter { it != MINUTES_DEFAULT } }

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

@@ -42,6 +42,5 @@ internal fun ColumnReader.toSearchResult(): EventInstance? {
         location = getString(SearchProjection.IDX_LOCATION),
         isRecurring = !getString(SearchProjection.IDX_RRULE).isNullOrEmpty() ||
             !getString(SearchProjection.IDX_RDATE).isNullOrEmpty(),
-        response = mapEventResponse(getInt(SearchProjection.IDX_SELF_ATTENDEE_STATUS)),
     )
 }

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

@@ -301,19 +301,6 @@ class SettingsPrefs @Inject constructor(
         store.edit { it[TODAY_BUTTON_IN_TOOLBAR_KEY] = enabled }
     }
 
-    /**
-     * Whether events can be dragged to another slot in the calendar views (#68,
-     * #173). Defaults to ON. Off means no block registers a drag gesture at all;
-     * rescheduling then goes through the edit form.
-     */
-    val dragToReschedule: Flow<Boolean> = store.data.map { prefs ->
-        prefs[DRAG_TO_RESCHEDULE_KEY] ?: true
-    }
-
-    suspend fun setDragToReschedule(enabled: Boolean) {
-        store.edit { it[DRAG_TO_RESCHEDULE_KEY] = enabled }
-    }
-
     /**
      * How far ahead the in-app Agenda screen shows events (v2.11). Defaults to
      * [AgendaRange.Month] — a month of upcoming events. Independent of the
@@ -563,87 +550,8 @@ class SettingsPrefs @Inject constructor(
         prefs[REMINDER_ONBOARDING_KEY] ?: false
     }
 
-    /** Cleared, not just set: the wizard's back button re-asks a step (#163). */
-    suspend fun setReminderOnboardingDone(done: Boolean = true) {
-        store.edit { it[REMINDER_ONBOARDING_KEY] = done }
-    }
-
-    /**
-     * Whether this install is a fresh one still owing the wizard's optional
-     * steps (#163). Armed on any launch that holds the calendar permission and
-     * has not finished the reminder step, and cleared again by
-     * [finishOnboardingWizard], so an existing user who revokes and re-grants
-     * the permission isn't re-onboarded.
-     */
-    val onboardingWizardArmed: Flow<Boolean> = store.data.map { prefs ->
-        prefs[ONBOARDING_WIZARD_ARMED_KEY] ?: false
-    }
-
-    suspend fun armOnboardingWizard() {
-        store.edit { prefs ->
-            if (prefs[REMINDER_ONBOARDING_KEY] != true) prefs[ONBOARDING_WIZARD_ARMED_KEY] = true
-        }
-    }
-
-    /** Whether the wizard's backup step has been answered (or skipped). */
-    val onboardingBackupDone: Flow<Boolean> = store.data.map { prefs ->
-        prefs[ONBOARDING_BACKUP_KEY] ?: false
-    }
-
-    suspend fun setOnboardingBackupDone(done: Boolean = true) {
-        store.edit { it[ONBOARDING_BACKUP_KEY] = done }
-    }
-
-    /** Whether the wizard's default-view step has been answered (or skipped). */
-    val onboardingViewDone: Flow<Boolean> = store.data.map { prefs ->
-        prefs[ONBOARDING_VIEW_KEY] ?: false
-    }
-
-    suspend fun setOnboardingViewDone(done: Boolean = true) {
-        store.edit { it[ONBOARDING_VIEW_KEY] = done }
-    }
-
-    /** Whether the wizard's month-style step has been answered (or skipped). */
-    val onboardingMonthStyleDone: Flow<Boolean> = store.data.map { prefs ->
-        prefs[ONBOARDING_MONTH_STYLE_KEY] ?: false
-    }
-
-    suspend fun setOnboardingMonthStyleDone(done: Boolean = true) {
-        store.edit { it[ONBOARDING_MONTH_STYLE_KEY] = done }
-    }
-
-    /**
-     * Whether the wizard's calendar-visibility notice has been read. Separate
-     * from [CalendarPrefs.visibilityNoticePending], which says whether this
-     * install has anything to announce at all.
-     */
-    val onboardingVisibilityDone: Flow<Boolean> = store.data.map { prefs ->
-        prefs[ONBOARDING_VISIBILITY_KEY] ?: false
-    }
-
-    suspend fun setOnboardingVisibilityDone(done: Boolean = true) {
-        store.edit { it[ONBOARDING_VISIBILITY_KEY] = done }
-    }
-
-    /** Whether the wizard's closing screen has been seen. */
-    val onboardingDoneShown: Flow<Boolean> = store.data.map { prefs ->
-        prefs[ONBOARDING_DONE_KEY] ?: false
-    }
-
-    suspend fun setOnboardingDoneShown(shown: Boolean = true) {
-        store.edit { it[ONBOARDING_DONE_KEY] = shown }
-    }
-
-    /**
-     * Close the wizard for good: the closing screen has been seen and the
-     * install stops counting as fresh, so a later revoke-and-re-grant is only
-     * the permission screen. One edit, so the plan can't see it half-closed.
-     */
-    suspend fun finishOnboardingWizard() {
-        store.edit { prefs ->
-            prefs[ONBOARDING_DONE_KEY] = true
-            prefs[ONBOARDING_WIZARD_ARMED_KEY] = false
-        }
+    suspend fun setReminderOnboardingDone() {
+        store.edit { it[REMINDER_ONBOARDING_KEY] = true }
     }
 
     /**
@@ -958,7 +866,6 @@ class SettingsPrefs @Inject constructor(
         internal val MONTH_VIEW_STYLE_KEY = stringPreferencesKey("month_view_style")
         internal val TIMELINE_SCALE_KEY = stringPreferencesKey("timeline_scale")
         internal val TODAY_BUTTON_IN_TOOLBAR_KEY = booleanPreferencesKey("today_button_in_toolbar")
-        internal val DRAG_TO_RESCHEDULE_KEY = booleanPreferencesKey("drag_to_reschedule")
         internal val DEFAULT_VIEW_KEY = stringPreferencesKey("default_view")
         internal val QUICK_SWITCH_VIEWS_KEY = stringPreferencesKey("quick_switch_views")
         internal val DRAWER_VIEW_ORDER_KEY = stringPreferencesKey("drawer_view_order")
@@ -975,14 +882,6 @@ class SettingsPrefs @Inject constructor(
         internal const val MAX_EVENT_DURATION = 1_440
         internal val REMINDERS_ENABLED_KEY = booleanPreferencesKey("reminders_enabled")
         internal val REMINDER_ONBOARDING_KEY = booleanPreferencesKey("reminder_onboarding_done")
-        internal val ONBOARDING_WIZARD_ARMED_KEY = booleanPreferencesKey("onboarding_wizard_armed")
-        internal val ONBOARDING_BACKUP_KEY = booleanPreferencesKey("onboarding_backup_done")
-        internal val ONBOARDING_VIEW_KEY = booleanPreferencesKey("onboarding_view_done")
-        internal val ONBOARDING_MONTH_STYLE_KEY =
-            booleanPreferencesKey("onboarding_month_style_done")
-        internal val ONBOARDING_VISIBILITY_KEY =
-            booleanPreferencesKey("onboarding_visibility_done")
-        internal val ONBOARDING_DONE_KEY = booleanPreferencesKey("onboarding_done_shown")
         internal val ALLOW_COLOR_UNSUPPORTED_KEY =
             booleanPreferencesKey("allow_color_unsupported_calendars")
         internal val DEFAULT_REMINDER_KEY = stringPreferencesKey("default_reminder_minutes")

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

@@ -44,16 +44,9 @@ class ProviderReminderInstanceSource @Inject constructor(
         // `visible` is the flag the app's one visibility model writes (#75).
         // The status clause mirrors CalendarDataSource.instances: NULL means
         // "normal", so a bare `!= CANCELED` would drop every ordinary event.
-        // An invitation the user declined is answered — it stays on the calendar
-        // struck through, but it plans nothing (#180). NULL again means "no
-        // answer recorded", which is not a "no".
         val selection = "${CalendarContract.Calendars.VISIBLE} = 1 AND " +
             "(${CalendarContract.Instances.STATUS} IS NULL OR " +
-            "${CalendarContract.Instances.STATUS} != " +
-            "${CalendarContract.Events.STATUS_CANCELED}) AND " +
-            "(${CalendarContract.Instances.SELF_ATTENDEE_STATUS} IS NULL OR " +
-            "${CalendarContract.Instances.SELF_ATTENDEE_STATUS} != " +
-            "${CalendarContract.Attendees.ATTENDEE_STATUS_DECLINED})"
+            "${CalendarContract.Instances.STATUS} != ${CalendarContract.Events.STATUS_CANCELED})"
         return context.contentResolver.query(
             uri, OCCURRENCE_PROJECTION, selection, null, null,
         )?.use { c ->

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

@@ -7,7 +7,6 @@ import android.util.Log
 import androidx.core.content.ContextCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.data.calendar.CalendarDataSource
-import de.jeanlucmakiola.calendula.data.calendar.withoutProviderDefaults
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.ReminderStatePrefs
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
@@ -91,8 +90,7 @@ class ReminderScanner @Inject constructor(
         val occurrences = source.occurrences(now - PAST_WINDOW_MILLIS, now + lookahead)
         val planned = planReminders(
             instances = occurrences,
-            minutesByEvent = source.reminderMinutes(occurrences.map { it.eventId })
-                .withoutProviderDefaults(),
+            minutesByEvent = source.reminderMinutes(occurrences.map { it.eventId }),
             zone = ZoneId.systemDefault(),
             allDayTimeMinutes = settingsPrefs.allDayReminderTimeMinutes.first(),
         )

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

@@ -110,17 +110,3 @@ private const val CURATION_TRIGGER_SIZE = 36
  * apart that two swatches never read as the same colour in the grid.
  */
 private const val MIN_DISTANCE = 0.025f
-
-/**
- * The palette entry closest to [argb], or null when the account publishes no
- * palette (its calendars then take a raw `EVENT_COLOR` instead).
- *
- * Used to land a colour that came from outside the account — an imported `.ics`
- * carries an arbitrary ARGB, while a palette calendar only accepts one of its
- * own keys. Distance is measured in Oklab, so the match is the one that looks
- * closest rather than the one that is closest in RGB coordinates.
- */
-fun List<EventColorOption>.nearestTo(argb: Int): EventColorOption? {
-    val target = oklchOf(argb)
-    return minByOrNull { oklchOf(it.argb).distanceTo(target) }
-}

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

@@ -1,256 +0,0 @@
-package de.jeanlucmakiola.calendula.domain
-
-import kotlinx.datetime.DateTimeUnit
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.atStartOfDayIn
-import kotlinx.datetime.number
-import kotlinx.datetime.plus
-import kotlinx.datetime.toLocalDateTime
-import kotlin.time.Instant
-
-/** An event with the free text the search may have matched it on. */
-data class SearchCandidate(
-    val event: EventInstance,
-    val description: String? = null,
-    /** Null when the event has none: [EventInstance.title] is then a display
-     *  placeholder, which the query must not catch on. */
-    val title: String? = event.title,
-)
-
-/** A matched run inside one of a hit's texts, for highlighting. */
-data class MatchSpan(val start: Int, val end: Int)
-
-/** The part of a description a token matched, elided to what fits a row. */
-data class DescriptionSnippet(
-    val text: String,
-    val spans: List<MatchSpan>,
-)
-
-/** One result: the event, plus where the query matched it. */
-data class SearchHit(
-    val event: EventInstance,
-    val titleSpans: List<MatchSpan> = emptyList(),
-    val locationSpans: List<MatchSpan> = emptyList(),
-    val descriptionSnippet: DescriptionSnippet? = null,
-    /** Already over, so the row can say so. Finished-today counts. */
-    val isPast: Boolean = false,
-)
-
-/** One month's worth of hits, as the results list draws them under a header. */
-data class SearchMonth(
-    val year: Int,
-    /** 1–12, so the UI can build the month's first day for a localized label. */
-    val monthNumber: Int,
-    val hits: List<SearchHit>,
-)
-
-/** A finished search: a calendar of hits, plus the description-only ones. */
-data class SearchResults(
-    val months: List<SearchMonth>,
-    val inDescriptions: List<SearchHit>,
-) {
-    val isEmpty: Boolean get() = months.isEmpty() && inDescriptions.isEmpty()
-
-    /** Every hit, whichever section it sits in — for select-all and delete. */
-    val allHits: List<SearchHit> get() = months.flatMap { it.hits } + inDescriptions
-}
-
-/**
- * Turning a typed query into the results list.
- *
- * An event has to carry *every* whitespace-separated token, each in any of
- * title / location / description; case is folded in Kotlin rather than by SQL's
- * ASCII-only `LIKE`, so "ärzte" finds "Ärzte".
- *
- * Results are a calendar, not a ranking: months from the current one, then
- * forwards, then backwards, and inside a month what is still to come before
- * what has passed. The day is the boundary, not the moment. A hit the query
- * only reached through its description is held back in
- * [SearchResults.inDescriptions] rather than dated among the real ones.
- */
-object EventSearch {
-
-    /** Characters of description kept around the match in a row's snippet. */
-    private const val SNIPPET_LENGTH = 96
-
-    /** Characters of lead-in shown before the match, when there is room. */
-    private const val SNIPPET_LEAD = 24
-
-    private val WHITESPACE = Regex("\\s+")
-
-    /** Shared with the data layer so its SQL pre-filter tokenises identically. */
-    fun tokenize(query: String): List<String> =
-        query.trim().split(WHITESPACE).filter { it.isNotEmpty() }
-
-    /**
-     * Search [candidates] for [query], dropping any that don't carry every token.
-     * [now] marks a hit as over, [todayStart] is where it stops being current.
-     * [zone] places each event on the calendar through the span rule, so an
-     * all-day event keeps its own day whichever side of UTC we are on (#82).
-     */
-    fun search(
-        candidates: List<SearchCandidate>,
-        query: String,
-        now: Instant,
-        todayStart: Instant,
-        zone: TimeZone,
-    ): SearchResults {
-        val tokens = tokenize(query)
-        if (tokens.isEmpty()) return SearchResults(emptyList(), emptyList())
-
-        val today = todayStart.toLocalDateTime(zone).date
-        val matched = candidates.mapNotNull { candidate -> match(candidate, tokens, now, zone) }
-        val upcoming = { m: Matched -> m.event.spanLastDay(zone) >= today }
-        val order = compareBy<Matched> { if (upcoming(it)) 0 else 1 }
-            .thenComparator { a, b ->
-                // What is left reads forwards; what is behind us reads backwards
-                // from today, nearest first.
-                if (upcoming(a)) {
-                    a.event.dayStart(zone).compareTo(b.event.dayStart(zone))
-                } else {
-                    b.event.dayStart(zone).compareTo(a.event.dayStart(zone))
-                }
-            }
-
-        val (inDescriptions, dated) = matched.sortedWith(order).partition { it.descriptionOnly }
-        return SearchResults(
-            months = groupByMonth(dated, zone, todayStart),
-            inDescriptions = inDescriptions.map { it.hit },
-        )
-    }
-
-    /** Months from the current one, then forwards, then backwards. */
-    private fun groupByMonth(
-        dated: List<Matched>,
-        zone: TimeZone,
-        todayStart: Instant,
-    ): List<SearchMonth> {
-        val currentKey = monthKey(todayStart.toLocalDateTime(zone).date)
-        return dated
-            .groupBy { monthKey(it.event.spanFirstDay(zone)) }
-            .entries
-            .sortedWith(
-                compareBy<Map.Entry<Int, List<Matched>>> {
-                    when {
-                        it.key == currentKey -> 0
-                        it.key > currentKey -> 1
-                        else -> 2
-                    }
-                }.thenComparator { a, b ->
-                    if (a.key > currentKey) a.key.compareTo(b.key) else b.key.compareTo(a.key)
-                },
-            )
-            .map { (key, entries) ->
-                SearchMonth(
-                    year = key / 12,
-                    monthNumber = key % 12 + 1,
-                    hits = entries.map { it.hit },
-                )
-            }
-    }
-
-    /** Year and month as one comparable number. */
-    private fun monthKey(date: LocalDate): Int = date.year * 12 + (date.month.number - 1)
-
-    private fun match(
-        candidate: SearchCandidate,
-        tokens: List<String>,
-        now: Instant,
-        zone: TimeZone,
-    ): Matched? {
-        val title = candidate.title?.takeIf { it.isNotBlank() }
-        val location = candidate.event.location?.takeIf { it.isNotBlank() }
-        // Collapsed so a multi-line description matches the way it is drawn.
-        val description = candidate.description
-            ?.replace(WHITESPACE, " ")
-            ?.trim()
-            ?.takeIf { it.isNotEmpty() }
-
-        // Mid-word counts: "termin" has to keep finding "Zahnarzttermin".
-        val present = { token: String ->
-            title?.contains(token, ignoreCase = true) == true ||
-                location?.contains(token, ignoreCase = true) == true ||
-                description?.contains(token, ignoreCase = true) == true
-        }
-        if (!tokens.all(present)) return null
-
-        val descriptionSpans = description?.let { spansIn(it, tokens) }.orEmpty()
-        val titleSpans = title?.let { spansIn(it, tokens) }.orEmpty()
-        val locationSpans = location?.let { spansIn(it, tokens) }.orEmpty()
-        return Matched(
-            hit = SearchHit(
-                event = candidate.event,
-                titleSpans = titleSpans,
-                locationSpans = locationSpans,
-                descriptionSnippet = description
-                    ?.takeIf { descriptionSpans.isNotEmpty() }
-                    ?.let { snippet(it, descriptionSpans) },
-                isPast = candidate.event.dayEnd(zone) < now,
-            ),
-            // Nothing in the name or the place caught the query: it is only here
-            // for something in its notes.
-            descriptionOnly = titleSpans.isEmpty() && locationSpans.isEmpty(),
-        )
-    }
-
-    /** Every occurrence of every token in [text], merged where they overlap. */
-    private fun spansIn(text: String, tokens: List<String>): List<MatchSpan> {
-        val raw = mutableListOf<MatchSpan>()
-        for (token in tokens) {
-            var index = text.indexOf(token, startIndex = 0, ignoreCase = true)
-            while (index >= 0) {
-                raw += MatchSpan(index, index + token.length)
-                index = text.indexOf(token, startIndex = index + 1, ignoreCase = true)
-            }
-        }
-        if (raw.isEmpty()) return emptyList()
-        val sorted = raw.sortedBy { it.start }
-        val merged = mutableListOf(sorted.first())
-        for (span in sorted.drop(1)) {
-            val last = merged.last()
-            if (span.start <= last.end) {
-                merged[merged.lastIndex] = MatchSpan(last.start, maxOf(last.end, span.end))
-            } else {
-                merged += span
-            }
-        }
-        return merged
-    }
-
-    /**
-     * A window of [description] around its first match, elided at both ends,
-     * with the spans rebased onto it and any falling outside dropped.
-     */
-    private fun snippet(description: String, spans: List<MatchSpan>): DescriptionSnippet {
-        if (description.length <= SNIPPET_LENGTH) {
-            return DescriptionSnippet(description, spans)
-        }
-        val first = spans.first().start
-        val start = (first - SNIPPET_LEAD).coerceIn(0, (description.length - SNIPPET_LENGTH))
-        val end = (start + SNIPPET_LENGTH).coerceAtMost(description.length)
-        val prefix = if (start > 0) "…" else ""
-        val suffix = if (end < description.length) "…" else ""
-        val text = prefix + description.substring(start, end) + suffix
-        val shift = prefix.length - start
-        val rebased = spans
-            .filter { it.start >= start && it.end <= end }
-            .map { MatchSpan(it.start + shift, it.end + shift) }
-        return DescriptionSnippet(text, rebased)
-    }
-
-    private data class Matched(val hit: SearchHit, val descriptionOnly: Boolean) {
-        val event: EventInstance get() = hit.event
-    }
-
-    /**
-     * The event's first day as an instant in [zone]. An all-day event sits at
-     * UTC midnight, so its raw start would rank it on a day it isn't drawn on.
-     */
-    private fun EventInstance.dayStart(zone: TimeZone): Instant =
-        if (isAllDay) spanFirstDay(zone).atStartOfDayIn(zone) else start
-
-    /** The moment the event's last day is over in [zone], exclusive. */
-    private fun EventInstance.dayEnd(zone: TimeZone): Instant =
-        if (isAllDay) spanLastDay(zone).plus(1, DateTimeUnit.DAY).atStartOfDayIn(zone) else end
-}

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

@@ -63,40 +63,13 @@ data class EventInstance(
     val color: Int,
     val location: String?,
     /**
-     * Only search results, which read the series master, fill this in — the
-     * Instances query already yields one row per occurrence.
+     * Whether this row's event carries a recurrence rule. Only search results
+     * (which read the series master) fill this in — the Instances query already
+     * yields one row per occurrence, so it stays false there.
      */
     val isRecurring: Boolean = false,
-    /**
-     * This device user's own answer to the invitation, as far as the grids care
-     * (#180, #230).
-     */
-    val response: EventResponse = EventResponse.Going,
 )
 
-/**
- * How this device user stands towards an event's invitation
- * (`Events.SELF_ATTENDEE_STATUS`), reduced to the three cases the calendar
- * surfaces draw differently (#230).
- */
-enum class EventResponse {
-    /** Your own event, or one you accepted — including a tentative "maybe". */
-    Going,
-
-    /** Invited, no answer given yet: drawn as an outline so it reads as still open. */
-    Invited,
-
-    /**
-     * You answered "no". The event stays on the calendar — it is still an
-     * appointment someone expects an answer about — but every surface strikes it
-     * through, and it plans no reminders (#180).
-     */
-    Declined,
-}
-
-/** Shorthand for the declined case, which most surfaces test on its own (#180). */
-val EventInstance.isDeclined: Boolean get() = response == EventResponse.Declined
-
 /**
  * Whether this event has finished relative to [now] — its end is at or before
  * the current instant. An in-progress event (already started but not yet ended)

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

@@ -1,80 +0,0 @@
-package de.jeanlucmakiola.calendula.domain.ics
-
-/** Opaque alpha, forced onto any colour that arrives without one. */
-private const val OPAQUE_ALPHA = 0xFF000000.toInt()
-
-/**
- * Resolve a colour value out of a foreign `.ics` to an opaque ARGB int.
- *
- * Three encodings are in the wild and all appear in the files Calendula is
- * asked to import:
- *  - a CSS3 colour name, which is what RFC 7986 `COLOR` is defined as
- *    (`COLOR:tomato`);
- *  - a raw signed Android colour int, which the Simple Calendar / Fossify
- *    family writes in its `X-…-COLOR` extensions (`X-FOSSIFY-EVENT-COLOR:-2818048`);
- *  - `#rrggbb` / `#aarrggbb` hex, used by assorted other producers.
- *
- * Anything else — including the literal `null` Fossify emits when its calendar
- * lookup misses — resolves to null.
- */
-fun parseIcsColorValue(raw: String?): Int? {
-    val value = raw?.trim().orEmpty()
-    if (value.isEmpty()) return null
-
-    if (value.startsWith("#")) {
-        val hex = value.substring(1)
-        val parsed = hex.toLongOrNull(16)?.toInt() ?: return null
-        return when (hex.length) {
-            6 -> parsed or OPAQUE_ALPHA
-            8 -> parsed
-            else -> null
-        }
-    }
-    value.toIntOrNull()?.let { return if (it ushr 24 == 0) it or OPAQUE_ALPHA else it }
-    return cssColors[value.lowercase()]
-}
-
-/** The CSS3 extended colour keywords, the value space of RFC 7986 `COLOR`. */
-private val cssColors: Map<String, Int> by lazy {
-    CSS3_TABLE.split(' ').associate { entry ->
-        val name = entry.substringBefore('=')
-        name to (entry.substringAfter('=').toInt(16) or OPAQUE_ALPHA)
-    }
-}
-
-private const val CSS3_TABLE =
-        "aliceblue=f0f8ff antiquewhite=faebd7 aqua=00ffff aquamarine=7fffd4 " +
-        "azure=f0ffff beige=f5f5dc bisque=ffe4c4 black=000000 blanchedalmond=ffebcd " +
-        "blue=0000ff blueviolet=8a2be2 brown=a52a2a burlywood=deb887 cadetblue=5f9ea0 " +
-        "chartreuse=7fff00 chocolate=d2691e coral=ff7f50 cornflowerblue=6495ed " +
-        "cornsilk=fff8dc crimson=dc143c cyan=00ffff darkblue=00008b darkcyan=008b8b " +
-        "darkgoldenrod=b8860b darkgray=a9a9a9 darkgreen=006400 darkgrey=a9a9a9 " +
-        "darkkhaki=bdb76b darkmagenta=8b008b darkolivegreen=556b2f darkorange=ff8c00 " +
-        "darkorchid=9932cc darkred=8b0000 darksalmon=e9967a darkseagreen=8fbc8f " +
-        "darkslateblue=483d8b darkslategray=2f4f4f darkslategrey=2f4f4f darkturquoise=00ced1 " +
-        "darkviolet=9400d3 deeppink=ff1493 deepskyblue=00bfff dimgray=696969 " +
-        "dimgrey=696969 dodgerblue=1e90ff firebrick=b22222 floralwhite=fffaf0 " +
-        "forestgreen=228b22 fuchsia=ff00ff gainsboro=dcdcdc ghostwhite=f8f8ff " +
-        "gold=ffd700 goldenrod=daa520 gray=808080 green=008000 greenyellow=adff2f " +
-        "grey=808080 honeydew=f0fff0 hotpink=ff69b4 indianred=cd5c5c indigo=4b0082 " +
-        "ivory=fffff0 khaki=f0e68c lavender=e6e6fa lavenderblush=fff0f5 lawngreen=7cfc00 " +
-        "lemonchiffon=fffacd lightblue=add8e6 lightcoral=f08080 lightcyan=e0ffff " +
-        "lightgoldenrodyellow=fafad2 lightgray=d3d3d3 lightgreen=90ee90 lightgrey=d3d3d3 " +
-        "lightpink=ffb6c1 lightsalmon=ffa07a lightseagreen=20b2aa lightskyblue=87cefa " +
-        "lightslategray=778899 lightslategrey=778899 lightsteelblue=b0c4de " +
-        "lightyellow=ffffe0 lime=00ff00 limegreen=32cd32 linen=faf0e6 magenta=ff00ff " +
-        "maroon=800000 mediumaquamarine=66cdaa mediumblue=0000cd mediumorchid=ba55d3 " +
-        "mediumpurple=9370db mediumseagreen=3cb371 mediumslateblue=7b68ee " +
-        "mediumspringgreen=00fa9a mediumturquoise=48d1cc mediumvioletred=c71585 " +
-        "midnightblue=191970 mintcream=f5fffa mistyrose=ffe4e1 moccasin=ffe4b5 " +
-        "navajowhite=ffdead navy=000080 oldlace=fdf5e6 olive=808000 olivedrab=6b8e23 " +
-        "orange=ffa500 orangered=ff4500 orchid=da70d6 palegoldenrod=eee8aa " +
-        "palegreen=98fb98 paleturquoise=afeeee palevioletred=db7093 papayawhip=ffefd5 " +
-        "peachpuff=ffdab9 peru=cd853f pink=ffc0cb plum=dda0dd powderblue=b0e0e6 " +
-        "purple=800080 rebeccapurple=663399 red=ff0000 rosybrown=bc8f8f royalblue=4169e1 " +
-        "saddlebrown=8b4513 salmon=fa8072 sandybrown=f4a460 seagreen=2e8b57 " +
-        "seashell=fff5ee sienna=a0522d silver=c0c0c0 skyblue=87ceeb slateblue=6a5acd " +
-        "slategray=708090 slategrey=708090 snow=fffafa springgreen=00ff7f " +
-        "steelblue=4682b4 tan=d2b48c teal=008080 thistle=d8bfd8 tomato=ff6347 " +
-        "turquoise=40e0d0 violet=ee82ee wheat=f5deb3 white=ffffff whitesmoke=f5f5f5 " +
-        "yellow=ffff00 yellowgreen=9acd32"

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

@@ -22,12 +22,6 @@ data class IcsEvent(
     val zoneId: String,
     /** Bare RRULE value (no `RRULE:` prefix), or null for a one-off event. */
     val recurrenceRule: String? = null,
-    /**
-     * Occurrences deleted from the series, in the provider's `EXDATE` shape —
-     * `yyyyMMdd` for an all-day series, a UTC `yyyyMMddTHHmmssZ` stamp
-     * otherwise. Empty for a one-off event.
-     */
-    val exDates: List<String> = emptyList(),
     val location: String? = null,
     val description: String? = null,
     /** Reminder lead times in minutes before start (raw provider offsets). */

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

@@ -7,25 +7,14 @@ import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.atStartOfDayIn
-import kotlinx.datetime.number
 import kotlinx.datetime.toInstant
-import kotlinx.datetime.toLocalDateTime
-import kotlin.math.ceil
 import kotlin.time.Instant
 
-/** Milliseconds in a calendar day; all-day times are UTC midnights, so this is exact. */
-private const val DAY_MILLIS = 86_400_000L
-private const val MINUTES_PER_DAY = 1_440
-
 /**
  * A `VEVENT` parsed from an `.ics` file — the read-side mirror of [IcsEvent],
  * but [uid] is nullable (an incoming event may carry none; the insert layer
  * then assigns one). Times are absolute instants; [isAllDay]/[zoneId] mirror
  * how the writer encoded them.
- *
- * [reminderMinutes] holds raw lead times as the file's `VALARM`s expressed
- * them — minutes *before* start, so a negative entry means "after start".
- * [semanticReminderMinutes] turns those into the lead times Calendula models.
  */
 data class ParsedIcsEvent(
     val uid: String?,
@@ -41,45 +30,8 @@ data class ParsedIcsEvent(
     val status: EventStatus = EventStatus.Confirmed,
     val availability: Availability = Availability.Busy,
     val calendarName: String? = null,
-    /** Opaque ARGB the source file gave this event, if any (see [parseIcsColorValue]). */
-    val color: Int? = null,
-    /** Excluded occurrences, already in the provider's `EXDATE` shape. */
-    val exDates: List<String> = emptyList(),
-    /** True when this came from a `VTODO` rather than a `VEVENT`. */
-    val isTask: Boolean = false,
 )
 
-/**
- * [reminderMinutes] mapped onto Calendula's model: a lead time in minutes before
- * the event, never negative.
- *
- * For a timed event the raw lead time already is that, and a trigger that fires
- * *after* the start models no lead time at all — it is dropped rather than
- * clamped, which would invent a reminder at the start the file never asked for
- * (a legal `TRIGGER:PT30M` follow-up alarm is the case). All-day reminders are
- * whole days before the event, fired at the user's configured time of day (see
- * `AllDayReminderEncoding`), so a raw offset counts the whole days its trigger
- * lands *earlier than* the event's UTC midnight — i.e. it rounds **up**.
- *
- * Rounding to the nearest day instead would lose a day for every producer whose
- * all-day notifications fire after noon: a file's raw offset is
- * `days × 1440 − timeOfDay`, so "1 day before at 18:00" arrives as
- * `TRIGGER:-PT6H` (raw 360) and would read as "on the day". Rounding up also
- * lands Fossify's encoding correctly — it writes "on the day at 09:00" as a
- * *positive* `TRIGGER:P0DT9H0M0S`, nine hours after the UTC midnight, which
- * ceils to zero days before.
- */
-fun ParsedIcsEvent.semanticReminderMinutes(): List<Int> = reminderMinutes
-    .mapNotNull { raw ->
-        if (isAllDay) {
-            ceil(raw.toDouble() / MINUTES_PER_DAY).toInt().coerceAtLeast(0) * MINUTES_PER_DAY
-        } else {
-            raw.takeIf { it >= 0 }
-        }
-    }
-    .distinct()
-    .sorted()
-
 /** Things the parser dropped rather than failing — surfaced in the import report. */
 enum class IcsParseWarning {
     /** A `RECURRENCE-ID` override occurrence (not modelled; only masters import). */
@@ -93,12 +45,6 @@ enum class IcsParseWarning {
 
     /** A `TZID` couldn't be resolved against the device tz database (used local zone). */
     UnknownTimezone,
-
-    /** `VTODO` components were imported as events — Calendula has no task model. */
-    TasksImportedAsEvents,
-
-    /** A malformed `RRULE` was repaired or dropped (see [sanitizeRrule]). */
-    RecurrenceRuleRepaired,
 }
 
 data class IcsParseResult(
@@ -106,28 +52,8 @@ data class IcsParseResult(
     val warnings: Set<IcsParseWarning>,
 )
 
-/**
- * Outcome of a bulk `.ics` import into one calendar. [failed] counts events the
- * provider rejected — the import continues past them, so a single unusable
- * event can't cost the user the rest of the file.
- *
- * [notAttempted] counts what a retry still has to import, because the permission
- * or the target calendar went away mid-file and every remaining insert would have
- * failed the same way. Events past that point whose UID is already in the
- * calendar count under [skippedDuplicate] instead — they were never going to be
- * added either way. It travels in the summary rather than as an exception so the
- * counts of what *did* land survive: an import is only idempotent for events that
- * carry a UID, so a retry told "nothing happened" would duplicate the rest.
- */
-data class IcsImportSummary(
-    val imported: Int,
-    val skippedDuplicate: Int,
-    val failed: Int = 0,
-    val notAttempted: Int = 0,
-)
-
-/** The non-standard property most exporters name the whole calendar with. */
-private const val CALENDAR_NAME_PROPERTY = "X-WR-CALNAME"
+/** Outcome of a bulk `.ics` import into one calendar. */
+data class IcsImportSummary(val imported: Int, val skippedDuplicate: Int)
 
 /**
  * Hand-rolled RFC 5545 reader, the inverse of [IcsWriter]. Pure and
@@ -136,9 +62,6 @@ private const val CALENDAR_NAME_PROPERTY = "X-WR-CALNAME"
  * (`RECURRENCE-ID`, attendees, unresolved `TZID`) are reported as [warnings]
  * rather than silently dropped. `VTIMEZONE` blocks are skipped — a `TZID` is
  * resolved against the OS tz database instead ([deviceZone] is the fallback).
- *
- * `VTODO` components are read as all-day/timed events: Calendula models no
- * tasks, and dropping them would silently lose half of some exports.
  */
 class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault()) {
 
@@ -146,57 +69,42 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
         val lines = unfoldLines(text)
         val events = mutableListOf<ParsedIcsEvent>()
         val warnings = mutableSetOf<IcsParseWarning>()
-        // Scanned up front, not in document order: an X-WR-CALNAME after the
-        // first VEVENT still names the calendar. The cheap prefix test first,
-        // so a file without one doesn't pay a full parse to find nothing.
-        val calendarName = lines.asSequence()
-            .filter { it.startsWith(CALENDAR_NAME_PROPERTY, ignoreCase = true) }
-            .mapNotNull(::parseContentLine)
-            .firstOrNull { it.name == CALENDAR_NAME_PROPERTY }
-            ?.let { unescapeText(it.value).trim().ifEmpty { null } }
+        var calendarName: String? = null
 
         var i = 0
         while (i < lines.size) {
             val line = parseContentLine(lines[i])
             if (line == null) { i++; continue }
-            val component = when {
-                line.isBegin("VEVENT") -> "VEVENT"
-                line.isBegin("VTODO") -> "VTODO"
-                else -> null
-            }
             when {
-                component != null -> {
-                    val end = indexOfEnd(lines, i + 1, component)
-                    parseComponent(
-                        body = lines.subList(i + 1, end),
-                        fileCalendarName = calendarName,
-                        warnings = warnings,
-                        isTask = component == "VTODO",
-                    )?.let(events::add)
+                line.isBegin("VEVENT") -> {
+                    val end = indexOfEnd(lines, i + 1, "VEVENT")
+                    parseVevent(lines.subList(i + 1, end), calendarName, warnings)
+                        ?.let(events::add)
                     i = end + 1
                 }
                 line.isBegin("VTIMEZONE") -> {
                     // Skipped wholesale; TZIDs resolve against the OS tz database.
                     i = indexOfEnd(lines, i + 1, "VTIMEZONE") + 1
                 }
+                line.name == "X-WR-CALNAME" -> {
+                    calendarName = unescapeText(line.value).trim().ifEmpty { null }
+                    i++
+                }
                 else -> i++
             }
         }
-        if (events.any { it.isTask }) warnings.add(IcsParseWarning.TasksImportedAsEvents)
         return IcsParseResult(events, warnings)
     }
 
-    private fun parseComponent(
+    private fun parseVevent(
         body: List<String>,
         fileCalendarName: String?,
         warnings: MutableSet<IcsParseWarning>,
-        isTask: Boolean,
     ): ParsedIcsEvent? {
         var uid: String? = null
         var summary = ""
         var dtStart: IcsDateTime? = null
         var dtEnd: IcsDateTime? = null
-        var due: IcsDateTime? = null
         var duration: String? = null
         var rrule: String? = null
         var location: String? = null
@@ -204,11 +112,7 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
         var status = EventStatus.Confirmed
         var availability = Availability.Busy
         var calendarName = fileCalendarName
-        var category: String? = null
-        var eventColor: Int? = null
-        var calendarColor: Int? = null
         val reminders = mutableListOf<Int>()
-        val exDateLines = mutableListOf<IcsContentLine>()
         var skipAsOverride = false
 
         var i = 0
@@ -225,11 +129,9 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
                 "UID" -> uid = line.value.trim().ifEmpty { null }
                 "SUMMARY" -> summary = unescapeText(line.value)
                 "DTSTART" -> dtStart = parseIcsDateTime(line, warnings)
-                "DUE" -> if (isTask) due = parseIcsDateTime(line, warnings)
                 "DTEND" -> dtEnd = parseIcsDateTime(line, warnings)
                 "DURATION" -> duration = line.value.trim()
                 "RRULE" -> rrule = line.value.trim().ifEmpty { null }
-                "EXDATE" -> exDateLines.add(line)
                 "LOCATION" -> location = unescapeText(line.value).ifEmpty { null }
                 "DESCRIPTION" -> description = unescapeText(line.value).ifEmpty { null }
                 "STATUS" -> status = mapIcsStatus(line.value)
@@ -240,19 +142,6 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
                 "ATTENDEE" -> warnings.add(IcsParseWarning.AttendeesIgnored)
                 "X-CALENDULA-CALENDAR" ->
                     calendarName = unescapeText(line.value).trim().ifEmpty { calendarName }
-                // Fossify names the source calendar per event; it never writes
-                // an X-WR-CALNAME, so this is the only calendar label its files
-                // carry. Elsewhere CATEGORIES is a plain tag list, so it only
-                // stands in where nothing named the calendar outright.
-                "CATEGORIES" -> category = singleCategory(line.value) ?: category
-                // Per-event colour, most specific encoding first (see parseIcsColorValue).
-                "X-FOSSIFY-EVENT-COLOR", "X-SMT-EVENT-COLOR" ->
-                    eventColor = parseIcsColorValue(line.value) ?: eventColor
-                "COLOR" -> eventColor = eventColor ?: parseIcsColorValue(line.value)
-                // The *calendar's* colour. Kept as a fallback so a migration that
-                // folds several source calendars into one keeps them apart visually.
-                "X-FOSSIFY-CATEGORY-COLOR", "X-SMT-CATEGORY-COLOR", "CATEGORY_COLOR" ->
-                    calendarColor = parseIcsColorValue(line.value) ?: calendarColor
             }
             i++
         }
@@ -261,125 +150,37 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
             warnings.add(IcsParseWarning.ModifiedOccurrenceSkipped)
             return null
         }
-        // Most producers give a VTODO only a DUE, which is then the moment the
-        // task sits at. One that carries a DTSTART too means the span between
-        // them, so DUE stands in for the end it has no DTEND for. Resolved after
-        // the sweep rather than inside it: property order isn't guaranteed, and
-        // a DUE ahead of the DTSTART would otherwise be taken for the start.
-        if (isTask && due != null) {
-            if (dtStart == null) dtStart = due else if (dtEnd == null) dtEnd = due
-        }
         val start = dtStart ?: run {
             warnings.add(IcsParseWarning.EventWithoutStartSkipped)
             return null
         }
-        val recurrence = sanitizeRrule(rrule)
-        if (recurrence.repaired) warnings.add(IcsParseWarning.RecurrenceRuleRepaired)
-        val end = resolveEnd(start, dtEnd, duration)
+        val end = dtEnd
+            ?: duration?.let {
+                start.copy(
+                    instant = Instant.fromEpochMilliseconds(
+                        start.instant.toEpochMilliseconds() + parseRfc2445DurationMillis(it),
+                    ),
+                )
+            }
+            ?: start
         return ParsedIcsEvent(
             uid = uid,
             summary = summary,
             start = start.instant,
-            end = end,
+            end = end.instant,
             isAllDay = start.isAllDay,
             zoneId = start.zoneId,
-            recurrenceRule = recurrence.rule,
+            recurrenceRule = rrule,
             location = location,
             description = description,
             reminderMinutes = reminders.distinct(),
             status = status,
             availability = availability,
-            calendarName = calendarName ?: category,
-            color = eventColor ?: calendarColor,
-            exDates = if (recurrence.rule == null) {
-                emptyList()
-            } else {
-                normalizeExDates(exDateLines, start)
-            },
-            isTask = isTask,
+            calendarName = calendarName,
         )
     }
 
-    /**
-     * The event's end instant.
-     *
-     * All-day events get two RFC 5545 §3.6.1 rules applied that a literal read
-     * would miss: a `DATE`-valued `DTSTART` with no `DTEND` lasts one day, and —
-     * since the provider expands a zero-length all-day series into no instances
-     * at all — an all-day event may never end at or before it starts.
-     */
-    private fun resolveEnd(
-        start: IcsDateTime,
-        dtEnd: IcsDateTime?,
-        duration: String?,
-    ): Instant {
-        val explicit = dtEnd?.instant ?: duration?.let {
-            Instant.fromEpochMilliseconds(
-                start.instant.toEpochMilliseconds() + parseRfc2445DurationMillis(it),
-            )
-        }
-        if (!start.isAllDay) return explicit ?: start.instant
-        return explicit?.takeIf { it > start.instant } ?: start.instant.plusDays(1)
-    }
-
-    /**
-     * `EXDATE` values in the shape `Events.EXDATE` wants: `yyyyMMdd` for an
-     * all-day series, a UTC `yyyyMMddTHHmmssZ` stamp otherwise.
-     *
-     * Fossify stores its excluded occurrences as bare day codes and writes them
-     * out that way even for timed series, where the property is then ambiguous.
-     * Such a value is resolved against the series' own time of day, which is
-     * what it meant — its repetitions never move within the day.
-     *
-     * An all-day exclusion names a calendar day, so a zone-qualified DATE-TIME
-     * still means the day it spells out; resolving it to an instant first and
-     * reading *that* back in UTC would roll a midnight east of UTC onto the day
-     * before and exclude an occurrence that doesn't exist.
-     */
-    private fun normalizeExDates(lines: List<IcsContentLine>, start: IcsDateTime): List<String> {
-        if (lines.isEmpty()) return emptyList()
-        val startZone = runCatching { TimeZone.of(start.zoneId) }.getOrNull() ?: deviceZone
-        val startTime = start.instant.toLocalDateTime(startZone).time
-        return lines
-            .flatMap { line -> line.value.split(',').map { line to it.trim() } }
-            .mapNotNull { (line, token) ->
-                when {
-                    token.isEmpty() -> null
-                    start.isAllDay -> parseBasicDate(token.substringBefore('T'))?.let(::dayCode)
-                    token.contains('T') -> parseExDateTime(token, line, startZone)?.let(::utcStamp)
-                    else -> parseBasicDate(token)
-                        ?.let { utcStamp(LocalDateTime(it, startTime).toInstant(startZone)) }
-                }
-            }
-            .distinct()
-    }
-
-    /**
-     * [startZone] is the series' own zone, which a floating value (no `Z`, no
-     * `TZID`) has to be read in — RFC 5545 ties `EXDATE` to `DTSTART`'s form,
-     * and reading it in the device's zone instead would put the exclusion on an
-     * instant no occurrence has.
-     */
-    private fun parseExDateTime(
-        token: String,
-        line: IcsContentLine,
-        startZone: TimeZone,
-    ): Instant? {
-        val ldt = parseBasicDateTime(token.removeSuffix("Z")) ?: return null
-        val zone = when {
-            token.endsWith("Z") -> TimeZone.UTC
-            else -> line.params["TZID"]?.let { runCatching { TimeZone.of(it) }.getOrNull() }
-                ?: startZone
-        }
-        return ldt.toInstant(zone)
-    }
-
-    /**
-     * A `VALARM`'s offset from the event start, in minutes *before* it — so a
-     * trigger that fires after the start (which is how the Fossify family
-     * encodes "on the day at 09:00") comes back negative. Null when the trigger
-     * isn't a usable relative offset.
-     */
+    /** A VALARM's lead time in minutes before start, or null if not a usable relative trigger. */
     private fun parseAlarmMinutes(body: List<String>): Int? {
         val trigger = body.asSequence()
             .mapNotNull { parseContentLine(it) }
@@ -388,7 +189,8 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
         // Absolute (DATE-TIME) triggers can't be expressed as a lead time.
         if (trigger.params["VALUE"].equals("DATE-TIME", true)) return null
         val millis = parseRfc2445DurationMillis(trigger.value)
-        return (-millis / 60_000L).toInt()
+        // Negative = before start (the normal case) → positive lead minutes.
+        return (-millis / 60_000L).toInt().coerceAtLeast(0)
     }
 
     private fun parseIcsDateTime(line: IcsContentLine, warnings: MutableSet<IcsParseWarning>): IcsDateTime? {
@@ -416,34 +218,6 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
         fun IcsContentLine.isBegin(component: String) =
             name == "BEGIN" && value.trim().equals(component, true)
 
-        fun Instant.plusDays(days: Int): Instant =
-            Instant.fromEpochMilliseconds(toEpochMilliseconds() + days * DAY_MILLIS)
-
-        fun dayCode(date: LocalDate): String =
-            "%04d%02d%02d".format(date.year, date.month.number, date.day)
-
-        fun utcStamp(instant: Instant): String = with(instant.toLocalDateTime(TimeZone.UTC)) {
-            "%04d%02d%02dT%02d%02d%02dZ".format(year, month.number, day, hour, minute, second)
-        }
-
-        /**
-         * A single-valued `CATEGORIES`, which is what the Fossify family writes
-         * for the source calendar's name. A multi-item list is a tag list and
-         * names no calendar, so it is ignored.
-         */
-        fun singleCategory(raw: String): String? {
-            var escaped = false
-            for (c in raw) {
-                when {
-                    escaped -> escaped = false
-                    c == '\\' -> escaped = true
-                    c == ',' -> return null
-                }
-            }
-            return unescapeText(raw).trim()
-                .takeIf { it.isNotEmpty() && !it.equals("null", true) }
-        }
-
         /** Index of the matching `END:<component>` at/after [from], or list end. */
         fun indexOfEnd(lines: List<String>, from: Int, component: String): Int {
             var i = from

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

@@ -1,132 +0,0 @@
-package de.jeanlucmakiola.calendula.domain.ics
-
-private val VALID_FREQ = setOf(
-    "SECONDLY", "MINUTELY", "HOURLY", "DAILY", "WEEKLY", "MONTHLY", "YEARLY",
-)
-
-private val VALID_WEEKDAYS = setOf("SU", "MO", "TU", "WE", "TH", "FR", "SA")
-
-/**
- * What `EventRecurrence` accepts in each numeric list part: a value range, plus
- * whether `0` is legal. Its `parseNumberList` throws on a non-number, on an item
- * outside the range *and* on a zero in the by-position parts, so checking only
- * that an item is a number would still hand the provider a rule it rejects.
- *
- * `BYSETPOS` is the one part it leaves unbounded; `0` is dropped from it anyway
- * because RFC 5545 §3.3.10 gives it no meaning.
- */
-private val NUMERIC_LIST_PARTS = mapOf(
-    "BYSECOND" to NumericPart(0..59, zeroAllowed = true),
-    "BYMINUTE" to NumericPart(0..59, zeroAllowed = true),
-    "BYHOUR" to NumericPart(0..23, zeroAllowed = true),
-    "BYMONTHDAY" to NumericPart(-31..31, zeroAllowed = false),
-    "BYYEARDAY" to NumericPart(-366..366, zeroAllowed = false),
-    "BYWEEKNO" to NumericPart(-53..53, zeroAllowed = false),
-    "BYMONTH" to NumericPart(1..12, zeroAllowed = false),
-    "BYSETPOS" to NumericPart(Int.MIN_VALUE..Int.MAX_VALUE, zeroAllowed = false),
-)
-
-private class NumericPart(private val range: IntRange, private val zeroAllowed: Boolean) {
-    fun accepts(item: String): Boolean {
-        val n = item.toIntOrNull() ?: return false
-        return n in range && (zeroAllowed || n != 0)
-    }
-}
-
-/** `UNTIL` in RFC 5545 basic format; anything else fails at expansion time. */
-private val UNTIL_SHAPE = Regex("""\d{8}(T\d{6}Z?)?""")
-
-/**
- * A foreign RRULE made safe to hand `CalendarContract`.
- *
- * [rule] is what survived, or null when there is nothing left to salvage.
- * [repaired] is true only when a part was actually dropped — pure normalisation
- * (case, a stray separator) doesn't count, so a conformant file is never
- * reported to the user as faulty.
- */
-data class SanitizedRrule(val rule: String?, val repaired: Boolean)
-
-/**
- * Salvage a foreign RRULE.
- *
- * The provider validates every RRULE through `EventRecurrence.parse`, which
- * **throws** on a malformed rule — and the throw surfaces from `insert`, not
- * from a later read. One bad rule in an imported file would therefore abort the
- * write it rides on. Producers do emit such rules: Fossify's exporter writes a
- * bare `;BYDAY=` whenever a weekly event carries no weekday mask
- * (`Parser.getByDay` interpolates an empty day string unconditionally), which is
- * the state every weekly event it imported from elsewhere is left in.
- *
- * That parser has a fixed table of parts and throws on any name outside it, so
- * this is a whitelist: an unrecognised part (RFC 7529 `RSCALE`, a vendor `X-`
- * extension) and an unusable value are dropped rather than passed on to fail the
- * whole event. Only a missing or unrecognised `FREQ` — without which there is no
- * rule at all — gives up entirely.
- */
-fun sanitizeRrule(raw: String?): SanitizedRrule {
-    val rule = raw?.trim()?.removePrefix("RRULE:")?.trim().orEmpty()
-    if (rule.isEmpty()) return SanitizedRrule(rule = null, repaired = false)
-
-    var freqSeen = false
-    var repaired = false
-    val parts = mutableListOf<String>()
-
-    /** The items [valid] accepts, uppercased and comma-joined; null if none survive. */
-    fun keepItems(value: String, valid: (String) -> Boolean): String? {
-        val items = value.split(',').map { it.trim().uppercase() }
-        val kept = items.filter(valid)
-        if (kept.size != items.size) repaired = true
-        return kept.takeIf { it.isNotEmpty() }?.joinToString(",")
-    }
-
-    for (part in rule.split(';')) {
-        // A stray separator ("FREQ=DAILY;") normalises away; nothing was lost.
-        // A part that carries text but no '=' ("FREQ=WEEKLY;BYDAY") is a part
-        // being dropped, so it falls through and marks the rule repaired.
-        if (part.isBlank()) continue
-        val key = part.substringBefore('=', "").trim().uppercase()
-        val value = if ('=' in part) part.substringAfter('=').trim() else ""
-        val kept = when {
-            key.isEmpty() || value.isEmpty() -> null
-            key == "FREQ" ->
-                value.uppercase().takeIf { it in VALID_FREQ }
-                    ?.also { freqSeen = true }
-                    ?.let { "FREQ=$it" }
-            // A non-positive or non-numeric INTERVAL/COUNT is rejected by the
-            // provider, and a COUNT of zero would expand to no occurrences.
-            key == "INTERVAL" -> value.toIntOrNull()?.takeIf { it > 0 }?.let { "INTERVAL=$it" }
-            key == "COUNT" -> value.toIntOrNull()?.takeIf { it > 0 }?.let { "COUNT=$it" }
-            key == "UNTIL" ->
-                value.uppercase().takeIf { UNTIL_SHAPE.matches(it) }?.let { "UNTIL=$it" }
-            key == "WKST" ->
-                value.uppercase().takeIf { it in VALID_WEEKDAYS }?.let { "WKST=$it" }
-            key == "BYDAY" -> keepItems(value, ::isWeekdayItem)?.let { "BYDAY=$it" }
-            key in NUMERIC_LIST_PARTS ->
-                keepItems(value, NUMERIC_LIST_PARTS.getValue(key)::accepts)?.let { "$key=$it" }
-            else -> null
-        }
-        if (kept == null) repaired = true else parts += kept
-    }
-    // `EventRecurrence.parse` ends with *two* global checks, not one: a missing
-    // FREQ throws, and so does an UNTIL that arrives together with a COUNT. A
-    // rule carrying both is malformed per RFC 5545 §3.3.10 but real producers
-    // emit it, and left alone it would throw straight out of `insert` — the very
-    // failure this function exists to prevent. UNTIL is kept: it bounds the
-    // series at an absolute date, so a stale COUNT can't over-generate past it.
-    if (parts.any { it.startsWith("UNTIL=") }) {
-        if (parts.removeAll { it.startsWith("COUNT=") }) repaired = true
-    }
-    return if (freqSeen) {
-        SanitizedRrule(rule = parts.joinToString(";"), repaired = repaired)
-    } else {
-        SanitizedRrule(rule = null, repaired = true)
-    }
-}
-
-/** A `BYDAY` item: a two-letter weekday, optionally preceded by an ordinal. */
-private fun isWeekdayItem(item: String): Boolean {
-    if (item.length < 2) return false
-    val ordinal = item.dropLast(2)
-    return item.takeLast(2) in VALID_WEEKDAYS &&
-        (ordinal.isEmpty() || ordinal.toIntOrNull() != null)
-}

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

@@ -46,7 +46,6 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) {
         appendTimes(event)
         event.recurrenceRule?.takeIf { it.isNotBlank() }
             ?.let { add("RRULE:${it.removePrefix("RRULE:")}") }
-        appendExDates(event)
         event.location?.takeIf { it.isNotBlank() }
             ?.let { add("LOCATION:${escapeText(it)}") }
         event.description?.takeIf { it.isNotBlank() }
@@ -84,20 +83,6 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) {
         }
     }
 
-    /**
-     * The series' deleted occurrences. RFC 5545 ties `EXDATE`'s value type to
-     * `DTSTART`'s, so an all-day series needs the explicit `VALUE=DATE` — without
-     * it the bare day codes read as an invalid DATE-TIME. Only written for a
-     * recurring event: an exclusion names an occurrence, and a one-off has none.
-     */
-    private fun MutableList<String>.appendExDates(event: IcsEvent) {
-        if (event.recurrenceRule.isNullOrBlank()) return
-        val stamps = event.exDates.filter { it.isNotBlank() }.distinct()
-        if (stamps.isEmpty()) return
-        val prefix = if (event.isAllDay) "EXDATE;VALUE=DATE:" else "EXDATE:"
-        add(prefix + stamps.joinToString(","))
-    }
-
     private fun MutableList<String>.appendAlarm(minutes: Int, summary: String) {
         add("BEGIN:VALARM")
         add("ACTION:DISPLAY")

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

@@ -13,11 +13,6 @@ import kotlinx.datetime.toLocalDateTime
  * calendar, exactly like a fresh create — the user confirms the target and
  * reviews everything before saving. Mirrors `EventDetail.toEditForm`'s all-day
  * handling (provider all-day times are UTC midnights with an exclusive end).
- *
- * [ParsedIcsEvent.color] is deliberately not carried over: picking the calendar
- * is the first thing this form asks for, and that clears any colour (a raw ARGB
- * is invalid on a calendar whose account publishes a palette). Bulk import,
- * where the target is known up front, does keep it.
  */
 fun ParsedIcsEvent.toEventForm(zone: TimeZone): EventForm {
     val (start, end) = if (isAllDay) {
@@ -36,7 +31,7 @@ fun ParsedIcsEvent.toEventForm(zone: TimeZone): EventForm {
         end = end,
         location = location.orEmpty(),
         description = description.orEmpty(),
-        reminders = semanticReminderMinutes(),
+        reminders = reminderMinutes.distinct().sorted(),
         availability = availability,
         rrule = recurrenceRule?.removePrefix("RRULE:")?.takeIf { it.isNotBlank() },
     )

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

@@ -63,12 +63,6 @@ private const val MINUTES_PER_DAY = 1_440
  * for *which day* it means ([allDayLeadDays]) and take the hour from
  * [allDayTimeMinutes], recomposed against each occurrence's own date in [zone].
  * Duplicate offsets in [minutesByEvent] collapse.
- *
- * Every offset given is planned. The provider's "use the account default"
- * sentinel names a lead time no reader can resolve, and is translated out on the
- * way in
- * ([de.jeanlucmakiola.calendula.data.calendar.withoutProviderDefaults]) — taken
- * as an offset it would arm an alarm a minute after the event began.
  */
 fun planReminders(
     instances: List<ReminderEventInstance>,
@@ -76,19 +70,17 @@ fun planReminders(
     zone: ZoneId,
     allDayTimeMinutes: Int,
 ): List<PlannedReminder> = instances.flatMap { instance ->
-    minutesByEvent[instance.eventId].orEmpty()
-        .distinct()
-        .map { minutes ->
-            PlannedReminder(
-                instance = instance,
-                minutes = minutes,
-                alarmMillis = if (instance.isAllDay) {
-                    allDayAlarmMillis(instance.beginMillis, minutes, zone, allDayTimeMinutes)
-                } else {
-                    instance.beginMillis - minutes * MILLIS_PER_MINUTE
-                },
-            )
-        }
+    minutesByEvent[instance.eventId].orEmpty().distinct().map { minutes ->
+        PlannedReminder(
+            instance = instance,
+            minutes = minutes,
+            alarmMillis = if (instance.isAllDay) {
+                allDayAlarmMillis(instance.beginMillis, minutes, zone, allDayTimeMinutes)
+            } else {
+                instance.beginMillis - minutes * MILLIS_PER_MINUTE
+            },
+        )
+    }
 }
 
 /** UTC midnight of an all-day occurrence, as the calendar date it stands for. */

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

@@ -312,17 +312,12 @@ fun CalendarHost(
         heldEditKey = key
         editKey = key
     }
-    // Off by preference (#173) switches off the gesture, not the scope: blocks
-    // register no drag, while the edit form and its TalkBack action stay put.
-    val dragToReschedule = viewModel.dragToReschedule.collectAsStateWithLifecycle().value
-    val moveScope = remember(movableCalendarIds, reschedule, dragToReschedule) {
+    val moveScope = remember(movableCalendarIds, reschedule) {
         EventMoveScope(
             movableCalendarIds = movableCalendarIds,
-            dragEnabled = dragToReschedule,
-            move = { reschedule.move(it) },
+            move = reschedule::move,
             inFlight = reschedule.inFlight,
             undoStarted = reschedule.undoStarted,
-            abandoned = reschedule.abandoned,
             edit = onEditEvent,
         )
     }

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

@@ -53,18 +53,4 @@ class CalendarHostViewModel @Inject constructor(
             started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = false,
         )
-
-    /**
-     * Whether events may be dragged to another slot to reschedule them (#68, #173).
-     * Off until the stored value arrives, even though the preference itself defaults
-     * on: the wrong guess costs an enabled user a gesture for the few frames a cold
-     * start takes to read DataStore, but re-arms the one thing a disabled user
-     * switched off to be rid of.
-     */
-    val dragToReschedule: StateFlow<Boolean> = prefs.dragToReschedule
-        .stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5_000L),
-            initialValue = false,
-        )
 }

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

@@ -2,15 +2,12 @@ package de.jeanlucmakiola.calendula.ui
 
 import android.Manifest
 import android.content.pm.PackageManager
-import androidx.compose.animation.AnimatedContent
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.animation.togetherWith
+import androidx.compose.animation.Crossfade
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.SideEffect
-import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
@@ -25,22 +22,13 @@ import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
 import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesScheduler
 import de.jeanlucmakiola.calendula.data.contacts.hasContactsPermission
-import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
-import de.jeanlucmakiola.calendula.ui.onboarding.OnboardingStep
-import de.jeanlucmakiola.calendula.ui.onboarding.OnboardingSteps
-import de.jeanlucmakiola.calendula.ui.onboarding.OnboardingViewModel
-import de.jeanlucmakiola.calendula.ui.onboarding.onboardingSlideTransition
-import de.jeanlucmakiola.calendula.ui.onboarding.rememberOnboardingSlideSpec
-import de.jeanlucmakiola.floret.identity.rememberReduceMotion
-
-/** What the root is showing: a wizard step, the app, or neither yet. */
-private sealed interface RootTarget {
-    /** DataStore has not emitted yet — render nothing rather than the wrong screen. */
-    data object Loading : RootTarget
-    data object App : RootTarget
-    data class Step(val step: OnboardingStep) : RootTarget
-}
+import de.jeanlucmakiola.calendula.ui.calendars.CalendarVisibilityNoticeDialog
+import de.jeanlucmakiola.calendula.ui.calendars.CalendarVisibilityNoticeViewModel
+import de.jeanlucmakiola.calendula.ui.permission.PermissionScreen
+import de.jeanlucmakiola.calendula.ui.permission.ReminderOnboardingScreen
+import de.jeanlucmakiola.calendula.ui.permission.ReminderOnboardingViewModel
 
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 fun RootScreen(
     modifier: Modifier = Modifier,
@@ -88,87 +76,58 @@ fun RootScreen(
         onDispose { lifecycle.removeObserver(obs) }
     }
 
-    val onboarding: OnboardingViewModel = hiltViewModel()
-    val plan by onboarding.plan.collectAsStateWithLifecycle()
-    // The grant is reported however it was taken, including via Android's
-    // app-settings screen (caught by the ON_RESUME above); arming the wizard
-    // hangs off that, not off the in-app callback.
-    LaunchedEffect(hasPermission) {
-        onboarding.setHasPermission(hasPermission)
-        if (hasPermission && !grantedAtLaunch) onboarding.onPermissionGranted()
-    }
-
-    // Arms the one-time explainer for the switch to the device's own calendar
-    // visibility (#75), which the wizard then carries as a step of its own.
-    LaunchedEffect(hasPermission) {
-        if (hasPermission) onboarding.reconcileCalendarVisibility()
-    }
-
-    val current = plan
-    val target: RootTarget = when {
-        current == null -> RootTarget.Loading
-        current.current == null -> RootTarget.App
-        else -> RootTarget.Step(current.current)
-    }
-
-    // Which way the flow is moving, so a step-back slides back. The app sorts
-    // after every step, so finishing the wizard reads as one more move forward.
-    val ordinal = when (target) {
-        RootTarget.Loading -> Int.MIN_VALUE
-        RootTarget.App -> Int.MAX_VALUE
-        is RootTarget.Step -> current?.steps?.indexOf(target.step) ?: 0
-    }
-    var lastOrdinal by remember { mutableIntStateOf(ordinal) }
-    val slideDir = if (ordinal < lastOrdinal) -1 else 1
-    SideEffect { lastOrdinal = ordinal }
-
-    val slideSpec = rememberOnboardingSlideSpec()
-    val fadeSpec = rememberCalendarFadeSpec()
-    val reduceMotion = rememberReduceMotion()
-    AnimatedContent(
-        targetState = target,
-        transitionSpec = {
-            // Coming off the blank first frame is not a step change.
-            if (initialState == RootTarget.Loading) {
-                fadeIn(fadeSpec).togetherWith(fadeOut(fadeSpec))
-            } else {
-                onboardingSlideTransition(
-                    slideDir = slideDir,
-                    spec = slideSpec,
-                    fadeSpec = fadeSpec,
-                    reduceMotion = reduceMotion,
-                )
+    // Cross-fade the one-time onboarding gates so granting permission / finishing
+    // onboarding eases into the next screen instead of snapping. A fade carries no
+    // spatial motion, so it stays appropriate under "remove animations" too.
+    val gateSpec = MaterialTheme.motionScheme.fastEffectsSpec<Float>()
+    Crossfade(targetState = hasPermission, animationSpec = gateSpec, label = "permissionGate") { granted ->
+        if (granted) {
+            // Second onboarding gate (v1.4, one-time): reminder notifications.
+            // Null until DataStore's first emission — render nothing for that
+            // frame instead of flashing the wrong screen.
+            val reminderOnboarding: ReminderOnboardingViewModel = hiltViewModel()
+            val onboardingDone by reminderOnboarding.onboardingDone.collectAsStateWithLifecycle()
+            // One-time explainer for the switch to the device's own calendar
+            // visibility (#75), armed by the reconciler.
+            val visibilityNotice: CalendarVisibilityNoticeViewModel = hiltViewModel()
+            val noticePending by visibilityNotice.pending.collectAsStateWithLifecycle()
+            // Runs on entry however the permission was granted, including via
+            // Android's app-settings screen (caught by the ON_RESUME above).
+            LaunchedEffect(Unit) {
+                visibilityNotice.reconcile()
+                if (!grantedAtLaunch) reminderOnboarding.rearmAfterGrant()
             }
-        },
-        label = "onboardingGate",
-    ) { shown ->
-        when (shown) {
-            RootTarget.Loading -> Unit
-            RootTarget.App -> CalendarHost(
+            if (onboardingDone == true && noticePending) {
+                CalendarVisibilityNoticeDialog(onDismiss = visibilityNotice::dismiss)
+            }
+            Crossfade(targetState = onboardingDone, animationSpec = gateSpec, label = "onboardingGate") { done ->
+                when (done) {
+                    true -> CalendarHost(
+                        modifier = modifier,
+                        requestedDetailKey = requestedDetailKey,
+                        onDetailKeyConsumed = onDetailKeyConsumed,
+                        widgetNavRequest = widgetNavRequest,
+                        onWidgetNavConsumed = onWidgetNavConsumed,
+                        requestedImportUri = requestedImportUri,
+                        onImportConsumed = onImportConsumed,
+                        requestedInsertForm = requestedInsertForm,
+                        requestedInsertSource = requestedInsertSource,
+                        onInsertConsumed = onInsertConsumed,
+                        requestedEditKey = requestedEditKey,
+                        onEditKeyConsumed = onEditKeyConsumed,
+                    )
+                    false -> ReminderOnboardingScreen(
+                        onFinished = reminderOnboarding::finish,
+                        modifier = modifier,
+                    )
+                    null -> {}
+                }
+            }
+        } else {
+            PermissionScreen(
+                onGranted = { hasPermission = true },
                 modifier = modifier,
-                requestedDetailKey = requestedDetailKey,
-                onDetailKeyConsumed = onDetailKeyConsumed,
-                widgetNavRequest = widgetNavRequest,
-                onWidgetNavConsumed = onWidgetNavConsumed,
-                requestedImportUri = requestedImportUri,
-                onImportConsumed = onImportConsumed,
-                requestedInsertForm = requestedInsertForm,
-                requestedInsertSource = requestedInsertSource,
-                onInsertConsumed = onInsertConsumed,
-                requestedEditKey = requestedEditKey,
-                onEditKeyConsumed = onEditKeyConsumed,
             )
-            // Both halves of a transition read their position out of the live
-            // plan; the one the outgoing step was drawn with is already gone.
-            is RootTarget.Step -> current?.let { plan ->
-                OnboardingSteps(
-                    step = shown.step,
-                    plan = plan,
-                    viewModel = onboarding,
-                    onPermissionGranted = { hasPermission = true },
-                    modifier = modifier,
-                )
-            }
         }
     }
 }

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

@@ -24,14 +24,11 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.domain.isDeclined
 import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
-import de.jeanlucmakiola.calendula.ui.common.declinedTitle
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.eventAccent
@@ -132,8 +129,8 @@ internal fun AgendaEventRow(
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
     GroupedRow(
         modifier = if (dimmed) modifier.alpha(EventDimAlpha) else modifier,
-        title = declinedTitle(title, event.isDeclined),
-        summary = AnnotatedString(agendaTimeSummary(event, day, zone)),
+        title = title,
+        summary = agendaTimeSummary(event, day, zone),
         position = position,
         minHeight = 64.dp,
         leading = {

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

@@ -30,6 +30,7 @@ import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.TopAppBarScrollBehavior
 import androidx.compose.material3.rememberDrawerState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
@@ -39,9 +40,9 @@ import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -50,8 +51,6 @@ import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.hasEnded
 import de.jeanlucmakiola.calendula.ui.common.AgendaRangePicker
-import de.jeanlucmakiola.calendula.ui.common.AppBarSpacing
-import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
 import de.jeanlucmakiola.calendula.ui.common.agendaRangeLabel
 import de.jeanlucmakiola.floret.identity.animateItemMotion
 import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
@@ -96,6 +95,7 @@ fun AgendaScreen(
     val showToday by viewModel.showToday.collectAsStateWithLifecycle()
     val weekStart by viewModel.weekStart.collectAsStateWithLifecycle()
 
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
     val drawerState = rememberDrawerState(DrawerValue.Closed)
     val scope = rememberCoroutineScope()
     var showRangePicker by remember { mutableStateOf(false) }
@@ -130,16 +130,16 @@ fun AgendaScreen(
         },
     ) {
         Scaffold(
-            modifier = modifier,
+            modifier = modifier.nestedScroll(scrollBehavior.nestedScrollConnection),
             topBar = {
                 AgendaTopBar(
                     selectedView = selectedView,
                     onCycleView = { onSelectView(selectedView.next(quickSwitchViews)) },
-                    quickSwitchViews = quickSwitchViews,
                     onOpenDrawer = { scope.launch { drawerState.open() } },
                     onOpenSearch = onOpenSearch,
                     showTodayButton = todayInToolbar,
                     onToday = viewModel::goToToday,
+                    scrollBehavior = scrollBehavior,
                 )
             },
             floatingActionButton = {
@@ -159,24 +159,13 @@ fun AgendaScreen(
                 // One bar at the top: the "showing …" header on the left and the
                 // session range switcher on the right (one settings toggle).
                 successState?.takeIf { it.showRangeBar }?.let { s ->
-                    // end lines the selector up with whatever ends the top bar:
-                    // the view switcher's background, or — once #150 hides it —
-                    // the search icon's glyph.
-                    val selectorEnd = if (quickSwitchViews.size >= QuickSwitchConfig.MIN_CYCLE) {
-                        AppBarSpacing.Inset
-                    } else {
-                        AppBarSpacing.IconTrailingInset
-                    }
                     Row(
                         verticalAlignment = Alignment.CenterVertically,
+                        // end aligns the selector's right edge with the top-bar view
+                        // switcher (its 8.dp margin + the app bar's 4.dp inset).
                         modifier = Modifier
                             .fillMaxWidth()
-                            .padding(
-                                start = RANGE_BAR_TEXT_INSET,
-                                end = selectorEnd,
-                                top = 8.dp,
-                                bottom = 8.dp,
-                            ),
+                            .padding(start = 28.dp, end = 12.dp, top = 8.dp, bottom = 8.dp),
                     ) {
                         AgendaRangeBanner(
                             range = s.range,
@@ -256,9 +245,6 @@ private fun AgendaRangePill(
     }
 }
 
-/** Optical start inset for the range bar's text, set against the title above it. */
-private val RANGE_BAR_TEXT_INSET = 28.dp
-
 /**
  * A header naming the concrete window currently shown under a "showing …" label,
  * e.g. "27 Jun 2026" / "27 Jun – 3 Jul 2026" / "June 2026". The range's name
@@ -290,7 +276,7 @@ private fun AgendaRangeBanner(
 }
 
 @Composable
-internal fun AgendaContent(
+private fun AgendaContent(
     state: AgendaUiState,
     pastDisplay: PastEventDisplay,
     showToday: Boolean,
@@ -423,22 +409,17 @@ private fun AgendaEmpty(modifier: Modifier = Modifier) {
 private fun AgendaTopBar(
     selectedView: CalendarView,
     onCycleView: () -> Unit,
-    quickSwitchViews: List<CalendarView>,
     onOpenDrawer: () -> Unit,
     onOpenSearch: () -> Unit,
     showTodayButton: Boolean,
     onToday: () -> Unit,
+    scrollBehavior: TopAppBarScrollBehavior,
 ) {
     TopAppBar(
         title = {
-            // A plain label rather than a CalendarTitleButton, so it takes that
-            // one's inset and one-line clamp itself.
             Text(
                 text = stringResource(R.string.view_agenda),
                 style = MaterialTheme.typography.titleLarge,
-                maxLines = 1,
-                overflow = TextOverflow.Ellipsis,
-                modifier = Modifier.padding(start = AppBarSpacing.TitleInset),
             )
         },
         navigationIcon = {
@@ -459,16 +440,14 @@ private fun AgendaTopBar(
             }
             ViewSwitcherPill(
                 current = selectedView,
-                cycle = quickSwitchViews,
                 onCycle = onCycleView,
+                modifier = Modifier.padding(end = 8.dp),
             )
         },
-        // Deliberately flat: M3 lifts the bar to mark content scrolling under
-        // it, but here the bar meets the header on the same surface and the
-        // tint is what makes that seam look like a separate block (#186).
         colors = TopAppBarDefaults.topAppBarColors(
             containerColor = MaterialTheme.colorScheme.surface,
-            scrolledContainerColor = MaterialTheme.colorScheme.surface,
+            scrolledContainerColor = MaterialTheme.colorScheme.surfaceContainer,
         ),
+        scrollBehavior = scrollBehavior,
     )
 }

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

@@ -1,64 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.agenda
-
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.Dp
-import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
-import de.jeanlucmakiola.calendula.ui.common.ScaledViewPreview
-import de.jeanlucmakiola.calendula.ui.common.sampleAgendaEvents
-import kotlinx.datetime.DateTimeUnit
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.plus
-import kotlinx.datetime.toLocalDateTime
-import kotlin.time.Clock
-
-/** How far ahead the agenda preview's stand-in window runs. */
-private const val PREVIEW_WINDOW_DAYS = 14
-
-/**
- * A live, scaled-down Agenda view for the onboarding view chooser. Today and
- * the day headers are real; only the events are stand-ins.
- */
-@Composable
-internal fun AgendaViewPreview(
-    height: Dp,
-    modifier: Modifier = Modifier,
-) {
-    val zone = remember { TimeZone.currentSystemDefault() }
-    val today = remember(zone) { Clock.System.now().toLocalDateTime(zone).date }
-    val state = remember(today, zone) { sampleAgendaState(today, zone) }
-
-    ScaledViewPreview(height = height, modifier = modifier) {
-        AgendaContent(
-            state = state,
-            // Stand-in events are all upcoming, so the past-event preference
-            // cannot change what the preview shows — keep it at the default.
-            pastDisplay = PastEventDisplay.SHOW,
-            showToday = true,
-            onRetry = {},
-            onEventClick = {},
-            onOpenDay = {},
-            modifier = Modifier.fillMaxSize(),
-        )
-    }
-}
-
-/** Sample agenda state, grouped through the same helper the live view uses. */
-private fun sampleAgendaState(today: LocalDate, zone: TimeZone): AgendaUiState.Success {
-    val windowEnd = today.plus(PREVIEW_WINDOW_DAYS, DateTimeUnit.DAY)
-    return AgendaUiState.Success(
-        anchor = today,
-        today = today,
-        days = groupAgendaDays(today, windowEnd, sampleAgendaEvents(today, zone), zone),
-        range = AgendaRange.Custom(PREVIEW_WINDOW_DAYS),
-        rangeIsOverride = false,
-        rangeEnd = windowEnd,
-        // The range bar belongs to the screen, not the list — the preview shows
-        // the list only.
-        showRangeBar = false,
-        zone = zone,
-    )
-}

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

@@ -0,0 +1,71 @@
+package de.jeanlucmakiola.calendula.ui.calendars
+
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.VisibilityOff
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import de.jeanlucmakiola.calendula.R
+import de.jeanlucmakiola.calendula.data.calendar.CalendarVisibilityReconciler
+import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+/**
+ * The one-time notice that Calendula now follows the device's per-calendar
+ * visibility (#75), armed by `CalendarVisibilityReconciler`. The app does not
+ * switch those calendars back on — that would un-hide them everywhere else too.
+ */
+@HiltViewModel
+class CalendarVisibilityNoticeViewModel @Inject constructor(
+    private val prefs: CalendarPrefs,
+    private val reconciler: CalendarVisibilityReconciler,
+) : ViewModel() {
+
+    /**
+     * Reconcile whenever the app comes up with the calendar permission held,
+     * rather than off one grant route: a permission granted on Android's
+     * app-settings screen never reaches the permission screen's callback.
+     */
+    fun reconcile() {
+        viewModelScope.launch { reconciler.run() }
+    }
+
+    val pending: StateFlow<Boolean> = prefs.visibilityNoticePending
+        .map { it == true }
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = false,
+        )
+
+    fun dismiss() {
+        viewModelScope.launch { prefs.setVisibilityNoticePending(false) }
+    }
+}
+
+/** Plain informational dialog — one acknowledgement, nothing to decide. */
+@Composable
+fun CalendarVisibilityNoticeDialog(onDismiss: () -> Unit) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        icon = { Icon(Icons.Default.VisibilityOff, contentDescription = null) },
+        title = { Text(stringResource(R.string.calendars_visibility_notice_title)) },
+        text = { Text(stringResource(R.string.calendars_visibility_notice_message)) },
+        confirmButton = {
+            TextButton(onClick = onDismiss) {
+                Text(stringResource(R.string.dialog_ok))
+            }
+        },
+    )
+}

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

@@ -1,40 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.ui.unit.dp
-
-/**
- * Trailing-edge and title spacing shared by the four calendar app bars (#165).
- *
- * Only the trailing edge and the title's start are shared; the leading edge and
- * the gaps between the action icons stay on M3's defaults, which derive both
- * from the icon buttons' width.
- */
-object AppBarSpacing {
-
-    /** Side inset shared by the bars' trailing edge and the month grid. */
-    val Inset = 8.dp
-
-    /**
-     * Start inset on the title, taking it clear of the navigation icon M3 places
-     * it flush against. Real padding rather than a negative offset, which would
-     * swallow taps meant for the menu button.
-     */
-    val TitleInset = 8.dp
-
-    /** M3's own padding around the actions row. */
-    internal val BarPadding = 4.dp
-
-    private val IconButtonSize = 48.dp
-
-    private val IconSize = 24.dp
-
-    /**
-     * End padding for a container-backed control that ends the bar, measured to
-     * its background. Coerced because [androidx.compose.foundation.layout.padding]
-     * throws on a negative value.
-     */
-    val ContainerTrailingInset = (Inset - BarPadding).coerceAtLeast(0.dp)
-
-    /** Screen edge to the glyph of an icon button that ends the bar. */
-    val IconTrailingInset = BarPadding + (IconButtonSize - IconSize) / 2
-}

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

@@ -4,201 +4,30 @@ import androidx.compose.animation.Crossfade
 import androidx.compose.animation.core.FiniteAnimationSpec
 import androidx.compose.animation.core.animateDpAsState
 import androidx.compose.animation.core.snap
-import androidx.compose.foundation.layout.Column
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.Immutable
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.platform.LocalLayoutDirection
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.rememberTextMeasurer
-import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.unit.Constraints
-import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.floret.identity.rememberReduceMotion
 
-/** Gap a timed block leaves to its neighbours in the column. */
-val BLOCK_OUTER_INSET = 1.dp
-
-/** Padding between a timed block's edge and its text. */
-val BLOCK_TEXT_PADDING = 4.dp
-
-/** The same, above and below — what a block's height has to pay before any text. */
-val BLOCK_TEXT_INSET = 2.dp
-
-/** Most lines a time label may wrap over before it is worth more than a title line. */
-const val MAX_TIME_LINES = 2
-
-/**
- * Lines [text] needs to render whole at [textWidth], capped at [max].
- *
- * Lets a block hand out its height by what the text actually asks for rather
- * than by what would fit: a title that wants one line should not be given three
- * that the time label could have used, and a week column is narrower than a
- * "09:30–11:00" range so the range should not be assumed to want one.
- */
-@Composable
-fun blockTextLines(text: String, style: TextStyle, textWidth: Dp, max: Int): Int {
-    val measurer = rememberTextMeasurer()
-    val widthPx = with(LocalDensity.current) { textWidth.roundToPx() }
-    return remember(text, style, widthPx, max, measurer) {
-        if (max <= 1 || widthPx <= 0) {
-            1
-        } else {
-            measurer.measure(
-                text = text,
-                style = style,
-                constraints = Constraints(maxWidth = widthPx),
-            ).lineCount.coerceIn(1, max)
-        }
-    }
-}
-
-/**
- * Lines the time label may take at [textWidth], out of the [spare] height left
- * once the title and the label's own first line are paid for.
- *
- * A week column is narrower than a "09:30–11:00" range, so the label takes a
- * second line rather than lose its end — but only out of a line the title
- * measured itself as not needing, never one it would have filled.
- */
-@Composable
-fun blockTimeLines(label: String, textWidth: Dp, spare: Dp): Int {
-    val timeLineHeight = with(LocalDensity.current) {
-        MaterialTheme.typography.labelSmall.lineHeight.toDp()
-    }
-    return if (spare >= timeLineHeight) {
-        blockTextLines(
-            text = label,
-            // The style it is drawn in, or the budget measures a line the label
-            // never uses (#219).
-            style = MaterialTheme.typography.labelSmall.asEventTime(),
-            textWidth = textWidth,
-            max = MAX_TIME_LINES,
-        )
-    } else {
-        1
-    }
-}
-
-/**
- * A timed block's title, over at most [maxLines].
- *
- * Wrapping and clipping pull against each other, which is why #164 left the
- * ellipsis on multi-line chips: with `softWrap` on, the last visible line ends
- * at a word boundary, so "Farmers Market" in a six-character column would clip
- * to "Farmer" / "s" where the ellipsis at least reached "s Mar…".
- *
- * So the block wraps every line but the last through one `Text` and hands the
- * remainder to a second that clips mid-glyph the way a single-line chip does.
- * Every line is then full and none of them spends two of its few characters on
- * a "…". RTL keeps the ellipsis for the reason [eventTitleOverflowFor] gives.
- */
-@Composable
-fun BlockTitle(
-    title: String,
-    maxLines: Int,
-    textWidth: Dp,
-    color: Color,
-    modifier: Modifier = Modifier,
-    textDecoration: TextDecoration? = null,
-    fontWeight: FontWeight? = null,
-) {
-    // Folded into the style rather than passed to the Text, so the wrap measured
-    // below is the wrap that gets drawn.
-    val style = MaterialTheme.typography.labelMedium
-        .let { if (fontWeight == null) it else it.copy(fontWeight = fontWeight) }
-    val rtl = LocalLayoutDirection.current == LayoutDirection.Rtl
-    val measurer = rememberTextMeasurer()
-    val widthPx = with(LocalDensity.current) { textWidth.roundToPx() }
-    // Where the wrapped lines stop and the clipped tail starts — null when the
-    // title fits, and nothing needs splitting.
-    val headEnd = remember(title, style, widthPx, maxLines, rtl, measurer) {
-        if (rtl || maxLines < 2 || widthPx <= 0) {
-            null
-        } else {
-            val layout = measurer.measure(
-                text = title,
-                style = style,
-                constraints = Constraints(maxWidth = widthPx),
-            )
-            if (layout.lineCount <= maxLines) {
-                null
-            } else {
-                layout.getLineEnd(maxLines - 2, visibleEnd = true)
-            }
-        }
-    }
-    if (headEnd == null) {
-        val overflow = eventTitleOverflow(singleLine = maxLines == 1)
-        Text(
-            text = title,
-            modifier = modifier,
-            style = style,
-            maxLines = maxLines,
-            overflow = overflow.overflow,
-            softWrap = overflow.softWrap,
-            color = color,
-            textDecoration = textDecoration,
-        )
-    } else {
-        val tail = eventTitleOverflow(singleLine = true)
-        Column(modifier = modifier) {
-            Text(
-                text = title.substring(0, headEnd),
-                style = style,
-                maxLines = maxLines - 1,
-                overflow = TextOverflow.Clip,
-                softWrap = true,
-                color = color,
-                textDecoration = textDecoration,
-            )
-            Text(
-                text = title.substring(headEnd).trimStart(),
-                style = style,
-                maxLines = 1,
-                overflow = tail.overflow,
-                softWrap = tail.softWrap,
-                color = color,
-                textDecoration = textDecoration,
-            )
-        }
-    }
-}
-
 /**
  * A timed block's own time label, crossfaded rather than replaced — the block
  * slides to its new slot, so the label shouldn't change in a single frame.
- *
- * Overflows like a title does (#164): the "…" costs two characters of a string
- * that is nothing but characters, so the label clips at the block's edge
- * instead. [maxLines] lets a narrow column spend spare height on the range
- * rather than losing its end.
  */
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun BlockTimeLabel(
-    label: String,
-    color: Color,
-    modifier: Modifier = Modifier,
-    maxLines: Int = 1,
-) {
+fun BlockTimeLabel(label: String, color: Color, modifier: Modifier = Modifier) {
     val spec: FiniteAnimationSpec<Float> = if (rememberReduceMotion()) {
         snap()
     } else {
         MaterialTheme.motionScheme.fastEffectsSpec()
     }
-    val overflow = eventTitleOverflow(singleLine = maxLines == 1)
     Crossfade(
         targetState = label,
         animationSpec = spec,
@@ -207,11 +36,9 @@ fun BlockTimeLabel(
     ) { text ->
         Text(
             text = text,
-            // Regular weight against the title's medium above it (#219).
-            style = MaterialTheme.typography.labelSmall.asEventTime(),
-            maxLines = maxLines,
-            overflow = overflow.overflow,
-            softWrap = overflow.softWrap,
+            style = MaterialTheme.typography.labelSmall,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
             color = color,
         )
     }

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

@@ -1,7 +1,6 @@
 package de.jeanlucmakiola.calendula.ui.common
 
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.BoxWithConstraints
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.padding
@@ -13,7 +12,6 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
@@ -21,8 +19,6 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.Role
-import androidx.compose.ui.text.rememberTextMeasurer
-import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 import kotlinx.datetime.LocalDate
@@ -35,9 +31,10 @@ import kotlinx.datetime.LocalDate
  * [currentDate] seeds the picker with whatever the bar is currently naming (the
  * visible day, week start or month anchor).
  *
- * [shortTitle] replaces [title] when the full one does not fit the width the app
- * bar hands the title slot (#165). Either way the line clamps to one and
- * ellipsises, so pass a [shortTitle] wherever there is something left to drop.
+ * The row keeps its own 8.dp inset rather than shifting back onto the app bar's
+ * start alignment: M3 places the title flush against the navigation icon's
+ * trailing edge, and the title is hit-tested on top of it, so a negative offset
+ * would swallow taps meant for the menu button.
  */
 @Composable
 fun CalendarTitleButton(
@@ -45,7 +42,6 @@ fun CalendarTitleButton(
     currentDate: LocalDate,
     onJumpToDate: (LocalDate) -> Unit,
     modifier: Modifier = Modifier,
-    shortTitle: String = title,
 ) {
     var showDatePicker by rememberSaveable { mutableStateOf(false) }
 
@@ -57,27 +53,14 @@ fun CalendarTitleButton(
                 onClickLabel = stringResource(R.string.drawer_jump_to_date),
                 role = Role.Button,
             ) { showDatePicker = true }
-            .padding(horizontal = AppBarSpacing.TitleInset),
+            .padding(horizontal = 8.dp),
         verticalAlignment = Alignment.CenterVertically,
     ) {
-        val style = MaterialTheme.typography.titleLarge
-        BoxWithConstraints(modifier = Modifier.weight(1f, fill = false)) {
-            val measurer = rememberTextMeasurer()
-            val shown = remember(title, shortTitle, style, constraints.maxWidth, measurer) {
-                titleFor(
-                    title = title,
-                    shortTitle = shortTitle,
-                    titleWidth = measurer.measure(title, style).size.width,
-                    availableWidth = constraints.maxWidth,
-                )
-            }
-            Text(
-                text = shown,
-                style = style,
-                maxLines = 1,
-                overflow = TextOverflow.Ellipsis,
-            )
-        }
+        Text(
+            text = title,
+            style = MaterialTheme.typography.titleLarge,
+            modifier = Modifier.weight(1f, fill = false),
+        )
         Icon(
             imageVector = Icons.Default.ArrowDropDown,
             contentDescription = null,
@@ -96,11 +79,3 @@ fun CalendarTitleButton(
         )
     }
 }
-
-/** Falls back to [shortTitle] when [title] is wider than [availableWidth] (#165). */
-internal fun titleFor(
-    title: String,
-    shortTitle: String,
-    titleWidth: Int,
-    availableWidth: Int,
-): String = if (titleWidth <= availableWidth) title else shortTitle

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

@@ -57,8 +57,7 @@ fun CalendarView.next(available: List<CalendarView> = IMPLEMENTED_VIEWS): Calend
  * implemented view — the settings screen reorders the whole set — while [cycle]
  * is the subset the pill actually steps through, in [order]. The navigation
  * drawer keeps its own separate order and always lists every view, so a view
- * disabled here stays reachable there — including when [cycle] is emptied and
- * the pill disappears altogether.
+ * disabled here stays reachable there.
  */
 data class QuickSwitchConfig(
     val order: List<CalendarView>,
@@ -68,15 +67,14 @@ data class QuickSwitchConfig(
     val cycle: List<CalendarView> get() = order.filter { it in enabled }
 
     companion object {
-        /**
-         * Fewest views that keep the switch meaningful. A single target is not a
-         * switch, so below this the pill is hidden rather than special-cased (#150);
-         * the drawer still reaches every view.
-         */
-        const val MIN_CYCLE = 2
-
         /** All views, in default order, all enabled. */
         val Default = QuickSwitchConfig(IMPLEMENTED_VIEWS, IMPLEMENTED_VIEWS.toSet())
+
+        /**
+         * Fewest views that keep the switch meaningful — a "switch" needs at
+         * least two targets, so the settings screen blocks disabling below this.
+         */
+        const val MIN_ENABLED = 2
     }
 }
 

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

@@ -1,104 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import android.content.ClipData
-import android.os.Build
-import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.material3.SnackbarHostState
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.ClipEntry
-import androidx.compose.ui.platform.LocalClipboard
-import androidx.compose.ui.platform.LocalHapticFeedback
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.semantics.onLongClick
-import androidx.compose.ui.semantics.semantics
-import de.jeanlucmakiola.calendula.R
-import kotlinx.coroutines.launch
-
-/** Puts one labelled field on the clipboard. */
-fun interface FieldCopier {
-    operator fun invoke(label: String, text: String)
-}
-
-/**
- * A [FieldCopier] that confirms the copy only where the system doesn't (#195).
- *
- * Android 13 raises its own clipboard chip for every copy, so a snackbar on top
- * of it reads as the app having done the job twice. A failure is always worth a
- * word, though: the clipboard can refuse a very long description outright.
- */
-@Composable
-fun rememberFieldCopier(snackbarHostState: SnackbarHostState): FieldCopier {
-    val clipboard = LocalClipboard.current
-    val scope = rememberCoroutineScope()
-    val confirmation = stringResource(R.string.field_copied)
-    val failure = stringResource(R.string.field_copy_failed)
-    return remember(clipboard, scope, snackbarHostState, confirmation, failure) {
-        FieldCopier { label, text ->
-            scope.launch {
-                val message = runCatching {
-                    clipboard.setClipEntry(ClipEntry(ClipData.newPlainText(label, text)))
-                }.fold(
-                    onSuccess = {
-                        confirmation.takeIf {
-                            Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU
-                        }
-                    },
-                    onFailure = { failure },
-                )
-                if (message != null) {
-                    // Copying twice in a row shouldn't queue two four-second
-                    // confirmations — the newest one wins.
-                    snackbarHostState.currentSnackbarData?.dismiss()
-                    snackbarHostState.showSnackbar(message)
-                }
-            }
-        }
-    }
-}
-
-/**
- * Long-press to copy [text] whole, filed on the clipboard under [label].
- *
- * [onTap] carries a field's existing tap action through; a field without one
- * stays unclickable rather than growing a ripple that leads nowhere, and gets
- * its long press announced through semantics instead. That branch merges the
- * node it sits on, so a screen reader lands on the field itself and finds the
- * action there — a bare container is never focused.
- */
-@Composable
-fun Modifier.copyOnLongPress(
-    label: String,
-    text: String,
-    copy: FieldCopier,
-    onTap: (() -> Unit)? = null,
-): Modifier {
-    val actionLabel = stringResource(R.string.field_copy_action)
-    return if (onTap != null) {
-        combinedClickable(
-            onClick = onTap,
-            onLongClickLabel = actionLabel,
-            onLongClick = { copy(label, text) },
-        )
-    } else {
-        val haptics = LocalHapticFeedback.current
-        pointerInput(label, text, copy) {
-            detectTapGestures(
-                onLongPress = {
-                    haptics.performHapticFeedback(HapticFeedbackType.LongPress)
-                    copy(label, text)
-                },
-            )
-        }.semantics(mergeDescendants = true) {
-            onLongClick(actionLabel) {
-                copy(label, text)
-                true
-            }
-        }
-    }
-}

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

@@ -1,35 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.ui.unit.dp
-
-/** The corner radius every event chip keeps on each edge the event doesn't cross. */
-val EVENT_CHIP_CORNER = 4.dp
-
-/** An event chip that is cut on no edge — an all-day bar, a floating copy. */
-val EventChipShape = RoundedCornerShape(EVENT_CHIP_CORNER)
-
-/**
- * A timed block's corners: square on whichever edge the event runs past, so a
- * cut edge reads as "this carries on" rather than as the event's own end. The
- * vertical counterpart of [monthBarShape].
- */
-fun timedBlockShape(continuesBefore: Boolean, continuesAfter: Boolean): RoundedCornerShape =
-    RoundedCornerShape(
-        topStart = if (continuesBefore) 0.dp else EVENT_CHIP_CORNER,
-        topEnd = if (continuesBefore) 0.dp else EVENT_CHIP_CORNER,
-        bottomStart = if (continuesAfter) 0.dp else EVENT_CHIP_CORNER,
-        bottomEnd = if (continuesAfter) 0.dp else EVENT_CHIP_CORNER,
-    )
-
-/**
- * A month/all-day bar's corners: square on whichever side the event runs past
- * the row it is drawn in.
- */
-fun monthBarShape(continuesLeft: Boolean, continuesRight: Boolean): RoundedCornerShape =
-    RoundedCornerShape(
-        topStart = if (continuesLeft) 0.dp else EVENT_CHIP_CORNER,
-        bottomStart = if (continuesLeft) 0.dp else EVENT_CHIP_CORNER,
-        topEnd = if (continuesRight) 0.dp else EVENT_CHIP_CORNER,
-        bottomEnd = if (continuesRight) 0.dp else EVENT_CHIP_CORNER,
-    )

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

@@ -29,18 +29,8 @@ class EventMoveScope(
      * the repository writes whatever it is handed — so this gate is load-bearing.
      */
     val movableCalendarIds: Set<Long>,
-    /**
-     * Whether the *gesture* is on (#173). Off gates the drag alone: [edit] and the
-     * TalkBack action below stay, since invoking a menu item can't cause the
-     * accidental drags the setting exists to stop.
-     */
-    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.
-     */
-    val move: (MoveRequest) -> Unit,
+    /** False when the drop was refused outright, so nothing will be written. */
+    val move: (MoveRequest) -> Boolean,
     /**
      * 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
@@ -49,12 +39,6 @@ class EventMoveScope(
     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>,
     /** Open an event in the edit form — the pointer-free route to the same change. */
     val edit: (EventInstance) -> Unit,
 ) {
@@ -67,8 +51,6 @@ private val NEVER_IN_FLIGHT = MutableStateFlow(false)
 
 private val NEVER_UNDONE = MutableStateFlow(0)
 
-private val NEVER_ABANDONED = MutableStateFlow(0)
-
 /**
  * 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.
@@ -79,17 +61,6 @@ fun moveInFlight(): Boolean {
     return flow.collectAsStateWithLifecycle().value
 }
 
-/**
- * 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.
- */
-@Composable
-fun abandonedMoves(): Int {
-    val flow = LocalEventMove.current?.abandoned ?: NEVER_ABANDONED
-    return flow.collectAsStateWithLifecycle().value
-}
-
 /**
  * Runs [onUndo] when an undo write begins, and never for one that began before
  * this composable came on screen.
@@ -120,17 +91,6 @@ fun ghostAlpha(lifted: Boolean): Float = animateFloatAsState(
     label = "ghost-alpha",
 ).value
 
-/**
- * Whether [event] can be picked up and dragged — its calendar allows moving and
- * the gesture is switched on. Not the same question as [eventMoveAction], which
- * survives the setting.
- */
-@Composable
-fun eventDragAllowed(event: EventInstance): Boolean {
-    val move = LocalEventMove.current ?: return false
-    return move.dragEnabled && move.allows(event)
-}
-
 /**
  * A TalkBack action that opens [event] in the edit form, so rescheduling isn't
  * pointer-only. Null when this event can't be moved.

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

@@ -1,165 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.foundation.background
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.Immutable
-import androidx.compose.runtime.compositionLocalOf
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.draw.drawBehind
-import androidx.compose.ui.geometry.CornerRadius
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.geometry.Size
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.Shape
-import androidx.compose.ui.graphics.drawscope.DrawScope
-import androidx.compose.ui.graphics.drawscope.Stroke
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextDecoration
-import androidx.compose.ui.unit.LayoutDirection
-import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.domain.EventResponse
-import de.jeanlucmakiola.calendula.domain.isDeclined
-
-/** Stroke an invitation you have not answered is outlined with. */
-val EVENT_OUTLINE_WIDTH = 1.dp
-
-/**
- * The surface an event chip is drawn on, which an outlined one fills itself with
- * so it reads as the background showing through rather than as a pale block laid
- * over it. Defaults to the `surfaceContainer` the month cells and the timeline
- * columns carry; the all-day strips sit on plain `surface` and a floating drag
- * copy wants a lifted one, so both provide their own.
- */
-val LocalChipGround = compositionLocalOf { Color.Unspecified }
-
-/**
- * Which edges of a chip the event runs past. Those edges are squared by
- * [monthBarShape] / [timedBlockShape] so the cut reads as "this carries on", and
- * an outline has to leave them open for the same reason — a stroke all the way
- * round would close a bar carried across a week boundary into two boxes.
- */
-@Immutable
-data class ChipCuts(
-    val start: Boolean = false,
-    val end: Boolean = false,
-    val top: Boolean = false,
-    val bottom: Boolean = false,
-)
-
-/** [ChipCuts] for a month or all-day bar, which is only ever cut left and right. */
-fun monthBarCuts(continuesLeft: Boolean, continuesRight: Boolean): ChipCuts =
-    ChipCuts(start = continuesLeft, end = continuesRight)
-
-/** [ChipCuts] for a timed block, which is only ever cut top and bottom. */
-fun timedBlockCuts(continuesBefore: Boolean, continuesAfter: Boolean): ChipCuts =
-    ChipCuts(top = continuesBefore, bottom = continuesAfter)
-
-/**
- * How one event's chip or block is painted, which turns on your answer to its
- * invitation (#180, #230).
- *
- * An invitation you have not answered is drawn as an outline: its calendar's
- * colour on the border and on the title, over the surface the chip sits on. So
- * it holds a chip's shape and a chip's weight without claiming the filled
- * container an event you are going to gets. A declined one keeps the fill and
- * its strike-through.
- */
-@Immutable
-data class EventPaint(
-    val fill: Color,
-    /** Null for a filled chip; the border colour when the chip is outlined. */
-    val outline: Color?,
-    val titleInk: Color,
-    val secondaryInk: Color,
-    val decoration: TextDecoration?,
-    /**
-     * Weight to set the title at, or null to keep whatever the surface's own
-     * text style carries.
-     */
-    val titleWeight: FontWeight?,
-)
-
-/** [EventPaint] for [event] on a [dark] scheme. */
-@Composable
-fun eventPaint(event: EventInstance, dark: Boolean): EventPaint {
-    val soften = LocalSoftenColors.current
-    if (event.response == EventResponse.Invited) {
-        // Harmonised even when the setting is off. Raw mode exists so a filled
-        // container matches what the sync source paints, and an outlined chip
-        // has no container — what it has is coloured *text*, which needs the
-        // lightness pinned against the surface or a pale calendar goes
-        // unreadable (eventTone returns the raw colour verbatim otherwise).
-        val accent = eventAccent(event.color, dark, soften = true)
-        val ground = LocalChipGround.current.takeIf { it != Color.Unspecified }
-            ?: MaterialTheme.colorScheme.surfaceContainer
-        return EventPaint(
-            fill = ground,
-            outline = accent,
-            titleInk = accent,
-            // A neutral token rather than the accent faded: the time is the
-            // smallest text on the chip, and an alpha step off an accent that is
-            // itself only just clear of the surface is where legibility goes.
-            secondaryInk = MaterialTheme.colorScheme.onSurfaceVariant,
-            decoration = null,
-            // The label styles' medium weight is set to carry ink on a filled
-            // container. In a calendar colour on a plain one it thickens into
-            // something harder to read, so step it back to regular.
-            titleWeight = FontWeight.Normal,
-        )
-    }
-    val fill = eventFill(event.color, dark, soften)
-    return EventPaint(
-        fill = fill,
-        outline = null,
-        titleInk = eventInk(fill, alpha = TITLE_INK_ALPHA),
-        secondaryInk = eventInk(fill, alpha = SECONDARY_INK_ALPHA),
-        decoration = declinedDecoration(event.isDeclined),
-        titleWeight = null,
-    )
-}
-
-/** [this] set at the weight [paint] asks a title for, for measuring and for drawing alike. */
-fun TextStyle.withTitleWeight(paint: EventPaint): TextStyle =
-    if (paint.titleWeight == null) this else copy(fontWeight = paint.titleWeight)
-
-/** Seats a chip or block on [shape]: its fill, plus the border when it has one. */
-fun Modifier.eventSurface(
-    paint: EventPaint,
-    shape: Shape,
-    cuts: ChipCuts = ChipCuts(),
-): Modifier {
-    val filled = background(paint.fill, shape)
-    val outline = paint.outline ?: return filled
-    return filled.clip(shape).drawBehind { drawChipOutline(outline, cuts) }
-}
-
-/**
- * The border, stroked as one round-rect whose edges run past the chip on every
- * side the event continues over. Clipped to the chip's own shape, so those
- * strokes — and the corners that would have turned back in — fall outside and
- * the edge stays open.
- */
-private fun DrawScope.drawChipOutline(color: Color, cuts: ChipCuts) {
-    val stroke = EVENT_OUTLINE_WIDTH.toPx()
-    val radius = EVENT_CHIP_CORNER.toPx()
-    // Far enough out that the corner arc clears the clip too, not just the edge.
-    val bleed = radius + stroke
-    val rtl = layoutDirection == LayoutDirection.Rtl
-    val leftCut = if (rtl) cuts.end else cuts.start
-    val rightCut = if (rtl) cuts.start else cuts.end
-    val left = if (leftCut) -bleed else stroke / 2f
-    val top = if (cuts.top) -bleed else stroke / 2f
-    val right = if (rightCut) size.width + bleed else size.width - stroke / 2f
-    val bottom = if (cuts.bottom) size.height + bleed else size.height - stroke / 2f
-    drawRoundRect(
-        color = color,
-        topLeft = Offset(left, top),
-        size = Size(right - left, bottom - top),
-        cornerRadius = CornerRadius(radius),
-        style = Stroke(width = stroke),
-    )
-}

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

@@ -1,77 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.text.AnnotatedString
-import androidx.compose.ui.text.SpanStyle
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.buildAnnotatedString
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.rememberTextMeasurer
-import androidx.compose.ui.text.withStyle
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.sp
-import de.jeanlucmakiola.floret.locale.currentLocale
-
-private val TIME_WEIGHT = FontWeight.Normal
-private val TIME_TRACKING = 0.sp
-private val TIME_SPAN = SpanStyle(fontWeight = TIME_WEIGHT, letterSpacing = TIME_TRACKING)
-
-/**
- * Ink for an event's title, against [SECONDARY_INK_ALPHA] for the time beside or
- * beneath it. Full, so the pair separates on a typeface with no medium weight to
- * step down from — Atkinson Hyperlegible and JetBrains Mono ship regular and bold
- * only, and a user's imported font a single face, so [asEventTime] is a no-op
- * there and the ink is the whole difference (#219).
- */
-const val TITLE_INK_ALPHA = 1f
-
-/**
- * [this] set as an event's time rather than as its title: the label styles' medium
- * weight and 0.5sp of tracking left a time reading as part of the title next to it.
- */
-fun TextStyle.asEventTime(): TextStyle =
-    copy(fontWeight = TIME_WEIGHT, letterSpacing = TIME_TRACKING)
-
-/** Text reading [time], set apart in [timeInk], before [title]. */
-fun inlineTimeLabel(time: String?, title: String, timeInk: Color): AnnotatedString =
-    buildAnnotatedString {
-        if (time != null) {
-            withStyle(TIME_SPAN.copy(color = timeInk)) { append(time) }
-            append(" ")
-        }
-        append(title)
-    }
-
-/**
- * The characters of title that have to survive a time prefix for it to be worth
- * its place — lowercase Latin of average advance, priced at the surface's own
- * text style rather than guessed in dp.
- */
-private const val TITLE_SAMPLE = "notepad"
-
-/** The widest wall-clock time in either convention: two-digit hour, and a meridiem in 12-hour. */
-private const val SAMPLE_HOUR = 12
-private const val SAMPLE_MINUTE = 45
-
-/**
- * The narrowest run of [style] text that may carry a time in front of a title:
- * wide enough for the widest time in the current convention plus [TITLE_SAMPLE].
- *
- * Measured rather than a device breakpoint, so it follows the font scale, the
- * 12/24-hour setting, the locale's own time format and whatever else has
- * already been taken off the width.
- */
-@Composable
-fun rememberInlineTimeWidth(style: TextStyle): Dp {
-    val measurer = rememberTextMeasurer()
-    val density = LocalDensity.current
-    val locale = currentLocale()
-    val sample = formatTimeOfDay(SAMPLE_HOUR, SAMPLE_MINUTE, LocalUse24HourFormat.current, locale)
-    return remember(sample, style, density, measurer) {
-        val label = inlineTimeLabel(sample, TITLE_SAMPLE, Color.Unspecified)
-        with(density) { measurer.measure(label, style).size.width.toDp() }
-    }
-}

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

@@ -1,39 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.platform.LocalLayoutDirection
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.unit.LayoutDirection
-
-/** How an event chip's title should overflow: what to pass to `Text`. */
-data class EventTitleOverflow(val overflow: TextOverflow, val softWrap: Boolean)
-
-/**
- * Overflow for an event chip's title (#164). Chips are narrow enough that the
- * "…" costs a couple of readable characters, so the title runs to the chip's
- * edge and clips mid-glyph instead.
- *
- * Two cases keep the ellipsis:
- *
- * - **[rtl].** With `softWrap` off Compose lays the line out at its full
- *   intrinsic width and clips to the node's left edge, which in RTL is the *end*
- *   of the string — an Arabic title would lose its beginning. The ellipsis
- *   truncates at the logical end in both directions.
- * - **More than one line** ([singleLine] false). Wrapping needs `softWrap` on,
- *   and clipping with it on breaks the last line at the last whole word — less
- *   title than the ellipsis showed, not more.
- */
-fun eventTitleOverflowFor(rtl: Boolean, singleLine: Boolean): EventTitleOverflow =
-    if (rtl || !singleLine) {
-        EventTitleOverflow(TextOverflow.Ellipsis, softWrap = true)
-    } else {
-        EventTitleOverflow(TextOverflow.Clip, softWrap = false)
-    }
-
-/** [eventTitleOverflowFor] against the current layout direction. */
-@Composable
-fun eventTitleOverflow(singleLine: Boolean = true): EventTitleOverflow =
-    eventTitleOverflowFor(
-        rtl = LocalLayoutDirection.current == LayoutDirection.Rtl,
-        singleLine = singleLine,
-    )

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

@@ -36,14 +36,6 @@ val GUTTER_WIDTH = 48.dp
  */
 val GUTTER_CONTENT_START_INSET = 8.dp
 
-/**
- * End inset for everything that lines up with the day columns — the week's day
- * header, the all-day strip and the timeline itself. Without it the last column
- * runs flush into the screen edge while the gutter gives the other side room
- * (#192); 8dp mirrors [GUTTER_CONTENT_START_INSET].
- */
-val TIMELINE_CONTENT_END_INSET = 8.dp
-
 private val BADGE_HEIGHT = 20.dp
 
 /** How far the fixed hour labels recede while a block is being dragged. */

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

@@ -1,10 +1,6 @@
 package de.jeanlucmakiola.calendula.ui.common
 
 import androidx.compose.runtime.compositionLocalOf
-import androidx.compose.ui.text.AnnotatedString
-import androidx.compose.ui.text.SpanStyle
-import androidx.compose.ui.text.buildAnnotatedString
-import androidx.compose.ui.text.style.TextDecoration
 import kotlin.time.Instant
 
 /**
@@ -18,30 +14,3 @@ val LocalDimCutoff = compositionLocalOf<Instant?> { null }
 
 /** Opacity applied to a completed/past event chip when it is dimmed. */
 const val EventDimAlpha = 0.4f
-
-/**
- * How a declined invitation's title is struck through (#180) — the mark every
- * surface uses to say "you answered no", chosen over hiding the event because it
- * is still something the organiser expects you at. Null for everything else, so
- * it drops straight into a `Text`'s `textDecoration`.
- */
-fun declinedDecoration(isDeclined: Boolean): TextDecoration? =
-    if (isDeclined) TextDecoration.LineThrough else null
-
-/** [declinedDecoration] for the rows that take styled text rather than a `String`. */
-fun declinedTitle(title: String, isDeclined: Boolean): AnnotatedString = if (isDeclined) {
-    AnnotatedString(title, SpanStyle(textDecoration = TextDecoration.LineThrough))
-} else {
-    AnnotatedString(title)
-}
-
-/** [declinedTitle] over already-styled text, e.g. a search hit's marked runs. */
-fun declinedTitle(title: AnnotatedString, isDeclined: Boolean): AnnotatedString =
-    if (!isDeclined) {
-        title
-    } else {
-        buildAnnotatedString {
-            append(title)
-            addStyle(SpanStyle(textDecoration = TextDecoration.LineThrough), 0, title.length)
-        }
-    }

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

@@ -1,169 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import de.jeanlucmakiola.calendula.domain.EventInstance
-import kotlinx.datetime.DateTimeUnit
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.atTime
-import kotlinx.datetime.plus
-import kotlinx.datetime.toInstant
-import kotlin.time.Duration.Companion.minutes
-import kotlin.time.Instant
-
-/**
- * Stand-in events for the view previews. A preview has no business querying the
- * provider for a thumbnail, so every chooser renders the same invented week.
- *
- * Colours are raw ARGB on purpose: that is what the provider hands out for an
- * event, so a theme token here would misrepresent what the views actually draw.
- */
-private val SAMPLE_COLORS = listOf(
-    0xFF3F7BD4.toInt(),
-    0xFFCE5B4C.toInt(),
-    0xFF4E9A6A.toInt(),
-    0xFF8A63C7.toInt(),
-)
-
-private val SAMPLE_TITLES = listOf(
-    "Standup",
-    "Lunch",
-    "Review",
-    "Gym",
-    "Call",
-    "Workshop",
-    "Dentist",
-    "Trip",
-)
-
-/** Hands out [EventInstance]s with running ids and cycling sample titles/colours. */
-private class SampleEvents(private val zone: TimeZone) {
-    private var id = 0L
-
-    fun timed(
-        day: LocalDate,
-        hour: Int,
-        minute: Int = 0,
-        lengthMinutes: Int,
-        colorIndex: Int,
-    ): EventInstance {
-        val start = day.atTime(hour, minute).toInstant(zone)
-        return build(
-            start = start,
-            end = start + lengthMinutes.minutes,
-            isAllDay = false,
-            colorIndex = colorIndex,
-        )
-    }
-
-    fun allDay(from: LocalDate, days: Int, colorIndex: Int): EventInstance = build(
-        // All-day events sit at UTC midnights with an exclusive end.
-        start = from.atTime(0, 0).toInstant(TimeZone.UTC),
-        end = from.plus(days, DateTimeUnit.DAY).atTime(0, 0).toInstant(TimeZone.UTC),
-        isAllDay = true,
-        colorIndex = colorIndex,
-    )
-
-    private fun build(
-        start: Instant,
-        end: Instant,
-        isAllDay: Boolean,
-        colorIndex: Int,
-    ): EventInstance {
-        val next = ++id
-        return EventInstance(
-            instanceId = next,
-            eventId = next,
-            calendarId = 1L,
-            title = SAMPLE_TITLES[(next.toInt() - 1) % SAMPLE_TITLES.size],
-            start = start,
-            end = end,
-            isAllDay = isAllDay,
-            color = SAMPLE_COLORS[colorIndex % SAMPLE_COLORS.size],
-            location = null,
-        )
-    }
-}
-
-/**
- * A month's worth of stand-ins, spread so most weeks carry something, with one
- * multi-day bar bridging cells and a busy today for the split pane.
- */
-internal fun sampleMonthEvents(
-    firstOfMonth: LocalDate,
-    today: LocalDate,
-    zone: TimeZone,
-): List<EventInstance> {
-    val sample = SampleEvents(zone)
-    return buildList {
-        add(sample.allDay(firstOfMonth.plus(9, DateTimeUnit.DAY), days = 3, colorIndex = 2))
-        add(sample.timed(firstOfMonth.plus(1, DateTimeUnit.DAY), 9, lengthMinutes = 60, colorIndex = 0))
-        add(sample.timed(firstOfMonth.plus(4, DateTimeUnit.DAY), 14, lengthMinutes = 120, colorIndex = 1))
-        add(sample.timed(firstOfMonth.plus(7, DateTimeUnit.DAY), 11, lengthMinutes = 60, colorIndex = 3))
-        add(sample.timed(firstOfMonth.plus(15, DateTimeUnit.DAY), 10, lengthMinutes = 60, colorIndex = 0))
-        add(sample.timed(firstOfMonth.plus(18, DateTimeUnit.DAY), 16, lengthMinutes = 60, colorIndex = 2))
-        add(sample.timed(firstOfMonth.plus(22, DateTimeUnit.DAY), 8, lengthMinutes = 120, colorIndex = 1))
-        add(sample.timed(firstOfMonth.plus(25, DateTimeUnit.DAY), 13, lengthMinutes = 60, colorIndex = 3))
-        // Today, so the split pane's list and the grid's dots both have content.
-        add(sample.timed(today, 9, lengthMinutes = 60, colorIndex = 0))
-        add(sample.timed(today, 12, lengthMinutes = 60, colorIndex = 1))
-        add(sample.timed(today, 15, lengthMinutes = 120, colorIndex = 3))
-    }
-}
-
-/**
- * Stand-ins for a timeline preview over [days]. [anchor] — the day the preview
- * is centred on — gets the busy set, including one overlapping pair so the
- * side-by-side lane layout shows; the rest of the week is sparser. A multi-day
- * all-day bar is only added when there is more than one column to span.
- */
-internal fun sampleTimelineEvents(
-    days: List<LocalDate>,
-    anchor: LocalDate,
-    zone: TimeZone,
-): List<EventInstance> {
-    val sample = SampleEvents(zone)
-    return buildList {
-        if (days.size > 1) {
-            add(sample.allDay(days[days.size / 2], days = 2, colorIndex = 2))
-        } else {
-            add(sample.allDay(anchor, days = 1, colorIndex = 2))
-        }
-        // The anchor day: enough to fill the column, with 09:30–11:00 running
-        // under 09:00–10:00 so the overlap resolves into two lanes.
-        add(sample.timed(anchor, 9, lengthMinutes = 60, colorIndex = 0))
-        add(sample.timed(anchor, 9, minute = 30, lengthMinutes = 90, colorIndex = 1))
-        add(sample.timed(anchor, 13, lengthMinutes = 120, colorIndex = 3))
-        days.filterNot { it == anchor }.forEachIndexed { index, day ->
-            // Skip every third day so the week doesn't read as a solid block.
-            if (index % 3 == 2) return@forEachIndexed
-            add(
-                sample.timed(
-                    day = day,
-                    hour = 8 + (index * 3) % 9,
-                    lengthMinutes = if (index % 2 == 0) 60 else 90,
-                    colorIndex = index,
-                ),
-            )
-        }
-    }
-}
-
-/**
- * Stand-ins for the agenda preview: a forward-looking fortnight where the first
- * days are busy and later ones thin out, so the grouped-by-day list shows both
- * a full day and the gaps between days.
- */
-internal fun sampleAgendaEvents(today: LocalDate, zone: TimeZone): List<EventInstance> {
-    val sample = SampleEvents(zone)
-    return buildList {
-        add(sample.timed(today, 9, lengthMinutes = 60, colorIndex = 0))
-        add(sample.timed(today, 12, minute = 30, lengthMinutes = 60, colorIndex = 1))
-        add(sample.timed(today, 16, lengthMinutes = 90, colorIndex = 3))
-        val tomorrow = today.plus(1, DateTimeUnit.DAY)
-        add(sample.allDay(tomorrow, days = 2, colorIndex = 2))
-        add(sample.timed(tomorrow, 10, lengthMinutes = 120, colorIndex = 1))
-        add(sample.timed(today.plus(3, DateTimeUnit.DAY), 14, lengthMinutes = 60, colorIndex = 0))
-        add(sample.timed(today.plus(6, DateTimeUnit.DAY), 11, lengthMinutes = 60, colorIndex = 3))
-        add(sample.timed(today.plus(10, DateTimeUnit.DAY), 18, lengthMinutes = 120, colorIndex = 2))
-    }
-}

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

@@ -5,7 +5,6 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
 import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.calendula.data.calendar.MINUTES_DEFAULT
 import de.jeanlucmakiola.floret.reminders.ReminderUnit
 
 /** Common reminder lead times offered as quick picks in the form and settings. */
@@ -21,20 +20,15 @@ fun reminderUnitLabel(unit: ReminderUnit): Int = when (unit) {
 
 /**
  * Humanise a reminder lead time (minutes before the event start) into one
- * line: "Default reminder" ([MINUTES_DEFAULT]), "At time of event" (0),
- * "10 minutes before", "1 hour before", … Shared by the detail screen, the event
- * form and the default-reminder settings so the wording never drifts.
- *
- * Only the sentinel itself is the account default. Any other negative is a real
- * lead time firing *after* the start — rare, but a foreign all-day row decodes to
- * one — and naming it "Default reminder" would tell the user an alarm that does
- * go off is not ours.
+ * line: "Default reminder" (negative = the provider default), "At time of
+ * event" (0), "10 minutes before", "1 hour before", … Shared by the detail
+ * screen, the event form and the default-reminder settings so the wording
+ * never drifts.
  */
 @Composable
 fun reminderLeadTimeLabel(minutes: Int): String = when {
-    minutes == MINUTES_DEFAULT -> stringResource(R.string.reminder_default)
+    minutes < 0 -> stringResource(R.string.reminder_default)
     minutes == 0 -> stringResource(R.string.reminder_at_time)
-    minutes < 0 -> stringResource(R.string.reminder_after, durationLabel(-minutes))
     minutes % 10_080 == 0 ->
         pluralStringResource(R.plurals.reminder_weeks, minutes / 10_080, minutes / 10_080)
     minutes % 1_440 == 0 ->

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

@@ -140,17 +140,6 @@ class RescheduleViewModel @Inject constructor(
      */
     val inFlight: StateFlow<Boolean> = _inFlight.asStateFlow()
 
-    private val _abandoned = MutableStateFlow(0)
-
-    /**
-     * 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).
-     */
-    val abandoned: StateFlow<Int> = _abandoned.asStateFlow()
-
     private val _undoStarted = MutableStateFlow(0)
 
     /**
@@ -200,23 +189,15 @@ 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.
-     *
-     * 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.
+     * be written and the caller must let its held copy go now — waiting on
+     * [inFlight] would strand it until the settle timeout instead.
      */
     fun move(request: MoveRequest): Boolean {
-        if (busy || _scopePrompt.value != null) {
-            _abandoned.value += 1
-            return false
-        }
+        if (busy || _scopePrompt.value != null) return false
         busy = true
         viewModelScope.launch {
             val prepared = prepare(request)
             if (prepared == null) {
-                _abandoned.value += 1
                 busy = false
                 return@launch
             }
@@ -250,7 +231,6 @@ class RescheduleViewModel @Inject constructor(
         pending = null
         busy = false
         _scopePrompt.value = null
-        _abandoned.value += 1
     }
 
     /**
@@ -258,12 +238,6 @@ class RescheduleViewModel @Inject constructor(
      * 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.
      */
     fun undo(undo: MoveUndo): Boolean {
         if (busy) return false
@@ -282,9 +256,6 @@ 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
         }
         return true
@@ -369,7 +340,6 @@ class RescheduleViewModel @Inject constructor(
         val request = prepared.request
         if (endsBeforeItStarts(prepared, scope)) {
             _outcome.value = MoveOutcome.BlockedSeriesEnd
-            _abandoned.value += 1
             return
         }
         _outcome.value = try {
@@ -381,7 +351,6 @@ class RescheduleViewModel @Inject constructor(
                     repository.updateOccurrence(
                         request.eventId,
                         request.beginMillis,
-                        prepared.original,
                         prepared.updated,
                     )
 
@@ -406,9 +375,6 @@ 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
     }
 
     /**

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

@@ -33,6 +33,7 @@ import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.layout.positionInRoot
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.IntSize
 import androidx.compose.ui.unit.dp
@@ -43,11 +44,7 @@ import de.jeanlucmakiola.calendula.ui.week.TimedBlock
 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
-import kotlinx.datetime.plus
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
@@ -69,155 +66,17 @@ private val AUTO_SCROLL_STEP = 16.dp
 data class TimelineDrag(
     val event: EventInstance,
     val date: LocalDate,
-    /**
-     * Where the dragged *block's* top edge now sits, in minutes from [date]'s
-     * midnight. The gesture's own quantity — what snaps, what the haptics tick
-     * on, and what the drop is expressed in. Not the event's start: for the tail
-     * of an event that began the day before, the two are a clip offset apart.
-     */
     val startMin: Int,
-    /** The event's new start, from [date]'s midnight — negative if it began earlier. */
-    val eventStartMin: Int,
-    val eventSpanMin: Int,
-    /** The event as the grid would draw it, one piece per day column it covers. */
-    val pieces: List<TimelineDragPiece>,
-    /**
-     * Lines the block the finger picked up drew its title over, zero for one too
-     * short to have drawn it at all. The floating copy is that block's size, so
-     * it has to spend its height the same way or the text re-wraps under the
-     * finger and snaps back on drop (#267).
-     */
-    val titleLines: Int,
-    /**
-     * True when [pieces] is only [edgeDragSlice]'s stand-in — the event has left
-     * every column this timeline shows. A hint under the finger, not where the
-     * drop lands, so it is dropped once the gesture ends ([finish]).
-     */
-    val edgeOnly: Boolean = false,
+    val endMin: Int,
+    val topLeftInRoot: Offset,
+    val sizePx: IntSize,
 ) {
     /** What the snap haptics key off: one tick per changed slot, not per frame. */
     val slot: Pair<LocalDate, Int> get() = date to startMin
 }
 
-/**
- * One day column's share of a dragged event, ready to draw. Both halves of an
- * event crossing midnight are previewed, whichever half the finger picked up:
- * showing only the held one made the event read as growing rather than moving,
- * since the day beside it still stood at the block's old extent (#253).
- */
-data class TimelineDragPiece(
-    val topLeftInRoot: Offset,
-    val sizePx: IntSize,
-    val continuesBefore: Boolean,
-    val continuesAfter: Boolean,
-)
-
-/**
- * How a run of [spanMin] minutes beginning [eventStartMin] minutes into a day —
- * negative when it began on an earlier one — falls across day columns, as
- * offsets from that day. Every slice but the first and last is a whole day, and
- * the flags say which edges are cuts rather than the event's own ends.
- *
- * [within] bounds the day offsets that have a column to draw in, so a very long
- * event doesn't slice days no one can see.
- */
-internal fun dragSlices(
-    eventStartMin: Int,
-    spanMin: Int,
-    within: IntRange? = null,
-): List<DragSlice> {
-    val span = spanMin.coerceAtLeast(0)
-    val end = eventStartMin + span
-    val days = dragDayRange(eventStartMin, spanMin)
-    val first = days.first
-    val last = days.last
-    val from = maxOf(first, within?.first ?: first)
-    val to = minOf(last, within?.last ?: last)
-    if (from > to) return emptyList()
-    return (from..to).map { day ->
-        val dayStart = day * MINUTES_PER_DAY
-        val sliceStart = maxOf(eventStartMin - dayStart, 0)
-        val sliceEnd = minOf(end - dayStart, MINUTES_PER_DAY)
-        DragSlice(
-            dayOffset = day,
-            startMin = sliceStart,
-            spanMin = sliceEnd - sliceStart,
-            continuesBefore = day > first,
-            continuesAfter = day < last,
-        )
-    }
-}
-
-/**
- * The one piece to draw when a drag has carried the whole event clear of the
- * columns this timeline shows, so [dragSlices] has nothing to hand back — where a
- * short clipped tail lands at its [dragFloorMin]: the event then belongs to the
- * day before, which Day view has no column for, and the copy would blink out from
- * under the finger mid-gesture. Pinned to the top of the nearest visible column
- * at minimum height instead, cut at that edge, so it reads as having slid off the
- * top. Null whenever a real slice exists. The drop is unaffected either way — it
- * reads [TimelineDrag.startMin], not the pieces.
- */
-internal fun edgeDragSlice(eventStartMin: Int, spanMin: Int, within: IntRange): DragSlice? {
-    if (dragDayRange(eventStartMin, spanMin).last >= within.first) return null
-    return DragSlice(
-        dayOffset = within.first,
-        startMin = 0,
-        spanMin = 0,
-        continuesBefore = true,
-        continuesAfter = false,
-    )
-}
-
-/**
- * The day offsets a run of [spanMin] minutes beginning [eventStartMin] covers,
- * before any clipping to what a timeline shows. One rule, so [dragSlices] and
- * [edgeDragSlice] can't drift apart on where an event's days begin and end.
- */
-private fun dragDayRange(eventStartMin: Int, spanMin: Int): IntRange {
-    val end = eventStartMin + spanMin.coerceAtLeast(0)
-    val first = eventStartMin.floorDiv(MINUTES_PER_DAY)
-    // A zero-length event still has a block, on the one day it sits in.
-    return first..maxOf((end - 1).floorDiv(MINUTES_PER_DAY), first)
-}
-
-/**
- * How far above its day's midnight a block's top edge may be dragged. Zero for
- * an ordinary block, whose top edge is the event's own start. A tail clipped at
- * midnight has to go lower: its top edge *is* midnight and stays there however
- * much earlier the event moves, so pinning it at zero made dragging the second
- * half earlier a no-op (#253). It may rise until the event's end reaches one
- * snap step into this day — or by a single step, for a tail too short to afford
- * even that, which then leaves the day for the one before it.
- */
-internal fun dragFloorMin(clipOffsetMin: Int, eventSpanMin: Int): Int =
-    if (clipOffsetMin > 0) {
-        minOf(-DRAG_SNAP_MINUTES, DRAG_SNAP_MINUTES + clipOffsetMin - eventSpanMin)
-    } else {
-        0
-    }
-
-/** One day's share of a dragged event, before it is placed on screen. */
-internal data class DragSlice(
-    val dayOffset: Int,
-    val startMin: Int,
-    val spanMin: Int,
-    val continuesBefore: Boolean,
-    val continuesAfter: Boolean,
-)
-
-/**
- * Where a finished drag asks its event to go. [date]/[startMin] are where the
- * dragged *block's* top edge landed, which is the event's own start only for a
- * block that isn't clipped — see [clipOffsetMin] and [startInstant].
- */
-data class TimelineDrop(
-    val event: EventInstance,
-    val date: LocalDate,
-    val startMin: Int,
-    /** Minutes from the event's start to the dragged block's top edge. */
-    val clipOffsetMin: Int = 0,
-)
+/** Where a finished drag asks its event to go. */
+data class TimelineDrop(val event: EventInstance, val date: LocalDate, val startMin: Int)
 
 /**
  * The timeline's live geometry, republished on every layout. Plain fields rather
@@ -275,14 +134,12 @@ class TimelineDragController {
         private set
 
     /**
-     * The event row and start instant the settled drop came from. The instance id
-     * alone can't identify the source for the length of the write: the provider
-     * regenerates `Instances` rows, so a re-read carrying the *old* time can
-     * arrive under a new instance id. Matching the start instant rather than a
-     * single day and slot keeps *both* halves of an event that crosses midnight
-     * ghosted until the write lands (#253).
+     * Where the settled drop came from, and which event row it belongs to. The
+     * instance id alone can't identify the source block for the length of the
+     * write: the provider regenerates `Instances` rows, so a re-read carrying the
+     * *old* time can arrive under a new instance id.
      */
-    private var settledOrigin: Pair<Long, Instant>? by mutableStateOf(null)
+    private var settledOrigin: Triple<Long, LocalDate, Int>? by mutableStateOf(null)
 
     /** Whether a finger is on a block right now — [settling] is not dragging. */
     var isDragging: Boolean by mutableStateOf(false)
@@ -296,47 +153,18 @@ class TimelineDragController {
     var settledOnGrid: Boolean by mutableStateOf(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
-        private set
-
     private var source: TimedBlock? = null
     private var grab = Offset.Zero
     private var pointer = Offset.Zero
 
-    /**
-     * How far the picked-up block's top edge sits past the event's own start —
-     * nonzero only for a block clipped at midnight, which is the tail of an
-     * event that began the day before (#253). The gesture tracks the block the
-     * finger is on; this is what turns where it lands back into an event start.
-     */
-    private var clipOffsetMin = 0
-
-    /** What the picked-up block drew its title over — see [TimelineDrag.titleLines]. */
-    private var titleLines = 0
-
     /**
      * The slot the block already occupied when it was picked up — not the same
      * as its start, since the target snaps to the grid (09:07 lifts to 09:00).
      */
     private var originSlot: Pair<LocalDate, Int>? = null
 
-    fun begin(
-        block: TimedBlock,
-        clipOffsetMin: Int,
-        titleLines: Int,
-        pointerInRoot: Offset,
-        blockInRoot: Offset,
-    ) {
+    fun begin(block: TimedBlock, pointerInRoot: Offset, blockInRoot: Offset) {
         source = block
-        this.clipOffsetMin = clipOffsetMin
-        this.titleLines = titleLines
         settling = null
         isDragging = true
         liftedInstanceId = block.event.instanceId
@@ -354,8 +182,6 @@ class TimelineDragController {
 
     fun cancel() {
         source = null
-        clipOffsetMin = 0
-        titleLines = 0
         isDragging = false
         liftedInstanceId = null
         originSlot = null
@@ -366,41 +192,32 @@ class TimelineDragController {
     }
 
     /**
-     * Whether [block] is part of the event whose copy is in flight, and so must
-     * stay a ghost: the instance the finger picked up, or once dropped whatever
-     * the re-read now carries at the time it came from — both halves of it, for
-     * an event that crosses midnight (#253).
+     * Whether [block] is the one whose copy is in flight, and so must stay a
+     * ghost: the instance the finger picked up, or once dropped whatever now
+     * sits in the slot it left.
      */
-    fun ghosts(block: TimedBlock): Boolean {
+    fun ghosts(block: TimedBlock, date: LocalDate): Boolean {
         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
+        val (eventId, originDate, originMin) = settledOrigin ?: return false
+        return block.event.eventId == eventId &&
+            date == originDate &&
+            block.startMin == originMin
     }
 
     /**
      * 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
-     * or its title, since a single-occurrence move writes a new `eventId`. A
-     * blank title matches nothing: every untitled event has one (#253).
+     * or its title, since a single-occurrence move writes a new `eventId`.
      */
     fun noteGrid(date: LocalDate, blocks: List<TimedBlock>) {
         val landed = settling ?: return
-        if (settledOnGrid) return
-        // 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
+        if (settledOnGrid || landed.date != date) return
         settledOnGrid = blocks.any { block ->
-            block.startMin == slice.startMin &&
+            block.startMin == landed.startMin &&
                 (
                     block.event.eventId == landed.event.eventId ||
-                        (
-                            landed.event.title.isNotBlank() &&
-                                block.event.title == landed.event.title
-                            )
+                        block.event.title == landed.event.title
                     )
         }
     }
@@ -413,18 +230,12 @@ class TimelineDragController {
     fun finish(): TimelineDrop? {
         val landed = drag
         val origin = originSlot
-        val clipOffset = clipOffsetMin
         cancel()
         if (landed == null || landed.slot == origin) return null
-        // An edge piece is a hint for the finger, not a preview of the landing
-        // slot: the event belongs to a day this timeline has no column for, so
-        // [noteGrid] can never seat it and it would sit at the top of today for
-        // the whole settle timeout, long after the event moved off-screen.
-        settling = if (landed.edgeOnly) landed.copy(pieces = emptyList()) else landed
+        settling = landed
         liftedInstanceId = landed.event.instanceId
-        settledOrigin = landed.event.eventId to landed.event.start
-        settledAbandonedMark = abandonedTicks?.value ?: 0
-        return TimelineDrop(landed.event, landed.date, landed.startMin, clipOffset)
+        settledOrigin = origin?.let { (date, min) -> Triple(landed.event.eventId, date, min) }
+        return TimelineDrop(landed.event, landed.date, landed.startMin)
     }
 
     /**
@@ -460,48 +271,28 @@ class TimelineDragController {
         val origin = grid.positionInRoot()
         val rawMinutes = (pointer.y - grab.y - origin.y) / hourPx * 60f
         val snapped = (rawMinutes / DRAG_SNAP_MINUTES).roundToInt() * DRAG_SNAP_MINUTES
-        val eventSpan = (block.event.end - block.event.start).inWholeMinutes.toInt()
-            .coerceAtLeast(0)
-        val floor = dragFloorMin(clipOffsetMin, eventSpan)
-        val startMin = snapped.coerceIn(floor, MINUTES_PER_DAY - DRAG_SNAP_MINUTES)
-        val eventStartMin = startMin - clipOffsetMin
+        // Clamp the start into the target day; a tail past midnight is fine.
+        val startMin = snapped.coerceIn(0, MINUTES_PER_DAY - DRAG_SNAP_MINUTES)
+        // The event's own length, not the block's: TimedBlock.endMin is clipped
+        // at midnight, which would draw a 22:00–02:00 event as a two-hour copy.
+        val span = (block.event.end - block.event.start).inWholeMinutes.toInt().coerceAtLeast(0)
+        // The column the finger is over on screen, and the day that column shows.
         val column = ((pointer.x - origin.x) / columnPx).toInt().coerceIn(0, days.lastIndex)
         val dayIndex = if (geometry.isRtl) days.lastIndex - column else column
-        val visible = -dayIndex..days.lastIndex - dayIndex
-        val onGrid = dragSlices(eventStartMin, eventSpan, within = visible)
-        val slices = onGrid.ifEmpty {
-            listOfNotNull(edgeDragSlice(eventStartMin, eventSpan, visible))
-        }
+        val height = maxOf(span / 60f * hourPx, MIN_EVENT_FRACTION * hourPx)
         drag = TimelineDrag(
             event = block.event,
             date = days[dayIndex],
             startMin = startMin,
-            eventStartMin = eventStartMin,
-            eventSpanMin = eventSpan,
-            titleLines = titleLines,
-            // Bounded to the columns this timeline actually shows: a day it
-            // doesn't has no piece to draw. The write is unaffected.
-            pieces = slices
-                .map { slice ->
-                    val day = dayIndex + slice.dayOffset
-                    val col = if (geometry.isRtl) days.lastIndex - day else day
-                    TimelineDragPiece(
-                        topLeftInRoot = Offset(
-                            x = origin.x + col * columnPx,
-                            y = origin.y + slice.startMin / 60f * hourPx,
-                        ),
-                        sizePx = IntSize(
-                            (columnPx - geometry.columnGapPx).roundToInt(),
-                            maxOf(
-                                slice.spanMin / 60f * hourPx,
-                                MIN_EVENT_FRACTION * hourPx,
-                            ).roundToInt(),
-                        ),
-                        continuesBefore = slice.continuesBefore,
-                        continuesAfter = slice.continuesAfter,
-                    )
-                },
-            edgeOnly = onGrid.isEmpty(),
+            endMin = startMin + span,
+            topLeftInRoot = Offset(
+                x = origin.x + column * columnPx,
+                y = origin.y + startMin / 60f * hourPx,
+            ),
+            sizePx = IntSize(
+                (columnPx - geometry.columnGapPx).roundToInt(),
+                height.roundToInt(),
+            ),
         )
     }
 
@@ -543,52 +334,24 @@ fun rememberTimelineDragController(): TimelineDragController {
     val density = LocalDensity.current
     controller.geometry.edgePx = with(density) { AUTO_SCROLL_EDGE.toPx() }
     controller.geometry.stepPx = with(density) { AUTO_SCROLL_STEP.toPx() }
-    controller.abandonedTicks = LocalEventMove.current?.abandoned
     return controller
 }
 
 /**
- * How far this block's top edge sits past its event's start, in minutes — zero
- * for a block that begins on [day], and the part already run for the tail of an
- * event that started earlier, whose top edge is midnight rather than the event's
- * start. Dragging such a tail moves the event by where *its own* top edge lands,
- * so the offset has to come back off at the drop (#253).
+ * True when [block] actually begins on [day] rather than being the tail of an
+ * event that started earlier. A clipped block's top edge is midnight, not the
+ * event's start, so dragging it would move the event to a time it never had.
  */
-fun TimedBlock.clipOffsetMinutes(day: LocalDate, zone: TimeZone): Int {
-    val start = event.start.toLocalDateTime(zone)
-    val days = (day.toEpochDays() - start.date.toEpochDays()).toInt()
-    val minutes = days * MINUTES_PER_DAY + startMin - start.time.toSecondOfDay() / 60
-    return minutes.coerceAtLeast(0)
-}
+fun TimedBlock.beginsOn(day: LocalDate, zone: TimeZone): Boolean =
+    event.start.toLocalDateTime(zone).date == day
 
 /**
- * True when the event began before [day] — this block is its tail, cut at
- * midnight rather than starting where the event does.
+ * The instant a drop asks for, read in the zone the timeline is drawn in. A drop
+ * into a spring-forward gap has no instant of its own; `toInstant` resolves it
+ * forward by the missing hour, and the block visibly settles there.
  */
-fun TimedBlock.continuesBefore(day: LocalDate, zone: TimeZone): Boolean =
-    event.start < day.atStartOfDayIn(zone)
-
-/** True when the event runs past [day]'s midnight, so this block is cut there. */
-fun TimedBlock.continuesAfter(day: LocalDate, zone: TimeZone): Boolean =
-    event.end > day.plus(1, DateTimeUnit.DAY).atStartOfDayIn(zone)
-
-/**
- * The instant a drop asks for — the *event's* new start, so the tail of an
- * overnight event drops back onto the day its own start belongs to. Read in the
- * zone the timeline is drawn in. A drop into a spring-forward gap has no instant
- * of its own; `toInstant` resolves it forward by the missing hour, and the block
- * visibly settles there.
- */
-fun TimelineDrop.startInstant(zone: TimeZone): Instant {
-    // Wall clock throughout, and past this day at either end: a block's top edge
-    // can be dragged above its midnight and a tail's below the next one, so the
-    // start is resolved as a day plus a minute of it rather than as an offset
-    // from an instant — which would shift by an hour across a DST boundary.
-    val fromMidnight = startMin - clipOffsetMin
-    val day = date.plus(fromMidnight.floorDiv(MINUTES_PER_DAY), DateTimeUnit.DAY)
-    val minute = fromMidnight.mod(MINUTES_PER_DAY)
-    return LocalDateTime(day, LocalTime(minute / 60, minute % 60)).toInstant(zone)
-}
+fun TimelineDrop.startInstant(zone: TimeZone): Instant =
+    LocalDateTime(date, LocalTime(startMin / 60, startMin % 60)).toInstant(zone)
 
 /**
  * A beat after the grid draws the drop, so its own block is under way before the
@@ -617,9 +380,11 @@ const val SETTLE_FADE_MILLIS: Int = 250
 fun TimelineDragOverlay(controller: TimelineDragController, modifier: Modifier = Modifier) {
     var origin by remember { mutableStateOf(Offset.Zero) }
     val dark = isSystemInDarkTheme()
+    val soften = LocalSoftenColors.current
     val use24Hour = LocalUse24HourFormat.current
     val locale = currentLocale()
     val reduceMotion = rememberReduceMotion()
+    val density = LocalDensity.current
     val moveInFlight = moveInFlight()
 
     // Both live here rather than beside the controller: they read [drag], which
@@ -632,14 +397,9 @@ 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()
-    LaunchedEffect(controller.settling, moveInFlight, controller.settledOnGrid, abandoned) {
+    LaunchedEffect(controller.settling, moveInFlight, controller.settledOnGrid) {
         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) {
-            delay(if (controller.settledOnGrid) SETTLE_GRACE_MILLIS else SETTLE_TIMEOUT_MILLIS)
-        }
+        delay(if (controller.settledOnGrid) SETTLE_GRACE_MILLIS else SETTLE_TIMEOUT_MILLIS)
         handingOver = true
         controller.handOver()
         delay(SETTLE_FADE_MILLIS.toLong())
@@ -666,117 +426,57 @@ fun TimelineDragOverlay(controller: TimelineDragController, modifier: Modifier =
             animationSpec = tween(SETTLE_FADE_MILLIS),
             label = "drag-handover",
         )
-        val paint = eventPaint(drag.event, dark)
+        val fill = eventFill(drag.event.color, dark, soften)
         val title = drag.event.title.ifBlank { stringResource(R.string.event_untitled) }
-        // Read off the event rather than the held block, so grabbing either half
-        // of an event that crosses midnight names the same hours. An end past
-        // midnight wraps rather than saturating, so a four-hour event dragged to
-        // 22:00 reads "22:00–02:00" and not "22:00–24:00".
-        val startMin = drag.eventStartMin.mod(MINUTES_PER_DAY)
-        val rawEnd = startMin + drag.eventSpanMin
-        val endMin = if (rawEnd > MINUTES_PER_DAY) rawEnd % MINUTES_PER_DAY else rawEnd
-        val label = "${formatMinuteOfDay(startMin, use24Hour, locale)}–" +
-            formatMinuteOfDay(endMin, use24Hour, locale)
-        // The tallest piece carries the range: on the smallest it would be
-        // clipped away, which is exactly the case when a short tail is held.
-        val labelled = drag.pieces.indices.maxByOrNull { drag.pieces[it].sizePx.height }
-        drag.pieces.forEachIndexed { index, piece ->
-            DragCopy(
-                topLeftInRoot = piece.topLeftInRoot,
-                overlayOrigin = origin,
-                sizePx = piece.sizePx,
-                paint = paint,
-                shape = timedBlockShape(piece.continuesBefore, piece.continuesAfter),
-                cuts = timedBlockCuts(piece.continuesBefore, piece.continuesAfter),
-                lift = lift,
-                alpha = copyAlpha,
-                title = title,
-                titleLines = drag.titleLines,
-                // Once for the whole event: repeated, it would name it per day.
-                label = label.takeIf { index == labelled },
-            )
+        // An end past midnight wraps rather than saturating, so a four-hour
+        // event dragged to 22:00 reads "22:00–02:00" and not "22:00–24:00".
+        val endMin = if (drag.endMin > MINUTES_PER_DAY) {
+            drag.endMin % MINUTES_PER_DAY
+        } else {
+            drag.endMin
         }
-    }
-}
-
-/** One piece of a dragged block, floating over the calendar. */
-@Composable
-private fun DragCopy(
-    topLeftInRoot: Offset,
-    overlayOrigin: Offset,
-    sizePx: IntSize,
-    paint: EventPaint,
-    shape: RoundedCornerShape,
-    cuts: ChipCuts,
-    lift: Float,
-    alpha: Float,
-    title: String,
-    titleLines: Int,
-    label: String?,
-) {
-    val density = LocalDensity.current
-    val width = with(density) { sizePx.width.toDp() }
-    val height = with(density) { sizePx.height.toDp() }
-    val textWidth = width - (BLOCK_OUTER_INSET + BLOCK_TEXT_PADDING) * 2
-    val titleLineHeight = with(density) {
-        MaterialTheme.typography.labelMedium.lineHeight.toDp()
-    }
-    val timeLineHeight = with(density) {
-        MaterialTheme.typography.labelSmall.lineHeight.toDp()
-    }
-    // The block's size, spent the block's way, so nothing reflows under the
-    // finger (#267) — but the range is paid for first, since it may be showing
-    // where a block too short for it will land, and nothing clips the overrun.
-    val available = height - BLOCK_TEXT_INSET * 2
-    val reserved = if (label == null) 0.dp else timeLineHeight
-    val titleBudget = ((available - reserved) / titleLineHeight).toInt().coerceAtLeast(0)
-    val lines = titleLines.coerceAtMost(titleBudget)
-    val spare = available - titleLineHeight * lines - reserved
-    val timeMaxLines = if (label == null) 1 else blockTimeLines(label, textWidth, spare)
-    Box(
-        modifier = Modifier
-            // Absolute: these are root coordinates, and the direction-aware
-            // offset would mirror them across the screen in an RTL layout.
-            .absoluteOffset {
-                IntOffset(
-                    (topLeftInRoot.x - overlayOrigin.x).roundToInt(),
-                    (topLeftInRoot.y - overlayOrigin.y).roundToInt(),
+        val label = "${formatMinuteOfDay(drag.startMin, use24Hour, locale)}–" +
+            formatMinuteOfDay(endMin, use24Hour, locale)
+        Box(
+            modifier = Modifier
+                // Absolute: these are root coordinates, and the direction-aware
+                // offset would mirror them across the screen in an RTL layout.
+                .absoluteOffset {
+                    IntOffset(
+                        (drag.topLeftInRoot.x - origin.x).roundToInt(),
+                        (drag.topLeftInRoot.y - origin.y).roundToInt(),
+                    )
+                }
+                .size(
+                    width = with(density) { drag.sizePx.width.toDp() },
+                    height = with(density) { drag.sizePx.height.toDp() },
                 )
-            }
-            .size(width = width, height = height)
-            .padding(horizontal = BLOCK_OUTER_INSET)
-            .graphicsLayer {
-                scaleX = 1f + 0.02f * lift
-                scaleY = 1f + 0.02f * lift
-                shadowElevation = 8.dp.toPx() * lift
-                this.alpha = alpha
-                this.shape = shape
-                clip = false
-            }
-            .eventSurface(paint, shape, cuts)
-            .padding(horizontal = BLOCK_TEXT_PADDING, vertical = BLOCK_TEXT_INSET),
-    ) {
-        Column {
-            if (lines > 0) {
-                BlockTitle(
-                    title = title,
-                    maxLines = lines,
-                    textWidth = textWidth,
-                    color = paint.titleInk,
-                    textDecoration = paint.decoration,
-                    fontWeight = paint.titleWeight,
+                .padding(horizontal = 1.dp)
+                .graphicsLayer {
+                    scaleX = 1f + 0.02f * lift
+                    scaleY = 1f + 0.02f * lift
+                    shadowElevation = 8.dp.toPx() * lift
+                    alpha = copyAlpha
+                    shape = RoundedCornerShape(4.dp)
+                    clip = false
+                }
+                .background(fill, RoundedCornerShape(4.dp))
+                .padding(horizontal = 4.dp, vertical = 2.dp),
+        ) {
+            Column {
+                Text(
+                    text = title,
+                    style = MaterialTheme.typography.labelMedium,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                    color = eventInk(fill, alpha = 0.85f),
                 )
-            }
-            if (label != null) {
-                val overflow = eventTitleOverflow(singleLine = timeMaxLines == 1)
                 Text(
                     text = label,
-                    // As the block it lifted off sets its own time (#219).
-                    style = MaterialTheme.typography.labelSmall.asEventTime(),
-                    maxLines = timeMaxLines,
-                    overflow = overflow.overflow,
-                    softWrap = overflow.softWrap,
-                    color = paint.secondaryInk,
+                    style = MaterialTheme.typography.labelSmall,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                    color = eventInk(fill, alpha = SECONDARY_INK_ALPHA),
                 )
             }
         }

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

@@ -76,18 +76,6 @@ fun TimelineScale.hourHeight(viewportHeight: Dp): Dp = when (this) {
         .coerceAtLeast(fillHourHeight(viewportHeight))
 }
 
-/**
- * The minute of the day a tap [offsetY] px down a timeline column means, snapped
- * to the hour it landed in.
- *
- * [hourPx] must be the hour height the column is drawing at *now* — a tap
- * detector that captured it when it was installed maps taps to a pre-pinch grid
- * (#148). A zero or negative height (a viewport measured at nothing) has no grid
- * to read, so it answers midnight rather than dividing by it.
- */
-fun tappedMinuteOfDay(offsetY: Float, hourPx: Float): Int =
-    if (hourPx <= 0f) 0 else (offsetY / hourPx).toInt().coerceIn(0, 23) * 60
-
 /**
  * Shortest an event block may render, as a fraction of an hour. Blocks keep a
  * floor so a 15-minute event stays tappable, but the floor scales with the hour

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

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

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

@@ -1,39 +1,26 @@
 package de.jeanlucmakiola.calendula.ui.common
 
-import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.FilledTonalButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.Dp
 
 /**
  * Top-bar pill that shows the current view and cycles to the next one on tap
  * (spec M1: Month → Week → Day → Month, restricted to [IMPLEMENTED_VIEWS]).
- *
- * Renders nothing when [cycle] holds fewer than [QuickSwitchConfig.MIN_CYCLE]
- * views (#150), so it drops straight into an app bar's `actions` slot without a
- * wrapping condition — the same way [TodayAction] handles being turned off.
- *
- * [trailingInset] lands the pill's background on the bar's own rhythm; pass
- * `0.dp` outside a top app bar, where M3's actions padding is not there to
- * cancel (#165).
  */
 @Composable
 fun ViewSwitcherPill(
     current: CalendarView,
-    cycle: List<CalendarView>,
     onCycle: () -> Unit,
     modifier: Modifier = Modifier,
-    trailingInset: Dp = AppBarSpacing.ContainerTrailingInset,
 ) {
-    if (cycle.size < QuickSwitchConfig.MIN_CYCLE) return
     FilledTonalButton(
         onClick = onCycle,
         shape = MaterialTheme.shapes.large,
-        modifier = modifier.padding(end = trailingInset),
+        modifier = modifier,
     ) {
         Text(stringResource(current.labelRes))
     }

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

@@ -1,6 +1,7 @@
 package de.jeanlucmakiola.calendula.ui.day
 
 import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.animateColorAsState
 import androidx.compose.animation.core.animateDpAsState
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
@@ -39,22 +40,22 @@ import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.rememberDrawerState
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.key
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.snapshotFlow
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.clipToBounds
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.RectangleShape
 import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.platform.LocalDensity
@@ -63,6 +64,7 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.customActions
 import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
@@ -70,9 +72,6 @@ import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.ui.common.LocalChipGround
-import de.jeanlucmakiola.calendula.ui.common.eventPaint
-import de.jeanlucmakiola.calendula.ui.common.eventSurface
 import de.jeanlucmakiola.calendula.ui.common.formatCalendarTitle
 import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
 import de.jeanlucmakiola.calendula.ui.common.CalendarTitleButton
@@ -81,12 +80,7 @@ import de.jeanlucmakiola.calendula.ui.common.TodayAction
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
-import de.jeanlucmakiola.calendula.ui.common.BLOCK_OUTER_INSET
-import de.jeanlucmakiola.calendula.ui.common.BLOCK_TEXT_PADDING
-import de.jeanlucmakiola.calendula.ui.common.BLOCK_TEXT_INSET
 import de.jeanlucmakiola.calendula.ui.common.BlockTimeLabel
-import de.jeanlucmakiola.calendula.ui.common.BlockTitle
-import de.jeanlucmakiola.calendula.ui.common.blockTimeLines
 import de.jeanlucmakiola.calendula.ui.common.animatedBlockPlacement
 import de.jeanlucmakiola.calendula.ui.common.ghostAlpha
 import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
@@ -96,14 +90,8 @@ import de.jeanlucmakiola.calendula.ui.common.NowLine
 import de.jeanlucmakiola.calendula.ui.common.TimelineDragController
 import de.jeanlucmakiola.calendula.ui.common.TimelineDragOverlay
 import de.jeanlucmakiola.calendula.ui.common.TimelineDrop
-import de.jeanlucmakiola.calendula.ui.common.clipOffsetMinutes
-import de.jeanlucmakiola.calendula.ui.common.continuesAfter
-import de.jeanlucmakiola.calendula.ui.common.continuesBefore
-import de.jeanlucmakiola.calendula.ui.common.timedBlockCuts
-import de.jeanlucmakiola.calendula.ui.common.timedBlockShape
-import de.jeanlucmakiola.calendula.ui.common.eventDragAllowed
+import de.jeanlucmakiola.calendula.ui.common.beginsOn
 import de.jeanlucmakiola.calendula.ui.common.eventMoveAction
-import de.jeanlucmakiola.calendula.ui.common.eventTitleOverflow
 import de.jeanlucmakiola.calendula.ui.common.rememberEventDragSource
 import de.jeanlucmakiola.calendula.ui.common.rememberTimelineDragController
 import de.jeanlucmakiola.calendula.ui.common.startInstant
@@ -113,21 +101,22 @@ import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarPageSwipe
 import de.jeanlucmakiola.floret.identity.rememberReduceMotion
 import de.jeanlucmakiola.calendula.ui.common.next
-import de.jeanlucmakiola.calendula.ui.common.EventChipShape
+import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
+import de.jeanlucmakiola.calendula.ui.common.eventFill
+import de.jeanlucmakiola.calendula.ui.common.eventInk
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.LocalShowHourLines
 import de.jeanlucmakiola.calendula.ui.common.LocalTimelineZoom
 import de.jeanlucmakiola.calendula.ui.common.MIN_EVENT_FRACTION
+import de.jeanlucmakiola.calendula.ui.common.SECONDARY_INK_ALPHA
 import de.jeanlucmakiola.calendula.ui.common.hourHeight
 import de.jeanlucmakiola.calendula.ui.common.rememberTimelinePinchZoom
 import de.jeanlucmakiola.calendula.ui.common.formatMinuteOfDay
 import de.jeanlucmakiola.calendula.ui.common.GUTTER_WIDTH
 import de.jeanlucmakiola.calendula.ui.common.HourGutter
-import de.jeanlucmakiola.calendula.ui.common.TIMELINE_CONTENT_END_INSET
 import de.jeanlucmakiola.calendula.ui.common.hourSeparatorLines
-import de.jeanlucmakiola.calendula.ui.common.tappedMinuteOfDay
 import de.jeanlucmakiola.calendula.ui.week.TimedBlock
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
@@ -142,7 +131,7 @@ private val ALL_DAY_ROW_HEIGHT = 24.dp
 private val ALL_DAY_VERTICAL_PADDING = 6.dp
 
 /** Total all-day strip height for the day (0 when there are no all-day events). */
-internal fun DayUiState.Success.allDayStripHeight(): Dp {
+private fun DayUiState.Success.allDayStripHeight(): Dp {
     if (allDay.isEmpty()) return 0.dp
     val lanes = allDay.maxOf { it.lane } + 1
     return ALL_DAY_ROW_HEIGHT * lanes + ALL_DAY_VERTICAL_PADDING * 2
@@ -172,9 +161,21 @@ fun DayScreen(
         initialDateIso?.let { viewModel.goToDate(LocalDate.parse(it)) }
     }
 
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
     val drawerState = rememberDrawerState(DrawerValue.Closed)
     val scope = rememberCoroutineScope()
 
+    // The all-day strip shares the app bar's scrolled colour so the whole top
+    // region elevates together once the timeline scrolls under it.
+    val topSectionColor by animateColorAsState(
+        targetValue = if (scrollBehavior.state.overlappedFraction > 0.01f) {
+            MaterialTheme.colorScheme.surfaceContainer
+        } else {
+            MaterialTheme.colorScheme.surface
+        },
+        label = "day-top-section-color",
+    )
+
     val isOnToday = when (val s = state) {
         is DayUiState.Success -> s.date == s.today
         else -> true
@@ -232,19 +233,19 @@ fun DayScreen(
         },
     ) {
         Scaffold(
-            modifier = modifier,
+            modifier = modifier.nestedScroll(scrollBehavior.nestedScrollConnection),
             topBar = {
                 DayTopBar(
                     date = date,
                     currentYear = currentYear,
                     selectedView = selectedView,
                     onCycleView = { onSelectView(selectedView.next(quickSwitchViews)) },
-                    quickSwitchViews = quickSwitchViews,
                     onOpenDrawer = { scope.launch { drawerState.open() } },
                     onOpenSearch = onOpenSearch,
                     onJumpToDate = jumpToDate,
                     showTodayButton = todayInToolbar,
                     onToday = jumpToToday,
+                    scrollBehavior = scrollBehavior,
                 )
             },
             floatingActionButton = {
@@ -259,6 +260,7 @@ fun DayScreen(
             DayContent(
                 state = state,
                 slideDir = slideDir,
+                topSectionColor = topSectionColor,
                 onSwipeNext = goNext,
                 onSwipePrev = goPrev,
                 onRetry = jumpToToday,
@@ -276,6 +278,7 @@ fun DayScreen(
 private fun DayContent(
     state: DayUiState,
     slideDir: Int,
+    topSectionColor: Color,
     onSwipeNext: () -> Unit,
     onSwipePrev: () -> Unit,
     onRetry: () -> Unit,
@@ -336,13 +339,14 @@ private fun DayContent(
                 is DayUiState.Failure -> CalendarFailure(reason = s.reason, onRetry = onRetry)
                 is DayUiState.Success -> DaySuccess(
                     state = s,
+                    topSectionColor = topSectionColor,
                     scrollState = scrollState,
                     allDayHeight = allDayHeight,
                     dragController = dragController,
                     onEventClick = onEventClick,
                     onCreateAt = onCreateAt,
                     onDrop = { drop ->
-                        move?.move(
+                        val took = move?.move(
                             MoveRequest(
                                 eventId = drop.event.eventId,
                                 beginMillis = drop.event.start.toEpochMilliseconds(),
@@ -350,6 +354,9 @@ private fun DayContent(
                                 target = MoveTarget.Start(drop.startInstant(zone)),
                             ),
                         )
+                        // Refused, so nothing will land: let the copy go now
+                        // rather than hold it out for a settle that never comes.
+                        if (took != true) dragController.release()
                     },
                 )
             }
@@ -359,8 +366,9 @@ private fun DayContent(
 }
 
 @Composable
-internal fun DaySuccess(
+private fun DaySuccess(
     state: DayUiState.Success,
+    topSectionColor: Color,
     scrollState: ScrollState,
     allDayHeight: Dp,
     dragController: TimelineDragController,
@@ -371,22 +379,16 @@ internal fun DaySuccess(
     Column(modifier = Modifier.fillMaxSize()) {
         // All-day strip collapses to nothing when the day has no all-day events,
         // so the timeline sits directly under the app bar.
-        // This strip is painted on `surface`, so an outlined chip has to fill
-        // with that and not with the column's container (#230).
-        CompositionLocalProvider(
-            LocalChipGround provides MaterialTheme.colorScheme.surface,
-        ) {
-            AllDayStrip(
-                state = state,
-                height = allDayHeight,
-                onEventClick = onEventClick,
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .background(MaterialTheme.colorScheme.surface),
-            )
-        }
-        // Breathing room between the top section and the scrolling timeline
-        // below.
+        AllDayStrip(
+            state = state,
+            height = allDayHeight,
+            onEventClick = onEventClick,
+            modifier = Modifier
+                .fillMaxWidth()
+                .background(topSectionColor),
+        )
+        // Breathing room between the (colour-shifting) top section and the
+        // scrolling timeline below.
         Spacer(Modifier.height(8.dp))
         Timeline(
             state = state,
@@ -406,25 +408,20 @@ private fun DayTopBar(
     currentYear: Int,
     selectedView: CalendarView,
     onCycleView: () -> Unit,
-    quickSwitchViews: List<CalendarView>,
     onOpenDrawer: () -> Unit,
     onOpenSearch: () -> Unit,
     onJumpToDate: (LocalDate) -> Unit,
     showTodayButton: Boolean,
     onToday: () -> Unit,
+    scrollBehavior: androidx.compose.material3.TopAppBarScrollBehavior,
 ) {
     val locale = currentLocale()
-    val (title, shortTitle) = remember(date, locale, currentYear) {
-        formatDayTitle(date, locale, currentYear) to
-            formatDayTitle(date, locale, currentYear, abbreviated = true)
-    }
     TopAppBar(
         title = {
             CalendarTitleButton(
-                title = title,
+                title = formatDayTitle(date, locale, currentYear),
                 currentDate = date,
                 onJumpToDate = onJumpToDate,
-                shortTitle = shortTitle,
             )
         },
         navigationIcon = {
@@ -445,17 +442,15 @@ private fun DayTopBar(
             }
             ViewSwitcherPill(
                 current = selectedView,
-                cycle = quickSwitchViews,
                 onCycle = onCycleView,
+                modifier = Modifier.padding(end = 8.dp),
             )
         },
-        // Deliberately flat: M3 lifts the bar to mark content scrolling under
-        // it, but here the bar meets the header on the same surface and the
-        // tint is what makes that seam look like a separate block (#186).
         colors = TopAppBarDefaults.topAppBarColors(
             containerColor = MaterialTheme.colorScheme.surface,
-            scrolledContainerColor = MaterialTheme.colorScheme.surface,
+            scrolledContainerColor = MaterialTheme.colorScheme.surfaceContainer,
         ),
+        scrollBehavior = scrollBehavior,
     )
 }
 
@@ -473,11 +468,7 @@ private fun AllDayStrip(
             // Height is hoisted + animated so it resizes smoothly; padding sits
             // inside it so the content area is lanes * row height.
             .height(height)
-            .padding(
-                top = ALL_DAY_VERTICAL_PADDING,
-                bottom = ALL_DAY_VERTICAL_PADDING,
-                end = TIMELINE_CONTENT_END_INSET,
-            ),
+            .padding(vertical = ALL_DAY_VERTICAL_PADDING),
     ) {
         // Keep the gutter-width offset so the bars line up with the day column.
         Spacer(Modifier.width(GUTTER_WIDTH))
@@ -515,25 +506,22 @@ private fun AllDayBar(
     modifier: Modifier = Modifier,
 ) {
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
-    val paint = eventPaint(event, dark)
+    val soften = LocalSoftenColors.current
+    val fill = eventFill(event.color, dark, soften)
     Box(
         modifier = modifier
-            .eventSurface(paint, EventChipShape)
+            .background(fill, RoundedCornerShape(4.dp))
             .clickable(onClick = onClick)
             .padding(horizontal = 6.dp, vertical = 2.dp)
             .semantics { contentDescription = title },
         contentAlignment = Alignment.CenterStart,
     ) {
-        val titleOverflow = eventTitleOverflow()
         Text(
             text = title,
             style = MaterialTheme.typography.labelSmall,
             maxLines = 1,
-            overflow = titleOverflow.overflow,
-            softWrap = titleOverflow.softWrap,
-            color = paint.titleInk,
-            fontWeight = paint.titleWeight,
-            textDecoration = paint.decoration,
+            overflow = TextOverflow.Ellipsis,
+            color = eventInk(fill),
         )
     }
 }
@@ -579,7 +567,6 @@ private fun Timeline(
                 modifier = Modifier
                     .weight(1f)
                     .fillMaxHeight()
-                    .padding(end = TIMELINE_CONTENT_END_INSET)
                     .clip(RoundedCornerShape(16.dp))
                     .verticalScroll(scrollState)
                     .onGloballyPositioned { dragController.geometry.viewport = it },
@@ -636,12 +623,6 @@ private fun DayColumnCard(
     LaunchedEffect(blocks, dragController.settling) {
         dragController.noteGrid(date, blocks)
     }
-    // The tap detector outlives the composition that installed it — a pinch or a
-    // Settings change moves the hour height without restarting it — so it reads
-    // the height and the callback through state handles instead of capturing
-    // them, or taps land on the scale the column had before the zoom (#148).
-    val currentHourPx = rememberUpdatedState(hourPx)
-    val currentOnCreateAt = rememberUpdatedState(onCreateAt)
     Card(
         // Plain rectangular column — the soft corners come from the outer
         // rounded scroll viewport, so inner rounding would look odd at the edges.
@@ -662,10 +643,8 @@ private fun DayColumnCard(
                 // only fires on the column background. Snaps to the tapped hour.
                 .pointerInput(date) {
                     detectTapGestures { offset ->
-                        currentOnCreateAt.value(
-                            date,
-                            tappedMinuteOfDay(offset.y, currentHourPx.value),
-                        )
+                        val hour = (offset.y / hourPx).toInt().coerceIn(0, 23)
+                        onCreateAt(date, hour * 60)
                     }
                 },
         ) {
@@ -692,7 +671,6 @@ private fun DayColumnCard(
                         block = block,
                         dark = dark,
                         height = place.height,
-                        width = place.width,
                         date = date,
                         dragController = dragController,
                         onClick = { onEventClick(block.event) },
@@ -701,7 +679,7 @@ private fun DayColumnCard(
                             .offset(x = place.x, y = place.y)
                             .width(place.width)
                             .height(place.height)
-                            .padding(horizontal = BLOCK_OUTER_INSET),
+                            .padding(horizontal = 1.dp),
                     )
                 }
             }
@@ -718,7 +696,6 @@ private fun EventBlock(
     block: TimedBlock,
     dark: Boolean,
     height: Dp,
-    width: Dp,
     date: LocalDate,
     dragController: TimelineDragController,
     onClick: () -> Unit,
@@ -737,59 +714,40 @@ private fun EventBlock(
     val timeLineHeight = with(density) {
         MaterialTheme.typography.labelSmall.lineHeight.toDp()
     }
-    // A block that cannot afford both lines spends its space on the title, and
-    // one too short even for that drops the title rather than serving a sliced one.
-    // Height alone decides: a duration threshold would keep hiding the time on a
-    // half-hour block the user has pinched open to three times the room it needs.
-    val available = height - BLOCK_TEXT_INSET * 2
-    val showTime = available >= titleLineHeight + timeLineHeight
+    // What's left for text once the 2.dp top/bottom padding is paid for. A block
+    // that cannot afford both lines spends its space on the title, and one too
+    // short even for that drops the title rather than serving a sliced one.
+    val available = height - 4.dp
+    val showTime = block.endMin - block.startMin >= 45 &&
+        available >= titleLineHeight + timeLineHeight
     val showTitle = available >= titleLineHeight
-    val textWidth = width - (BLOCK_OUTER_INSET + BLOCK_TEXT_PADDING) * 2
-    val titleMaxLines = if (showTime) 1 else 2
-    // On a day column — wide enough for "09:30–11:00" several times over — the
-    // range never needs the second line, until lanes cut the column down.
-    val spare = available - titleLineHeight * titleMaxLines -
-        if (showTime) timeLineHeight else 0.dp
-    val timeMaxLines = if (showTime) blockTimeLines(timeLabel, textWidth, spare) else 1
-    val paint = eventPaint(block.event, dark)
+    val soften = LocalSoftenColors.current
+    val fill = eventFill(block.event.color, dark, soften)
     val zone = remember { TimeZone.currentSystemDefault() }
     val moveAction = eventMoveAction(block.event)
-    val draggable = eventDragAllowed(block.event)
-    // The drop takes this offset back off, so a tail clipped at midnight lands
-    // where the event's own start belongs (#253).
-    val clipOffset = remember(block, date, zone) { block.clipOffsetMinutes(date, zone) }
-    val cuts = remember(block, date, zone) {
-        timedBlockCuts(block.continuesBefore(date, zone), block.continuesAfter(date, zone))
-    }
-    val shape = remember(cuts) { timedBlockShape(cuts.top, cuts.bottom) }
+    // A block clipped at the top continues from the previous day: its top edge
+    // is midnight, not the event's start, so dragging it would invent a time.
+    val draggable = moveAction != null && block.beginsOn(date, zone)
     val dragModifier = rememberEventDragSource(
         enabled = draggable,
         key = block.event.instanceId,
-        onPickUp = { pointer, blockRoot, _ ->
-            dragController.begin(
-                block = block,
-                clipOffsetMin = clipOffset,
-                titleLines = if (showTitle) titleMaxLines else 0,
-                pointerInRoot = pointer,
-                blockInRoot = blockRoot,
-            )
-        },
+        onPickUp = { pointer, blockRoot, _ -> dragController.begin(block, pointer, blockRoot) },
         onMove = dragController::move,
         onDrop = { dragController.finish()?.let(onDrop) },
         onCancel = dragController::cancel,
     )
-    val lifted = draggable && dragController.ghosts(block)
+    val lifted = draggable && dragController.ghosts(block, date)
     val ghost = ghostAlpha(lifted)
     Box(
         modifier = modifier
             // The source stays put as a ghost while its floating copy travels.
             .then(if (ghost < 1f) Modifier.alpha(ghost) else Modifier)
-            .eventSurface(paint, shape, cuts)
+            .background(fill, RoundedCornerShape(4.dp))
             .clickable(onClick = onClick)
             // After clickable, so it is the inner node and wins the main pass;
             // the tap still works, since a drag consumes the up.
             .then(dragModifier)
-            .padding(horizontal = BLOCK_TEXT_PADDING, vertical = BLOCK_TEXT_INSET)
+            .padding(horizontal = 4.dp, vertical = 2.dp)
             .semantics {
                 contentDescription = "$title, $timeLabel"
                 if (moveAction != null) customActions = listOf(moveAction)
@@ -797,20 +755,18 @@ private fun EventBlock(
     ) {
         Column {
             if (showTitle) {
-                BlockTitle(
-                    title = title,
-                    maxLines = titleMaxLines,
-                    textWidth = textWidth,
-                    color = paint.titleInk,
-                    textDecoration = paint.decoration,
-                    fontWeight = paint.titleWeight,
+                Text(
+                    text = title,
+                    style = MaterialTheme.typography.labelMedium,
+                    maxLines = if (showTime) 1 else 2,
+                    overflow = TextOverflow.Ellipsis,
+                    color = eventInk(fill, alpha = 0.85f),
                 )
             }
             if (showTime) {
                 BlockTimeLabel(
                     label = timeLabel,
-                    color = paint.secondaryInk,
-                    maxLines = timeMaxLines,
+                    color = eventInk(fill, alpha = SECONDARY_INK_ALPHA),
                 )
             }
         }
@@ -825,12 +781,7 @@ private fun DayLoading() {
         // Same scale resolution as the loaded timeline, so the skeleton's column
         // doesn't resize the moment the real day arrives.
         val totalHeight = scale.hourHeight(maxHeight) * 24
-        Row(
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(end = TIMELINE_CONTENT_END_INSET)
-                .verticalScroll(scrollState),
-        ) {
+        Row(modifier = Modifier.fillMaxSize().verticalScroll(scrollState)) {
             Spacer(Modifier.width(GUTTER_WIDTH))
             Box(
                 modifier = Modifier
@@ -846,16 +797,10 @@ private fun DayLoading() {
 private fun minToHm(min: Int, is24Hour: Boolean, locale: Locale): String =
     formatMinuteOfDay(min, is24Hour, locale)
 
-/** [abbreviated] drops the weekday, leaving the date itself (#165). */
-private fun formatDayTitle(
-    date: LocalDate,
-    locale: Locale,
-    currentYear: Int,
-    abbreviated: Boolean = false,
-): String =
+private fun formatDayTitle(date: LocalDate, locale: Locale, currentYear: Int): String =
     formatCalendarTitle(
         date = java.time.LocalDate.of(date.year, date.month.ordinal + 1, date.day),
         locale = locale,
         currentYear = currentYear,
-        skeleton = if (abbreviated) "dMMM" else "EEEdMMM",
+        skeleton = "EEEdMMM",
     )

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

@@ -1,63 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.day
-
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.snapshotFlow
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.Dp
-import de.jeanlucmakiola.calendula.ui.common.ScaledViewPreview
-import de.jeanlucmakiola.calendula.ui.common.rememberTimelineDragController
-import de.jeanlucmakiola.calendula.ui.common.sampleTimelineEvents
-import de.jeanlucmakiola.calendula.ui.week.layoutAllDay
-import de.jeanlucmakiola.calendula.ui.week.layoutDay
-import kotlinx.coroutines.flow.first
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.toLocalDateTime
-import kotlin.time.Clock
-
-/**
- * A live, scaled-down Day view for the onboarding view chooser. Today's date is
- * real; only the events are stand-ins.
- */
-@Composable
-internal fun DayViewPreview(
-    height: Dp,
-    modifier: Modifier = Modifier,
-) {
-    val zone = remember { TimeZone.currentSystemDefault() }
-    val today = remember(zone) { Clock.System.now().toLocalDateTime(zone).date }
-    val state = remember(today, zone) { sampleDayState(today, zone) }
-    val scrollState = rememberScrollState()
-    LaunchedEffect(Unit) {
-        snapshotFlow { scrollState.maxValue }.first { it > 0 }
-        // Half the scroll range is noon — the same centring the live view does.
-        scrollState.scrollTo(scrollState.maxValue / 2)
-    }
-
-    ScaledViewPreview(height = height, modifier = modifier) {
-        DaySuccess(
-            state = state,
-            scrollState = scrollState,
-            allDayHeight = state.allDayStripHeight(),
-            dragController = rememberTimelineDragController(),
-            onEventClick = {},
-            onCreateAt = { _, _ -> },
-            onDrop = {},
-        )
-    }
-}
-
-/** Sample day state, laid out through the same helpers the live view uses. */
-private fun sampleDayState(today: LocalDate, zone: TimeZone): DayUiState.Success {
-    val days = listOf(today)
-    val events = sampleTimelineEvents(days, today, zone)
-    return DayUiState.Success(
-        date = today,
-        today = today,
-        allDay = layoutAllDay(events.filter { it.isAllDay }, days, zone),
-        timed = layoutDay(events, today, zone),
-    )
-}

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

@@ -9,6 +9,7 @@ import android.net.Uri
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -97,9 +98,6 @@ import de.jeanlucmakiola.calendula.domain.timeZoneOptionOf
 import de.jeanlucmakiola.calendula.domain.zoneDescriptor
 import de.jeanlucmakiola.floret.identity.predictiveBack
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
-import de.jeanlucmakiola.calendula.ui.common.FieldCopier
-import de.jeanlucmakiola.calendula.ui.common.copyOnLongPress
-import de.jeanlucmakiola.calendula.ui.common.rememberFieldCopier
 import de.jeanlucmakiola.calendula.ui.common.icuTimeZoneRegion
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.eventAccent
@@ -152,7 +150,6 @@ fun EventDetailScreen(
     val scope = rememberCoroutineScope()
     val snackbarHostState = remember { SnackbarHostState() }
     var showDeleteDialog by rememberSaveable { mutableStateOf(false) }
-    val copyField = rememberFieldCopier(snackbarHostState)
 
     // Sharing is read-only, so it needs no WRITE_CALENDAR upgrade. The VM stages
     // an .ics in the cache and hands back a content Uri for the chooser.
@@ -303,7 +300,7 @@ fun EventDetailScreen(
                 reason = s.reason,
                 onRetry = viewModel::retry,
             )
-            is EventDetailUiState.Success -> EventDetailContent(s, copyField, contentModifier)
+            is EventDetailUiState.Success -> EventDetailContent(s, contentModifier)
         }
     }
 
@@ -385,11 +382,7 @@ private fun DeleteEventDialog(
 
 
 @Composable
-private fun EventDetailContent(
-    state: EventDetailUiState.Success,
-    copyField: FieldCopier,
-    modifier: Modifier = Modifier,
-) {
+private fun EventDetailContent(state: EventDetailUiState.Success, modifier: Modifier = Modifier) {
     val detail = state.detail
     val instance = detail.instance
     val dark = isSystemInDarkTheme()
@@ -406,7 +399,6 @@ private fun EventDetailContent(
         // event, so it's left implicit — only Free is worth surfacing. A
         // cancelled event strikes through its title.
         Row(verticalAlignment = Alignment.Top) {
-            val titleLabel = stringResource(R.string.event_detail_title)
             Text(
                 text = instance.title.ifBlank { stringResource(R.string.event_untitled) },
                 style = MaterialTheme.typography.headlineMedium,
@@ -416,17 +408,7 @@ private fun EventDetailContent(
                 } else {
                     null
                 },
-                modifier = Modifier
-                    .weight(1f)
-                    .then(
-                        // Nothing to copy off an untitled event — the placeholder
-                        // isn't the event's own text.
-                        if (instance.title.isNotBlank()) {
-                            Modifier.copyOnLongPress(titleLabel, instance.title, copyField)
-                        } else {
-                            Modifier
-                        },
-                    ),
+                modifier = Modifier.weight(1f),
             )
             if (detail.availability == Availability.Free) {
                 Spacer(Modifier.width(12.dp))
@@ -534,11 +516,10 @@ private fun EventDetailContent(
         // Location (conditional, tap → maps).
         instance.location?.takeIf { it.isNotBlank() }?.let { location ->
             val context = LocalContext.current
-            val locationLabel = stringResource(R.string.event_detail_location)
             Spacer(Modifier.height(gap))
             DetailCard(
                 icon = Icons.Default.Place,
-                iconContentDescription = locationLabel,
+                iconContentDescription = stringResource(R.string.event_detail_location),
             ) {
                 Text(
                     text = location,
@@ -546,12 +527,7 @@ private fun EventDetailContent(
                     color = MaterialTheme.colorScheme.primary,
                     modifier = Modifier
                         .fillMaxWidth()
-                        .copyOnLongPress(
-                            label = locationLabel,
-                            text = location,
-                            copy = copyField,
-                            onTap = { openInMaps(context, location) },
-                        )
+                        .clickable { openInMaps(context, location) }
                         .padding(vertical = 2.dp),
                 )
             }
@@ -559,15 +535,10 @@ private fun EventDetailContent(
 
         // Description (conditional). URLs are auto-linked.
         detail.description?.takeIf { it.isNotBlank() }?.let { description ->
-            val descriptionLabel = stringResource(R.string.event_detail_description)
             Spacer(Modifier.height(gap))
             DetailCard(
                 icon = Icons.AutoMirrored.Filled.Notes,
-                iconContentDescription = descriptionLabel,
-                // The gesture sits on the card so the icon and padding answer
-                // it too: every linkified URL owns the pointer over its own
-                // glyphs, which leaves the text itself a patchy target.
-                modifier = Modifier.copyOnLongPress(descriptionLabel, description, copyField),
+                iconContentDescription = stringResource(R.string.event_detail_description),
             ) {
                 Text(
                     text = linkifyUrls(description, MaterialTheme.colorScheme.primary),
@@ -640,14 +611,13 @@ private fun EventDetailContent(
 private fun DetailCard(
     icon: ImageVector,
     iconContentDescription: String?,
-    modifier: Modifier = Modifier,
     iconTint: Color = MaterialTheme.colorScheme.onSurfaceVariant,
     content: @Composable ColumnScope.() -> Unit,
 ) {
     Surface(
         color = MaterialTheme.colorScheme.surfaceContainerHigh,
         shape = RoundedCornerShape(16.dp),
-        modifier = modifier.fillMaxWidth(),
+        modifier = Modifier.fillMaxWidth(),
     ) {
         Row(
             modifier = Modifier.padding(16.dp),

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

@@ -48,14 +48,9 @@ class EventDetailViewModel @Inject constructor(
 ) : ViewModel() {
 
     private val _target = MutableStateFlow<Target?>(null)
-    // Bumped by retry() and by re-opening the target already shown, to re-run
-    // the load without changing the target.
+    // Bumped by retry() to re-run the load for the same target.
     private val _reload = MutableStateFlow(0)
 
-    // Last target whose content is already on screen; a re-read of it skips the
-    // Loading skeleton so the sheet doesn't blank out between two identical reads.
-    private var loadedTarget: Target? = null
-
     private val _deleteState = MutableStateFlow<DeleteUiState>(DeleteUiState.Idle)
     val deleteState: StateFlow<DeleteUiState> = _deleteState.asStateFlow()
 
@@ -63,14 +58,11 @@ class EventDetailViewModel @Inject constructor(
         combine(_target, _reload) { target, _ -> target }
             .flatMapLatest { target ->
                 if (target == null) {
-                    loadedTarget = null
                     flowOf<EventDetailUiState>(EventDetailUiState.Loading)
                 } else {
                     flow {
-                        if (loadedTarget != target) emit(EventDetailUiState.Loading)
-                        val loaded = loadDetail(target)
-                        loadedTarget = target.takeIf { loaded is EventDetailUiState.Success }
-                        emit(loaded)
+                        emit(EventDetailUiState.Loading)
+                        emit(loadDetail(target))
                     }
                 }
             }
@@ -86,15 +78,9 @@ class EventDetailViewModel @Inject constructor(
      * the occurrence's own times (from `CalendarContract.Instances`); they
      * override the series DTSTART/DTEND so recurring events show the correct
      * date instead of the first occurrence.
-     *
-     * Re-opening the *same* occurrence always re-reads it. The view model
-     * outlives the sheet, and a `StateFlow` conflates an identical value away,
-     * so assigning the target alone would leave an edit that changed no time —
-     * adding a description, say (#196) — showing the state from before the save.
      */
     fun open(eventId: Long, beginMillis: Long, endMillis: Long) {
-        val target = Target(eventId, beginMillis, endMillis)
-        if (_target.value == target) _reload.value += 1 else _target.value = target
+        _target.value = Target(eventId, beginMillis, endMillis)
     }
 
     /** Re-run the current load after a failure. */

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

@@ -64,7 +64,6 @@ import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SegmentedButton
 import androidx.compose.material3.SegmentedButtonDefaults
 import androidx.compose.material3.SingleChoiceSegmentedButtonRow
-import androidx.compose.material3.SnackbarDuration
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.Surface
@@ -265,16 +264,13 @@ fun EventEditScreen(
                 viewModel.reset()
                 onSaved()
             }
-            // A failed save leaves the form looking unchanged, so the snackbar is
-            // the only sign anything happened — long rather than the default
-            // flash (Codeberg #234: it read as "nothing happens at all").
             SaveUiState.Failed -> {
                 viewModel.consumeSaveResult()
-                snackbarHostState.showSnackbar(saveFailedMessage, duration = SnackbarDuration.Long)
+                snackbarHostState.showSnackbar(saveFailedMessage)
             }
             SaveUiState.NeedsPermission -> {
                 viewModel.consumeSaveResult()
-                snackbarHostState.showSnackbar(writeDeniedMessage, duration = SnackbarDuration.Long)
+                snackbarHostState.showSnackbar(writeDeniedMessage)
             }
             // AwaitingScope/AwaitingConflict/Gone render as dialogs below.
             else -> Unit
@@ -794,9 +790,6 @@ private fun EventEditContent(
                         value = form.location,
                         onValueChange = viewModel::setLocation,
                         placeholder = stringResource(R.string.event_detail_location),
-                        // A location is as often a meeting URL as an address,
-                        // and "Zoom.us/j/123" reads wrong (#146).
-                        capitalization = KeyboardCapitalization.None,
                         modifier = Modifier
                             .weight(1f)
                             .padding(vertical = 4.dp),
@@ -2226,9 +2219,7 @@ private fun formatTimeRange(start: LocalDateTime, end: LocalDateTime, locale: Lo
 /**
  * Borderless text input used inside the cards (and as the headline title).
  * Thin wrapper over the shared [InlineTextField] so the form and the rest of
- * the app share one input style. Sentence-case by default, as floret-kit is;
- * a field holding an identifier rather than prose passes
- * [KeyboardCapitalization.None].
+ * the app share one input style.
  */
 @Composable
 private fun InlineField(
@@ -2240,7 +2231,6 @@ private fun InlineField(
     minLines: Int = 1,
     enabled: Boolean = true,
     keyboardType: KeyboardType = KeyboardType.Text,
-    capitalization: KeyboardCapitalization = KeyboardCapitalization.Sentences,
     modifier: Modifier = Modifier
         .fillMaxWidth()
         .padding(vertical = 4.dp),
@@ -2255,7 +2245,7 @@ private fun InlineField(
         minLines = minLines,
         enabled = enabled,
         keyboardType = keyboardType,
-        capitalization = capitalization,
+        capitalization = KeyboardCapitalization.None,
     )
 }
 

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

@@ -1,6 +1,5 @@
 package de.jeanlucmakiola.calendula.ui.edit
 
-import android.util.Log
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
@@ -57,8 +56,6 @@ import kotlin.time.Duration.Companion.minutes
 import kotlin.time.Instant
 import javax.inject.Inject
 
-private const val TAG = "EventEdit"
-
 /**
  * Where a prefilled [EventEditViewModel.openImported] form came from. The sources
  * want different reminder handling (#49), and differ in whether they own the
@@ -737,12 +734,7 @@ class EventEditViewModel @Inject constructor(
                 } else {
                     when (scope) {
                         RecurringWriteScope.ThisEvent ->
-                            repository.updateOccurrence(
-                                target.eventId,
-                                target.beginMillis,
-                                target.original,
-                                form,
-                            )
+                            repository.updateOccurrence(target.eventId, target.beginMillis, form)
                         RecurringWriteScope.ThisAndFollowing ->
                             repository.updateEventFromOccurrence(
                                 eventId = target.eventId,
@@ -759,15 +751,7 @@ class EventEditViewModel @Inject constructor(
                 throw e
             } catch (e: SecurityException) {
                 SaveUiState.NeedsPermission
-            } catch (e: NoSuchEventException) {
-                // The event or occurrence is already gone: the same answer the
-                // pre-check gives, and better than a bare "couldn't save".
-                SaveUiState.Gone
             } catch (e: Exception) {
-                // The user only gets a generic snackbar, so without this a failed
-                // write leaves nothing to report (Codeberg #234). Scope and event
-                // id only — never the form's content.
-                Log.w(TAG, "Save failed (scope=$scope, eventId=${target?.eventId})", e)
                 SaveUiState.Failed
             }
         }

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

@@ -23,7 +23,6 @@ import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Check
 import androidx.compose.material.icons.filled.Close
-import androidx.compose.material.icons.filled.PriorityHigh
 import androidx.compose.material3.Button
 import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.ExperimentalMaterial3Api
@@ -94,11 +93,15 @@ fun ImportScreen(
     }
 
     // Hoisted target calendar so the always-visible top-bar Import action can
-    // read it without the user scrolling to a bottom button (see
-    // [defaultImportTarget] for the choice). Re-defaults when the "many" list
-    // first arrives (keyed on it), then holds the pick.
+    // read it without the user scrolling to a bottom button. Defaults to the
+    // first *local* calendar — the first row the picker shows ("Your calendars"
+    // group leads) — so the pre-selection lines up with the top of the list;
+    // falls back to the first calendar if there are no local ones. Re-defaults
+    // when the "many" list first arrives (keyed on it), then holds the pick.
     val many = state as? ImportUiState.Many
-    val defaultTarget = many?.let { defaultImportTarget(it.calendars, it.fileCalendarName) }
+    val defaultTarget = many?.calendars?.let { cals ->
+        (cals.firstOrNull { it.isLocal } ?: cals.firstOrNull())?.id
+    }
     var selected by rememberSaveable(defaultTarget) { mutableStateOf(defaultTarget) }
 
     Scaffold(
@@ -220,10 +223,6 @@ private fun DoneContent(state: ImportUiState.Done, onClose: () -> Unit) {
         )
     }
 
-    // Part of the file never reached the calendar, so the screen doesn't get to
-    // read as a plain success.
-    val stopped = state.summary.notAttempted > 0
-
     Column(
         Modifier.fillMaxSize().padding(24.dp),
         horizontalAlignment = Alignment.CenterHorizontally,
@@ -237,43 +236,22 @@ private fun DoneContent(state: ImportUiState.Done, onClose: () -> Unit) {
                     scaleY = badgeScale.value
                 }
                 .clip(CircleShape)
-                .background(
-                    if (stopped) {
-                        MaterialTheme.colorScheme.errorContainer
-                    } else {
-                        MaterialTheme.colorScheme.primaryContainer
-                    },
-                ),
+                .background(MaterialTheme.colorScheme.primaryContainer),
             contentAlignment = Alignment.Center,
         ) {
             Icon(
-                if (stopped) Icons.Default.PriorityHigh else Icons.Default.Check,
+                Icons.Default.Check,
                 contentDescription = null,
-                tint = if (stopped) {
-                    MaterialTheme.colorScheme.onErrorContainer
-                } else {
-                    MaterialTheme.colorScheme.onPrimaryContainer
-                },
+                tint = MaterialTheme.colorScheme.onPrimaryContainer,
                 modifier = Modifier.size(56.dp),
             )
         }
         Spacer(Modifier.height(24.dp))
         Text(
-            stringResource(
-                if (stopped) R.string.import_done_stopped_title else R.string.import_done_title,
-            ),
+            stringResource(R.string.import_done_title),
             style = MaterialTheme.typography.headlineSmall,
             color = MaterialTheme.colorScheme.onSurface,
         )
-        if (state.summary.failed > 0) {
-            Spacer(Modifier.height(8.dp))
-            Text(
-                stringResource(R.string.import_done_failed_note),
-                style = MaterialTheme.typography.bodyMedium,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                textAlign = TextAlign.Center,
-            )
-        }
         if (state.summary.skippedDuplicate > 0) {
             Spacer(Modifier.height(8.dp))
             Text(
@@ -283,21 +261,6 @@ private fun DoneContent(state: ImportUiState.Done, onClose: () -> Unit) {
                 textAlign = TextAlign.Center,
             )
         }
-        // The one note that isn't about individual events: the counts below cover
-        // the part of the file that was tried, so say how much never was.
-        if (stopped) {
-            Spacer(Modifier.height(8.dp))
-            Text(
-                pluralStringResource(
-                    R.plurals.import_done_stopped,
-                    state.summary.notAttempted,
-                    state.summary.notAttempted,
-                ),
-                style = MaterialTheme.typography.bodyMedium,
-                color = MaterialTheme.colorScheme.error,
-                textAlign = TextAlign.Center,
-            )
-        }
         Spacer(Modifier.height(24.dp))
         Row(
             Modifier.fillMaxWidth(),
@@ -327,19 +290,6 @@ private fun DoneContent(state: ImportUiState.Done, onClose: () -> Unit) {
                     onContainer = MaterialTheme.colorScheme.onSurfaceVariant,
                 )
             }
-            if (state.summary.failed > 0) {
-                ImportStatCard(
-                    count = state.summary.failed,
-                    label = stringResource(R.string.import_done_failed_label),
-                    contentDescription = pluralStringResource(
-                        R.plurals.import_done_failed,
-                        state.summary.failed,
-                        state.summary.failed,
-                    ),
-                    container = MaterialTheme.colorScheme.errorContainer,
-                    onContainer = MaterialTheme.colorScheme.onErrorContainer,
-                )
-            }
         }
         Spacer(Modifier.weight(1f))
         Button(
@@ -351,7 +301,7 @@ private fun DoneContent(state: ImportUiState.Done, onClose: () -> Unit) {
     }
 }
 
-/** A big-number tonal tile summarising one import outcome (added / skipped / failed). */
+/** A big-number tonal tile summarising one import outcome (added / skipped). */
 @Composable
 private fun RowScope.ImportStatCard(
     count: Int,
@@ -393,9 +343,6 @@ private fun WarningText(warning: IcsParseWarning) {
         IcsParseWarning.EventWithoutStartSkipped -> stringResource(R.string.import_warning_no_start)
         IcsParseWarning.AttendeesIgnored -> stringResource(R.string.import_warning_attendees)
         IcsParseWarning.UnknownTimezone -> stringResource(R.string.import_warning_timezone)
-        IcsParseWarning.TasksImportedAsEvents -> stringResource(R.string.import_warning_tasks)
-        IcsParseWarning.RecurrenceRuleRepaired ->
-            stringResource(R.string.import_warning_recurrence_repaired)
     }
     Text(
         text = text,

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

@@ -43,12 +43,6 @@ sealed interface ImportUiState {
         val events: List<ParsedIcsEvent>,
         val warnings: Set<IcsParseWarning>,
         val calendars: List<CalendarSource>,
-        /**
-         * The calendar the file says its events came from, when every one of
-         * them names the same — used to preselect a matching target (see
-         * [fileCalendarName]).
-         */
-        val fileCalendarName: String? = null,
     ) : ImportUiState
 
     data class Done(val summary: IcsImportSummary) : ImportUiState
@@ -98,7 +92,6 @@ class ImportViewModel @Inject constructor(
                         warnings = parsed.warnings,
                         calendars = repository.calendars().first()
                             .filter { it.isEventTarget },
-                        fileCalendarName = fileCalendarName(parsed.events),
                     )
                 }
             }
@@ -120,33 +113,3 @@ class ImportViewModel @Inject constructor(
         }
     }
 }
-
-/**
- * The one calendar [events] all came from, or null.
- *
- * Every event has to agree, unnamed ones included: a foreign file where a single
- * `VEVENT` carries a `CATEGORIES` tag and the rest carry nothing names no
- * calendar — it just has one tagged event, and letting it pick the target would
- * land the whole file wherever that tag happens to match.
- */
-internal fun fileCalendarName(events: List<ParsedIcsEvent>): String? =
-    events.map { it.calendarName }.distinct().singleOrNull()
-
-/**
- * The target calendar to preselect for a bulk import.
- *
- * A calendar named like the one the file came from wins — restoring "Birthdays"
- * onto the Birthdays calendar is what the user means. Otherwise the first
- * *local* calendar, which is the first row the picker shows ("Your calendars"
- * leads), so the pre-selection lines up with the top of the list; failing that
- * the first calendar of any kind.
- */
-internal fun defaultImportTarget(
-    calendars: List<CalendarSource>,
-    fileCalendarName: String?,
-): Long? {
-    val named = fileCalendarName?.let { name ->
-        calendars.firstOrNull { it.displayName.equals(name, ignoreCase = true) }
-    }
-    return (named ?: calendars.firstOrNull { it.isLocal } ?: calendars.firstOrNull())?.id
-}

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

@@ -1,19 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.month
-
-import androidx.compose.ui.unit.dp
-
-// The month grid's chip geometry, together in one file: these derive from each
-// other, and a top-level val reading one across a file boundary would resolve
-// against whichever class the JVM happened to initialise first.
-
-/** Gap between a day cell and its neighbours. */
-internal val CELL_GAP = 2.dp
-
-/** Padding between a month chip's edge and its text. */
-internal val MONTH_CHIP_TEXT_PADDING = 4.dp
-
-/** A chip's own inset inside its day cell, on top of the cell's gap. */
-internal val MONTH_CHIP_INSET = CELL_GAP + 1.dp
-
-/** Horizontal space a chip spends on chrome rather than on text, both sides. */
-internal val MONTH_CHIP_CHROME = (MONTH_CHIP_INSET + MONTH_CHIP_TEXT_PADDING) * 2f

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

@@ -1,33 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.month
-
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.unit.Dp
-import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.ui.common.formatTimeOfDay
-import de.jeanlucmakiola.calendula.ui.common.rememberInlineTimeWidth
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.toLocalDateTime
-import java.util.Locale
-
-/**
- * The start time a chip shows before its title (#219), or null when it has none
- * to show: an all-day chip never carries a time, and neither does a bar carried
- * in from an earlier week, whose start is not in this segment.
- */
-internal fun monthChipTime(
-    event: EventInstance,
-    continuesLeft: Boolean,
-    zone: TimeZone,
-    is24Hour: Boolean,
-    locale: Locale,
-): String? {
-    if (event.isAllDay || continuesLeft) return null
-    val start = event.start.toLocalDateTime(zone).time
-    return formatTimeOfDay(start.hour, start.minute, is24Hour, locale)
-}
-
-/** The narrowest chip that may show a time — the text it needs, plus its chrome. */
-@Composable
-internal fun rememberMonthTimeChipWidth(): Dp =
-    rememberInlineTimeWidth(MaterialTheme.typography.labelSmall) + MONTH_CHIP_CHROME

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

@@ -13,8 +13,6 @@ 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 kotlinx.datetime.LocalDate
 import kotlin.math.abs
 
@@ -35,8 +33,6 @@ class MonthRowGeometry(
     val isRtl: Boolean,
     /** What this row currently draws in [lane] of column `col`, or null. */
     val chipAt: (col: Int, lane: Int) -> EventInstance?,
-    /** The column the chip in [lane] of column `col` is drawn from. */
-    val chipStart: (col: Int, lane: Int) -> Int,
 ) {
     /** Root top-left of the chip seated in [lane] of column [col]. */
     fun seat(col: Int, lane: Int): Offset? {
@@ -51,43 +47,21 @@ class MonthRowGeometry(
      * the day isn't in this week, or the chip went into the day's "+N" overflow.
      */
     fun seatOf(event: EventInstance, date: LocalDate): Offset? {
-        val (col, lane) = chipSeat(days, laneCount, chipAt, chipStart, event, date) ?: return null
+        val col = days.indexOf(date).takeIf { it >= 0 } ?: return null
+        val lane = (0 until laneCount).firstOrNull { lane ->
+            chipAt(col, lane)?.let { isSameEvent(it, event) } == true
+        } ?: return null
         return seat(col, lane)
     }
 }
 
-/**
- * The column and lane a row draws [event]'s chip in, given it covers [date] —
- * null when the row seats no such chip. The column is the *left end* of the bar
- * within this row, not [date]'s own: a bar spanning several days is drawn once,
- * from its first column, so an event dropped onto the second day it covers is
- * seated a column (or more) to the left of where it landed (#253).
- */
-internal fun chipSeat(
-    days: List<LocalDate>,
-    laneCount: Int,
-    chipAt: (col: Int, lane: Int) -> EventInstance?,
-    chipStart: (col: Int, lane: Int) -> Int,
-    event: EventInstance,
-    date: LocalDate,
-): Pair<Int, Int>? {
-    val col = days.indexOf(date).takeIf { it >= 0 } ?: return null
-    val lane = (0 until laneCount).firstOrNull { lane ->
-        chipAt(col, lane)?.let { isSameEvent(it, event) } == true
-    } ?: return null
-    return chipStart(col, lane) to lane
-}
-
 /**
  * Whether [chip] is the moved event [moved] as the grid now holds it. Neither id
  * alone will do: re-read instances get new instance ids, and a single-occurrence
- * move writes a new event id — the title survives both. A *blank* title is no
- * evidence at all, though: every untitled event carries one, so matching on it
- * made any two of them the same event (#253).
+ * move writes a new event id — the title survives both.
  */
-internal fun isSameEvent(chip: EventInstance, moved: EventInstance): Boolean =
-    chip.eventId == moved.eventId ||
-        (moved.title.isNotBlank() && chip.title == moved.title)
+private fun isSameEvent(chip: EventInstance, moved: EventInstance): Boolean =
+    chip.eventId == moved.eventId || chip.title == moved.title
 
 /** A chip in flight, in root coordinates so it can be drawn in an overlay. */
 data class MonthChipDrag(
@@ -97,13 +71,6 @@ data class MonthChipDrag(
     val targetDate: LocalDate?,
     val topLeftInRoot: Offset,
     val sizePx: IntSize,
-    /**
-     * The start time of the chip this lifted off, already formatted (#219).
-     * Carried rather than re-derived: the overlay has no row to ask whether the
-     * bar was carried in from the previous week, and no zone the grid laid out
-     * in. Null where the source chip had no time to show.
-     */
-    val time: String? = null,
 )
 
 /** Where a finished chip drag asks its event to go, as a whole-day shift. */
@@ -167,19 +134,8 @@ class MonthDragController {
      */
     private var undoable: MonthChipDrag? = null
 
-    /**
-     * 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 chip was let go. */
-    var settledAbandonedMark: Int = 0
-        private set
-
     private var event: EventInstance? = null
     private var grabDate: LocalDate? = null
-    private var time: String? = null
     private var grab = Offset.Zero
     private var pointer = Offset.Zero
     private var sizePx = IntSize.Zero
@@ -198,11 +154,9 @@ class MonthDragController {
         pointerInRoot: Offset,
         chipInRoot: Offset,
         size: IntSize,
-        time: String? = null,
     ) {
         this.event = event
         this.grabDate = grabDate
-        this.time = time
         settling = null
         isDragging = true
         liftedInstanceId = event.instanceId
@@ -220,7 +174,6 @@ class MonthDragController {
     fun cancel() {
         event = null
         grabDate = null
-        time = null
         isDragging = false
         liftedInstanceId = null
         drag = null
@@ -269,7 +222,6 @@ class MonthDragController {
         liftedInstanceId = last.event.instanceId
         settledGhost = true
         settledInRoot = null
-        settledAbandonedMark = abandonedTicks?.value ?: 0
         return true
     }
 
@@ -290,7 +242,6 @@ class MonthDragController {
         liftedInstanceId = landed.event.instanceId
         settledGhost = true
         undoable = settling
-        settledAbandonedMark = abandonedTicks?.value ?: 0
         return MonthChipDrop(landed.event, landed.grabDate, target)
     }
 
@@ -342,16 +293,11 @@ class MonthDragController {
             targetDate = resolved ?: drag?.targetDate,
             topLeftInRoot = pointer - grab,
             sizePx = sizePx,
-            time = time,
         )
     }
 }
 
 @Composable
-fun rememberMonthDragController(): MonthDragController {
-    val controller = remember { MonthDragController() }
-    controller.abandonedTicks = LocalEventMove.current?.abandoned
-    return controller
-}
+fun rememberMonthDragController(): MonthDragController = remember { MonthDragController() }
 
 val LocalMonthDrag = compositionLocalOf<MonthDragController?> { null }

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

@@ -19,8 +19,6 @@ import androidx.compose.animation.togetherWith
 import androidx.compose.foundation.background
 import androidx.compose.foundation.border
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.gestures.awaitEachGesture
-import androidx.compose.foundation.gestures.awaitFirstDown
 import androidx.compose.foundation.gestures.detectDragGestures
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
@@ -88,18 +86,13 @@ import androidx.compose.ui.platform.LocalLayoutDirection
 import androidx.compose.ui.semantics.clearAndSetSemantics
 import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.geometry.Offset
-import de.jeanlucmakiola.calendula.ui.common.eventPaint
-import de.jeanlucmakiola.calendula.ui.common.eventSurface
-import de.jeanlucmakiola.calendula.ui.common.monthBarCuts
 import kotlin.math.roundToInt
 import de.jeanlucmakiola.calendula.ui.common.rememberDragSurface
 import de.jeanlucmakiola.calendula.ui.common.eventMoveAction
-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.OnUndoStarted
 import de.jeanlucmakiola.calendula.ui.common.ghostAlpha
 import de.jeanlucmakiola.calendula.ui.common.DragSnapHaptics
@@ -117,7 +110,7 @@ import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.geometry.Size
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.drawscope.Stroke
-import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.res.stringResource
@@ -126,7 +119,6 @@ import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -138,7 +130,6 @@ import de.jeanlucmakiola.calendula.ui.agenda.AgendaEmptyDayRow
 import de.jeanlucmakiola.calendula.ui.agenda.AgendaEventRow
 import de.jeanlucmakiola.calendula.ui.common.formatCalendarTitle
 import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
-import de.jeanlucmakiola.calendula.ui.common.AppBarSpacing
 import de.jeanlucmakiola.calendula.ui.common.CalendarTitleButton
 import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
 import de.jeanlucmakiola.calendula.ui.common.TodayAction
@@ -149,11 +140,9 @@ import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
 import de.jeanlucmakiola.calendula.ui.common.LocalDimCutoff
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
-import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
-import de.jeanlucmakiola.calendula.ui.common.inlineTimeLabel
 import de.jeanlucmakiola.calendula.ui.common.eventAccent
-import de.jeanlucmakiola.calendula.ui.common.EventChipShape
-import de.jeanlucmakiola.calendula.ui.common.monthBarShape
+import de.jeanlucmakiola.calendula.ui.common.eventFill
+import de.jeanlucmakiola.calendula.ui.common.eventInk
 import de.jeanlucmakiola.calendula.ui.common.rememberCurrentMinute
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
@@ -216,6 +205,7 @@ fun MonthScreen(
         derivedStateOf { if (dimCompleted) nowState.value else null }
     }
 
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
     val drawerState = rememberDrawerState(DrawerValue.Closed)
     val scope = rememberCoroutineScope()
 
@@ -301,14 +291,10 @@ fun MonthScreen(
     // carries the year instead of repeating it two lines further down. Dense has
     // no header to defer to, so it keeps the full title.
     val locale = currentLocale()
-    val (topBarTitle, topBarShortTitle) = remember(viewStyle, titleMonth, locale, today.year) {
-        if (viewStyle == MonthViewStyle.Continuous) {
-            val year = titleMonth.year.toString()
-            year to year
-        } else {
-            formatMonthTitle(titleMonth, locale, currentYear = today.year) to
-                formatMonthTitle(titleMonth, locale, currentYear = today.year, abbreviated = true)
-        }
+    val topBarTitle = if (viewStyle == MonthViewStyle.Continuous) {
+        titleMonth.year.toString()
+    } else {
+        formatMonthTitle(titleMonth, locale, currentYear = today.year)
     }
 
     // Slide direction for the grid transition: +1 = next, -1 = prev, 0 = jump (no slide).
@@ -393,20 +379,19 @@ fun MonthScreen(
         },
     ) {
         Scaffold(
-            modifier = modifier,
+            modifier = modifier.nestedScroll(scrollBehavior.nestedScrollConnection),
             topBar = {
                 MonthTopBar(
                     title = topBarTitle,
-                    shortTitle = topBarShortTitle,
                     titleDate = LocalDate(titleMonth.year, titleMonth.month, 1),
                     selectedView = selectedView,
                     onCycleView = { onSelectView(selectedView.next(quickSwitchViews)) },
-                    quickSwitchViews = quickSwitchViews,
                     onOpenDrawer = { scope.launch { drawerState.open() } },
                     onOpenSearch = onOpenSearch,
                     onJumpToDate = jumpToDate,
                     showTodayButton = todayInToolbar,
                     onToday = jumpToToday,
+                    scrollBehavior = scrollBehavior,
                 )
             },
             floatingActionButton = {
@@ -454,7 +439,6 @@ fun MonthScreen(
                             showWeekNumbers = showWeekNumbers,
                             onRetry = jumpToToday,
                             onOpenDay = onOpenDay,
-                            onEventClick = onEventClick,
                         )
                     } else if (viewStyle == MonthViewStyle.Split) {
                         SplitMonthContent(
@@ -479,7 +463,6 @@ fun MonthScreen(
                             onSwipePrev = goPrev,
                             onRetry = jumpToToday,
                             onOpenDay = onOpenDay,
-                            onEventClick = onEventClick,
                         )
                     }
                 }
@@ -502,7 +485,6 @@ private fun MonthDragOverlay(controller: MonthDragController) {
     var origin by remember { mutableStateOf(Offset.Zero) }
     val dark = isSystemInDarkTheme()
     val density = LocalDensity.current
-    val timeChipWidth = rememberMonthTimeChipWidth()
     val reduceMotion = rememberReduceMotion()
     val moveInFlight = moveInFlight()
     // Here rather than beside the controller: this reads [drag], which changes
@@ -517,14 +499,11 @@ private fun MonthDragOverlay(controller: MonthDragController) {
     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) {
+    LaunchedEffect(controller.settling, moveInFlight, seat) {
         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)
+            delay(MONTH_SETTLE_TIMEOUT_MILLIS)
         } else {
             if (!gliding) glide.snapTo(landed.topLeftInRoot)
             gliding = true
@@ -560,11 +539,6 @@ private fun MonthDragOverlay(controller: MonthDragController) {
             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,
-            showTime = with(density) { drag.sizePx.width.toDp() } >= timeChipWidth,
             modifier = Modifier
                 // Absolute: these are root coordinates, and the direction-aware
                 // offset would mirror them across the screen in an RTL layout.
@@ -577,13 +551,13 @@ private fun MonthDragOverlay(controller: MonthDragController) {
                 }
                 .width(with(density) { drag.sizePx.width.toDp() })
                 .height(with(density) { drag.sizePx.height.toDp() })
-                .padding(horizontal = MONTH_CHIP_INSET, vertical = 1.dp)
+                .padding(horizontal = CELL_GAP + 1.dp, vertical = 1.dp)
                 .graphicsLayer {
                     scaleX = 1f + 0.04f * lift
                     scaleY = 1f + 0.04f * lift
                     shadowElevation = 8.dp.toPx() * lift
                     alpha = copyAlpha
-                    shape = EventChipShape
+                    shape = RoundedCornerShape(4.dp)
                     clip = false
                 },
         )
@@ -599,7 +573,6 @@ private fun MonthContent(
     onSwipePrev: () -> Unit,
     onRetry: () -> Unit,
     onOpenDay: (LocalDate) -> Unit,
-    onEventClick: (EventInstance) -> Unit,
 ) {
     val slideSpec = rememberCalendarSlideSpec()
     val fadeSpec = rememberCalendarFadeSpec()
@@ -626,7 +599,6 @@ private fun MonthContent(
                 state = s,
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onOpenDay,
-                onEventClick = onEventClick,
             )
         }
     }
@@ -645,7 +617,6 @@ private fun ContinuousMonthContent(
     showWeekNumbers: Boolean,
     onRetry: () -> Unit,
     onOpenDay: (LocalDate) -> Unit,
-    onEventClick: (EventInstance) -> Unit,
 ) {
     when (state) {
         // The scrolling styles get their own skeleton rather than the paged
@@ -660,7 +631,6 @@ private fun ContinuousMonthContent(
                 listState = listState,
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onOpenDay,
-                onEventClick = onEventClick,
             )
         } else {
             ContinuousMonthGrid(
@@ -668,7 +638,6 @@ private fun ContinuousMonthContent(
                 listState = listState,
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onOpenDay,
-                onEventClick = onEventClick,
             )
         }
     }
@@ -678,16 +647,15 @@ private fun ContinuousMonthContent(
 @Composable
 private fun MonthTopBar(
     title: String,
-    shortTitle: String,
     titleDate: LocalDate,
     selectedView: CalendarView,
     onCycleView: () -> Unit,
-    quickSwitchViews: List<CalendarView>,
     onOpenDrawer: () -> Unit,
     onOpenSearch: () -> Unit,
     onJumpToDate: (LocalDate) -> Unit,
     showTodayButton: Boolean,
     onToday: () -> Unit,
+    scrollBehavior: androidx.compose.material3.TopAppBarScrollBehavior,
 ) {
     TopAppBar(
         title = {
@@ -695,7 +663,6 @@ private fun MonthTopBar(
                 title = title,
                 currentDate = titleDate,
                 onJumpToDate = onJumpToDate,
-                shortTitle = shortTitle,
             )
         },
         navigationIcon = {
@@ -716,17 +683,11 @@ private fun MonthTopBar(
             }
             ViewSwitcherPill(
                 current = selectedView,
-                cycle = quickSwitchViews,
                 onCycle = onCycleView,
+                modifier = Modifier.padding(end = 8.dp),
             )
         },
-        // Deliberately flat: M3 lifts the bar to mark content scrolling under
-        // it, but here the bar meets the header on the same surface and the
-        // tint is what makes that seam look like a separate block (#186).
-        colors = TopAppBarDefaults.topAppBarColors(
-            containerColor = MaterialTheme.colorScheme.surface,
-            scrolledContainerColor = MaterialTheme.colorScheme.surface,
-        ),
+        scrollBehavior = scrollBehavior,
     )
 }
 
@@ -741,7 +702,7 @@ internal fun WeekdayHeader(weekStart: DayOfWeek, showWeekNumbers: Boolean) {
     Row(
         modifier = Modifier
             .fillMaxWidth()
-            .padding(horizontal = AppBarSpacing.Inset, vertical = 4.dp),
+            .padding(horizontal = 8.dp, vertical = 4.dp),
     ) {
         // Reserve the gutter so the weekday labels stay over their day columns.
         if (showWeekNumbers) Spacer(Modifier.width(WEEK_NUMBER_GUTTER))
@@ -767,6 +728,7 @@ private val DAY_NUMBER_HEIGHT = 22.dp
 private val WEEK_NUMBER_GUTTER = 40.dp
 private val DAY_NUMBER_GAP = 4.dp
 private val CELL_TOP_PADDING = 6.dp
+private val CELL_GAP = 2.dp
 /** Named separately because the split style's selection outline draws its own
  *  rounded rect and has to match this radius exactly. */
 private val CELL_CORNER = 12.dp
@@ -774,8 +736,7 @@ private val CELL_SHAPE = RoundedCornerShape(CELL_CORNER)
 
 /** Width of the split style's selected-day outline. */
 private val SPLIT_SELECTION_STROKE = 1.5.dp
-/** Lanes of bars/pills a day cell draws before the rest become overflow dots. */
-internal const val MAX_EVENT_ROWS = 3
+private const val MAX_EVENT_ROWS = 3
 
 /**
  * Row height in the continuous grid. The paged grid divides the viewport between
@@ -793,41 +754,31 @@ private val CONTINUOUS_ROW_HEIGHT = 112.dp
  */
 private val CONTINUOUS_MONTH_GAP = 20.dp
 
-/** Gap between the weekday header and the seamless stream's first week row. */
-private val DENSE_HEADER_GAP = 4.dp
-
 @Composable
 internal fun MonthGrid(
     state: MonthUiState.Success,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
-    onEventClick: (EventInstance) -> Unit,
     /** See [MonthWeekRow]'s `selected`: an anchor for the morph, never a mark. */
     selected: LocalDate? = null,
 ) {
     Column(
         modifier = Modifier
             .fillMaxSize()
-            // Match the weekday header's inset so day cells sit under their
+            // Match the weekday header's 8dp inset so day cells sit under their
             // labels, and so the week-number gutter's centre lines up with the
             // top bar's hamburger (4dp bar inset + 24dp half icon button).
-            .padding(horizontal = AppBarSpacing.Inset, vertical = 4.dp),
+            .padding(horizontal = 8.dp, vertical = 4.dp),
         verticalArrangement = Arrangement.spacedBy(2.dp),
     ) {
         val month = state.month
-        // Once per grid: the value depends on the typography, the density, the
-        // locale and the 24-hour setting, none of which vary by row (#219).
-        val timeChipWidth = rememberMonthTimeChipWidth()
         state.weeks.forEach { week ->
             MonthWeekRow(
                 week = week,
                 today = state.today,
-                zone = state.zone,
-                timeChipWidth = timeChipWidth,
                 inMonth = { it.month == month.month && it.year == month.year },
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onOpenDay,
-                onEventClick = onEventClick,
                 selected = selected,
                 modifier = Modifier
                     .fillMaxWidth()
@@ -858,12 +809,10 @@ internal fun ContinuousMonthGrid(
     listState: LazyListState,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
-    onEventClick: (EventInstance) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val monthCount = remember { continuousMonthCount() }
     val todayMonth = remember(state.today) { YearMonth(state.today.year, state.today.month) }
-    val timeChipWidth = rememberMonthTimeChipWidth()
     LazyColumn(
         state = listState,
         modifier = modifier.fillMaxSize(),
@@ -885,11 +834,8 @@ internal fun ContinuousMonthGrid(
                     weeks = state.monthsByIndex[index],
                     weekStart = state.weekStart,
                     today = state.today,
-                    zone = state.zone,
-                    timeChipWidth = timeChipWidth,
                     showWeekNumbers = showWeekNumbers,
                     onOpenDay = onOpenDay,
-                    onEventClick = onEventClick,
                 )
             }
         }
@@ -907,17 +853,14 @@ private fun ContinuousMonthBlock(
     weeks: List<MonthWeek>?,
     weekStart: DayOfWeek,
     today: LocalDate,
-    zone: TimeZone,
-    timeChipWidth: Dp,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
-    onEventClick: (EventInstance) -> Unit,
 ) {
     val rowCount = remember(month, weekStart) { weekRowsInMonth(month, weekStart) }
     Column(
         modifier = Modifier
             .fillMaxWidth()
-            .padding(horizontal = AppBarSpacing.Inset)
+            .padding(horizontal = 8.dp)
             .padding(bottom = CONTINUOUS_MONTH_GAP),
         verticalArrangement = Arrangement.spacedBy(2.dp),
     ) {
@@ -928,15 +871,12 @@ private fun ContinuousMonthBlock(
                 MonthWeekRow(
                     week = week,
                     today = today,
-                    zone = zone,
-                    timeChipWidth = timeChipWidth,
                     inMonth = { it.month == month.month && it.year == month.year },
                     // The block owns its month alone: a day from either
                     // neighbour is left out entirely rather than dimmed.
                     blankOutside = true,
                     showWeekNumbers = showWeekNumbers,
                     onOpenDay = onOpenDay,
-                    onEventClick = onEventClick,
                     modifier = Modifier
                         .fillMaxWidth()
                         .height(CONTINUOUS_ROW_HEIGHT),
@@ -995,24 +935,17 @@ internal fun DenseMonthGrid(
     listState: LazyListState,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
-    onEventClick: (EventInstance) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val weekCount = remember(state.weekStart) { continuousWeekCount(state.weekStart) }
-    val timeChipWidth = rememberMonthTimeChipWidth()
     LazyColumn(
         state = listState,
         modifier = modifier
             .fillMaxSize()
-            // The gap under the weekday header is a real margin, not content
-            // padding: a lazy list scrolls its rows *through* the before-content
-            // padding, so scrolling to a week landed its row that far down with
-            // the tail of the previous one showing above it (#191).
-            .padding(horizontal = AppBarSpacing.Inset)
-            .padding(top = DENSE_HEADER_GAP),
+            .padding(horizontal = 8.dp),
         verticalArrangement = Arrangement.spacedBy(2.dp),
         // Bottom inset clears the FAB stack so the last row stays tappable.
-        contentPadding = PaddingValues(bottom = 96.dp),
+        contentPadding = PaddingValues(top = 4.dp, bottom = 96.dp),
     ) {
         items(count = weekCount, key = { it }) { index ->
             val week = state.weeksByIndex[index]
@@ -1022,14 +955,11 @@ internal fun DenseMonthGrid(
                 MonthWeekRow(
                     week = week,
                     today = state.today,
-                    zone = state.zone,
-                    timeChipWidth = timeChipWidth,
                     // Every day in the stream belongs to a month equally — there
                     // is no "other month" to recede here.
                     inMonth = { true },
                     showWeekNumbers = showWeekNumbers,
                     onOpenDay = onOpenDay,
-                    onEventClick = onEventClick,
                     labelMonthOnFirst = true,
                     modifier = Modifier
                         .fillMaxWidth()
@@ -1257,9 +1187,6 @@ private fun SplitMonthBody(
                 onSelectDay(it)
                 onSetExpanded(false)
             },
-            // A tapped chip is asking for that event, not for its day, so it
-            // opens the detail from here too rather than collapsing (#187).
-            onEventClick = onEventClick,
             onCollapse = { onSetExpanded(false) },
         )
     } else {
@@ -1360,7 +1287,6 @@ private fun SplitMonthExpanded(
     showWeekNumbers: Boolean,
     swipeModifier: Modifier,
     onPickDay: (LocalDate) -> Unit,
-    onEventClick: (EventInstance) -> Unit,
     onCollapse: () -> Unit,
 ) {
     val slideSpec = rememberCalendarSlideSpec()
@@ -1383,7 +1309,6 @@ private fun SplitMonthExpanded(
                 state = s,
                 showWeekNumbers = showWeekNumbers,
                 onOpenDay = onPickDay,
-                onEventClick = onEventClick,
                 selected = sel,
             )
         }
@@ -1477,7 +1402,7 @@ internal fun SplitMonthGrid(
     Column(
         modifier = modifier
             .fillMaxWidth()
-            .padding(horizontal = AppBarSpacing.Inset, vertical = 4.dp),
+            .padding(horizontal = 8.dp, vertical = 4.dp),
         verticalArrangement = Arrangement.spacedBy(2.dp),
     ) {
         state.weeks.forEach { week ->
@@ -1842,7 +1767,7 @@ private fun ContinuousMonthSkeleton(dense: Boolean) {
     Column(
         modifier = Modifier
             .fillMaxSize()
-            .padding(horizontal = AppBarSpacing.Inset)
+            .padding(horizontal = 8.dp)
             .clipToBounds(),
     ) {
         if (!dense) {
@@ -1864,7 +1789,7 @@ private fun ContinuousMonthSkeleton(dense: Boolean) {
                 modifier = Modifier.padding(bottom = 8.dp),
             )
         } else {
-            Spacer(Modifier.height(DENSE_HEADER_GAP))
+            Spacer(Modifier.height(4.dp))
         }
         // More rows than a viewport holds; the clip takes the overflow.
         repeat(6) {
@@ -1909,14 +1834,9 @@ private fun rememberSkeletonPulse(): Float {
 private fun MonthWeekRow(
     week: MonthWeek,
     today: LocalDate,
-    /** The zone the grid was laid out in — never re-read here (see [MonthUiState.Success.zone]). */
-    zone: TimeZone,
-    /** The narrowest chip that may carry a start time, measured once per grid (#219). */
-    timeChipWidth: Dp,
     inMonth: (LocalDate) -> Boolean,
     showWeekNumbers: Boolean,
     onOpenDay: (LocalDate) -> Unit,
-    onEventClick: (EventInstance) -> Unit,
     modifier: Modifier = Modifier,
     blankOutside: Boolean = false,
     labelMonthOnFirst: Boolean = false,
@@ -1932,27 +1852,6 @@ private fun MonthWeekRow(
     val laneCount = (week.spans.maxOfOrNull { it.lane } ?: -1) + 1
     val shownLanes = laneCount.coerceAtMost(MAX_EVENT_ROWS)
     val morphing = morphInFlight()
-    // Every chip's start time for this row at once, and only when the row's own
-    // inputs change: formatting is a parsed pattern per call, and the dim cutoff
-    // ticks every minute while a drag recomposes every frame (#219).
-    val is24Hour = LocalUse24HourFormat.current
-    val locale = currentLocale()
-    val chipTimes = remember(week, zone, is24Hour, locale) {
-        buildMap {
-            week.spans.forEach { span ->
-                put(
-                    span.event.instanceId,
-                    monthChipTime(span.event, span.continuesLeft, zone, is24Hour, locale),
-                )
-            }
-            week.timedByDay.values.flatten().forEach { event ->
-                put(
-                    event.instanceId,
-                    monthChipTime(event, continuesLeft = false, zone, is24Hour, locale),
-                )
-            }
-        }
-    }
 
     // Drag to reschedule (#68). The chips can take no pointer input of their own
     // — the full-bleed tap layer sits on top of them — so one detector on the
@@ -1986,7 +1885,6 @@ private fun MonthWeekRow(
                     laneCount = MAX_EVENT_ROWS,
                     isRtl = isRtl,
                     chipAt = { col, lane -> week.chipAt(col, lane, MAX_EVENT_ROWS) },
-                    chipStart = { col, lane -> week.chipStartCol(col, lane) },
                 ),
             )
         }
@@ -2027,12 +1925,9 @@ private fun MonthWeekRow(
                         band = bandCoordinates,
                         rowHeightPx = rowHeightPx,
                         isRtl = isRtl,
-                        chipTimes = chipTimes,
                     ),
                 ),
         ) {
-            // What a chip has to spend, against the [timeChipWidth] a start time
-            // costs it (#219).
             val colW = maxWidth / 7
 
             // Per-day background pills — same surfaceContainer rounded surface the
@@ -2113,8 +2008,6 @@ private fun MonthWeekRow(
                             continuesLeft = span.continuesLeft,
                             continuesRight = span.continuesRight,
                             days = week.days.subList(span.startCol, span.endCol + 1),
-                            time = chipTimes[span.event.instanceId],
-                            showTime = colW * cols >= timeChipWidth,
                             modifier = Modifier
                                 .offset(
                                     x = colW * span.startCol,
@@ -2138,7 +2031,7 @@ private fun MonthWeekRow(
                                 )
                                 .width(colW * cols)
                                 .height(EVENT_ROW_HEIGHT)
-                                .padding(horizontal = MONTH_CHIP_INSET, vertical = 1.dp),
+                                .padding(horizontal = CELL_GAP + 1.dp, vertical = 1.dp),
                         )
                         // One invisible slice of the bar per further column it
                         // covers. A multi-day event has a dot on every day but
@@ -2162,7 +2055,7 @@ private fun MonthWeekRow(
                                     )
                                     .width(colW)
                                     .height(EVENT_ROW_HEIGHT)
-                                    .padding(horizontal = MONTH_CHIP_INSET, vertical = 1.dp),
+                                    .padding(horizontal = CELL_GAP + 1.dp, vertical = 1.dp),
                             )
                         }
                     }
@@ -2185,8 +2078,6 @@ private fun MonthWeekRow(
                                 continuesLeft = false,
                                 continuesRight = false,
                                 days = listOf(d),
-                                time = chipTimes[ev.instanceId],
-                                showTime = colW >= timeChipWidth,
                                 modifier = Modifier
                                     .offset(
                                         x = colW * col,
@@ -2195,7 +2086,7 @@ private fun MonthWeekRow(
                                     .morphBounds(MonthMorphKey.Event(d, ev.instanceId))
                                     .width(colW)
                                     .height(EVENT_ROW_HEIGHT)
-                                    .padding(horizontal = MONTH_CHIP_INSET, vertical = 1.dp),
+                                    .padding(horizontal = CELL_GAP + 1.dp, vertical = 1.dp),
                             )
                         }
                         val hidden = (week.countByDay[d] ?: 0) - occupied.size - pillsShown.size
@@ -2244,17 +2135,11 @@ private fun MonthWeekRow(
                 }
             }
 
-            // Tap layer: a tap on a chip opens that event, anything else opens the
-            // day (#187). The chips take no pointer input of their own — this
-            // layer covers them — so the lane under the finger is resolved
-            // geometrically, exactly as the drag pickup above does it; the down
-            // position is read on the initial pass, which consumes nothing and so
-            // leaves both the click and a pickup in flight untouched. Padded and
+            // Tap layer: in month view a tap on any day opens that day. Padded and
             // clipped to the background pill so the ripple matches it. A blanked
             // cell isn't part of this month, so it takes no taps either.
-            val downY = remember(week.days.size) { FloatArray(week.days.size) { NO_DOWN_Y } }
             Row(Modifier.matchParentSize()) {
-                week.days.forEachIndexed { col, d ->
+                week.days.forEach { d ->
                     if (blankOutside && !inMonth(d)) {
                         Spacer(Modifier.weight(1f).fillMaxHeight())
                     } else {
@@ -2262,33 +2147,9 @@ private fun MonthWeekRow(
                             Modifier
                                 .weight(1f)
                                 .fillMaxHeight()
-                                .pointerInput(col) {
-                                    awaitEachGesture {
-                                        downY[col] = awaitFirstDown(
-                                            requireUnconsumed = false,
-                                            pass = PointerEventPass.Initial,
-                                        ).position.y
-                                    }
-                                }
                                 .padding(horizontal = CELL_GAP, vertical = 1.dp)
                                 .clip(CELL_SHAPE)
-                                .clickable {
-                                    // Cleared on read: a click with no fresh down
-                                    // (TalkBack, D-pad) would otherwise resolve the
-                                    // previous tap's position and reopen its chip.
-                                    val cellY = downY[col]
-                                    downY[col] = NO_DOWN_Y
-                                    val chip = week.chipAtCellY(
-                                        col = col,
-                                        cellY = cellY,
-                                        bandTopInCell = bandTopInCell(
-                                            cellCoordinates,
-                                            bandCoordinates,
-                                        ),
-                                        rowHeightPx = rowHeightPx,
-                                    )
-                                    if (chip != null) onEventClick(chip) else onOpenDay(d)
-                                },
+                                .clickable { onOpenDay(d) },
                         )
                     }
                 }
@@ -2297,43 +2158,6 @@ private fun MonthWeekRow(
     }
 }
 
-/**
- * How far the event band sits below the top of the row's day-column box, or null
- * while either is unmeasured. Read off the live coordinates rather than summed
- * from the padding constants, so it can't drift from what the row actually drew.
- */
-private fun bandTopInCell(
-    cell: Array<LayoutCoordinates?>,
-    band: Array<LayoutCoordinates?>,
-): Float? {
-    val cellTop = cell[0]?.takeIf { it.isAttached }?.positionInRoot()?.y ?: return null
-    val bandTop = band[0]?.takeIf { it.isAttached }?.positionInRoot()?.y ?: return null
-    return bandTop - cellTop
-}
-
-/**
- * Stand-in [cellY] for "no touch down recorded", which resolves to no chip.
- */
-private const val NO_DOWN_Y = Float.NEGATIVE_INFINITY
-
-/**
- * The chip at [cellY] in column [col], where [cellY] is measured from the top of
- * the row's day-column box. Null for a tap above the band (the day number), on an
- * empty lane, or on the overflow dots — all of which mean "open the day", the
- * dots included: their point is that the day holds more than fits.
- */
-internal fun MonthWeek.chipAtCellY(
-    col: Int,
-    cellY: Float,
-    bandTopInCell: Float?,
-    rowHeightPx: Float,
-): EventInstance? {
-    if (bandTopInCell == null || rowHeightPx <= 0f) return null
-    val bandY = cellY - bandTopInCell
-    if (bandY < 0f) return null
-    return chipAt(col, (bandY / rowHeightPx).toInt(), MAX_EVENT_ROWS)
-}
-
 /**
  * The row-level pickup for month chips: resolves which chip the press landed on
  * from the geometry the row just laid out, and abandons the gesture on empty
@@ -2347,11 +2171,8 @@ private fun monthChipDragModifier(
     band: Array<LayoutCoordinates?>,
     rowHeightPx: Float,
     isRtl: Boolean,
-    /** The row's formatted chip times by instance id, so the copy carries the
-     *  one its source chip had rather than deriving another (#219). */
-    chipTimes: Map<Long, String?>,
 ): Modifier = rememberDragSurface(
-    enabled = moveScope?.dragEnabled == true && controller != null,
+    enabled = moveScope != null && controller != null,
     key = week.days.first(),
     onPickUp = { local, pointerInRoot, nodeInRoot, size ->
         val bandTop = band[0]?.takeIf { it.isAttached }?.positionInRoot()?.y
@@ -2378,7 +2199,6 @@ private fun monthChipDragModifier(
                     y = requireNotNull(bandTop) + lane * rowHeightPx,
                 ),
                 size = IntSize(columnPx.toInt(), rowHeightPx.toInt()),
-                time = chipTimes[event.instanceId],
             )
             true
         }
@@ -2389,7 +2209,7 @@ private fun monthChipDragModifier(
             // How many columns the finger crossed — grabbing the middle of a
             // multi-day bar shifts by what it travelled, not to where it landed.
             val delta = (drop.targetDate.toEpochDays() - drop.grabDate.toEpochDays()).toInt()
-            moveScope?.move(
+            val took = moveScope?.move(
                 MoveRequest(
                     eventId = drop.event.eventId,
                     beginMillis = drop.event.start.toEpochMilliseconds(),
@@ -2397,6 +2217,9 @@ private fun monthChipDragModifier(
                     target = MoveTarget.ByDays(delta),
                 ),
             )
+            // Refused, so nothing will land: let the copy go now rather than
+            // hold the chip out for a settle that can never arrive.
+            if (took != true) controller?.release()
         }
     },
     onCancel = { controller?.cancel() },
@@ -2486,10 +2309,7 @@ private fun shortMonthName(date: LocalDate): String {
     }
 }
 
-/**
- * A filled event pill/bar — softened (or raw) fill, title clipped to one line,
- * with the start time before it where the chip is wide enough ([showTime], #219).
- */
+/** A filled event pill/bar — softened (or raw) fill, title clipped to one line. */
 @Composable
 private fun MonthBar(
     event: de.jeanlucmakiola.calendula.domain.EventInstance,
@@ -2503,54 +2323,41 @@ private fun MonthBar(
      * the provider hands the re-read instance a new one.
      */
     days: List<LocalDate>? = null,
-    /** The chip's start time, or null where it has none — see `monthChipTime` (#219). */
-    time: String? = null,
-    /** Whether this chip has the width to draw [time]; a screen reader gets it either way. */
-    showTime: Boolean = false,
 ) {
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
     val dimCutoff = LocalDimCutoff.current
     val dimmed = dimCutoff != null && event.hasEnded(dimCutoff)
-    val paint = eventPaint(event, dark)
-    // The same title/secondary ink pairing the week and day blocks use, with
-    // the time on the quieter half.
-    val label = inlineTimeLabel(
-        time = time.takeIf { showTime },
-        title = title,
-        timeInk = paint.secondaryInk,
-    )
-    // Announced whether or not it is drawn, and comma-separated as the week and
-    // day blocks do it: what a screen reader hears shouldn't turn on how wide
-    // the chip happens to be (#219).
-    val description = if (time != null) "$title, $time" else title
+    val soften = LocalSoftenColors.current
+    val fill = eventFill(event.color, dark, soften)
     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
     val ghost = ghostAlpha(lifted)
-    val shape = monthBarShape(continuesLeft, continuesRight)
+    val shape = RoundedCornerShape(
+        topStart = if (continuesLeft) 0.dp else 4.dp,
+        bottomStart = if (continuesLeft) 0.dp else 4.dp,
+        topEnd = if (continuesRight) 0.dp else 4.dp,
+        bottomEnd = if (continuesRight) 0.dp else 4.dp,
+    )
     Box(
         modifier = (if (dimmed) modifier.alpha(EventDimAlpha) else modifier)
             .then(if (ghost < 1f) Modifier.alpha(ghost) else Modifier)
-            .eventSurface(paint, shape, monthBarCuts(continuesLeft, continuesRight))
-            .padding(horizontal = MONTH_CHIP_TEXT_PADDING)
+            .background(fill, shape)
+            .padding(horizontal = 4.dp)
             .semantics {
-                contentDescription = description
+                contentDescription = title
                 if (moveAction != null) customActions = listOf(moveAction)
             },
         contentAlignment = Alignment.CenterStart,
     ) {
-        val titleOverflow = eventTitleOverflow()
         Text(
-            text = label,
+            text = title,
             style = MaterialTheme.typography.labelSmall,
             maxLines = 1,
-            overflow = titleOverflow.overflow,
-            softWrap = titleOverflow.softWrap,
-            color = paint.titleInk,
-            fontWeight = paint.titleWeight,
-            textDecoration = paint.decoration,
+            overflow = TextOverflow.Ellipsis,
+            color = eventInk(fill),
         )
     }
 }
@@ -2606,7 +2413,7 @@ private fun MonthGridLoading() {
     Column(
         modifier = Modifier
             .fillMaxSize()
-            .padding(horizontal = AppBarSpacing.Inset, vertical = 4.dp),
+            .padding(horizontal = 8.dp, vertical = 4.dp),
         verticalArrangement = Arrangement.spacedBy(4.dp),
     ) {
         repeat(6) {
@@ -2632,16 +2439,10 @@ private fun MonthGridLoading() {
     }
 }
 
-/** [abbreviated] swaps the full month name for its three-letter form (#165). */
-private fun formatMonthTitle(
-    ym: YearMonth,
-    locale: Locale,
-    currentYear: Int,
-    abbreviated: Boolean = false,
-): String =
+private fun formatMonthTitle(ym: YearMonth, locale: Locale, currentYear: Int): String =
     formatCalendarTitle(
         date = java.time.LocalDate.of(ym.year, ym.month.ordinal + 1, 1),
         locale = locale,
         currentYear = currentYear,
-        skeleton = if (abbreviated) "LLL" else "LLLL",
+        skeleton = "LLLL",
     )

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

@@ -1,31 +1,54 @@
 package de.jeanlucmakiola.calendula.ui.month
 
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clipToBounds
+import androidx.compose.ui.layout.layout
+import androidx.compose.ui.unit.Constraints
+import androidx.compose.ui.graphics.TransformOrigin
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.semantics.clearAndSetSemantics
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.calendula.ui.common.ScaledViewPreview
-import de.jeanlucmakiola.calendula.ui.common.sampleMonthEvents
+import de.jeanlucmakiola.calendula.domain.EventInstance
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.YearMonth
+import kotlinx.datetime.atTime
 import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Clock
+import kotlin.math.roundToInt
 
 /**
  * A live, scaled-down Month view in a given [MonthViewStyle], for the settings
- * and onboarding choosers.
+ * chooser.
+ *
+ * It renders the *real* grid composables rather than a drawing of them, so the
+ * preview cannot drift from the thing it depicts: change a cell's shape or an
+ * event bar's colour and every preview follows automatically. The trick is
+ * [requiredSize] — it ignores the incoming constraints, so the grid lays itself
+ * out at a full phone width and a plausible viewport height, and a
+ * [graphicsLayer] scale shrinks the finished layout into the card.
  *
  * The month, today's position and the week start are all real; only the events
- * are stand-ins. See [ScaledViewPreview] for how the real grid composables get
- * measured at phone size and shrunk into the card.
+ * are stand-ins, since the settings screen has no business querying the
+ * provider for a thumbnail.
  */
 @Composable
 internal fun MonthStylePreview(
@@ -34,64 +57,108 @@ internal fun MonthStylePreview(
     height: Dp,
     modifier: Modifier = Modifier,
 ) {
+    val screenWidth = LocalConfiguration.current.screenWidthDp.dp
+    val scale = height.value / VIRTUAL_HEIGHT.value
     val zone = remember { TimeZone.currentSystemDefault() }
     val today = remember(zone) { Clock.System.now().toLocalDateTime(zone).date }
     val sample = remember(today, weekStart, zone) { sampleMonthState(today, weekStart, zone) }
 
-    ScaledViewPreview(height = height, modifier = modifier) {
-        WeekdayHeader(weekStart = weekStart, showWeekNumbers = false)
-        when (style) {
-            MonthViewStyle.Paged -> MonthGrid(
-                state = sample.month,
-                showWeekNumbers = false,
-                onOpenDay = {},
-                onEventClick = {},
-            )
-            MonthViewStyle.Continuous -> ContinuousMonthGrid(
-                state = sample.continuous,
-                listState = rememberLazyListState(
-                    initialFirstVisibleItemIndex = itemIndexForMonth(
-                        monthIndexOf(YearMonth(today.year, today.month)),
-                    ),
-                ),
-                showWeekNumbers = false,
-                onOpenDay = {},
-                onEventClick = {},
-            )
-            MonthViewStyle.Dense -> DenseMonthGrid(
-                state = sample.continuous,
-                listState = rememberLazyListState(
-                    // Start a week above today's, so the preview shows a stream
-                    // running past the viewport rather than one beginning at its
-                    // top edge.
-                    initialFirstVisibleItemIndex = weekIndexOf(today, weekStart) - 1,
-                ),
-                showWeekNumbers = false,
-                onOpenDay = {},
-                onEventClick = {},
-            )
-            MonthViewStyle.Split -> {
-                SplitMonthGrid(
-                    state = sample.month,
-                    selected = today,
-                    showWeekNumbers = false,
-                    onSelectDay = {},
-                )
-                SplitDayPane(
-                    date = today,
-                    today = today,
-                    events = sample.month.instancesByDay[today].orEmpty(),
-                    zone = zone,
-                    onOpenDay = {},
-                    onEventClick = {},
-                    onCreateEvent = {},
-                    modifier = Modifier.fillMaxWidth().height(SPLIT_PANE_HEIGHT),
-                )
+    Box(
+        modifier = modifier
+            .clipToBounds()
+            .background(MaterialTheme.colorScheme.surface)
+            // A preview is a picture, not a control: swallow touches before the
+            // grid's own clickables see them, and give screen readers one label
+            // instead of six weeks of day cells.
+            .pointerInput(Unit) {
+                awaitPointerEventScope {
+                    while (true) {
+                        awaitPointerEvent(PointerEventPass.Initial).changes
+                            .forEach { it.consume() }
+                    }
+                }
+            }
+            .clearAndSetSemantics { }
+            // Measure the grid at a full phone viewport but report the scaled
+            // size, so the node occupies exactly what it draws.
+            //
+            // Modifier.requiredSize would be the obvious way to force the larger
+            // measurement, but it *centres* content that overflows the incoming
+            // constraints — which pushed the grid to a negative offset and left
+            // only its bottom-right corner inside the clip.
+            .layout { measurable, _ ->
+                val fullWidth = screenWidth.roundToPx()
+                val fullHeight = VIRTUAL_HEIGHT.roundToPx()
+                val placeable = measurable.measure(Constraints.fixed(fullWidth, fullHeight))
+                layout((fullWidth * scale).roundToInt(), (fullHeight * scale).roundToInt()) {
+                    placeable.place(0, 0)
+                }
+            }
+            .graphicsLayer {
+                scaleX = scale
+                scaleY = scale
+                transformOrigin = TransformOrigin(0f, 0f)
+            },
+    ) {
+        Column(Modifier.fillMaxSize()) {
+            WeekdayHeader(weekStart = weekStart, showWeekNumbers = false)
+                when (style) {
+                    MonthViewStyle.Paged -> MonthGrid(
+                        state = sample.month,
+                        showWeekNumbers = false,
+                        onOpenDay = {},
+                    )
+                    MonthViewStyle.Continuous -> ContinuousMonthGrid(
+                        state = sample.continuous,
+                        listState = rememberLazyListState(
+                            initialFirstVisibleItemIndex = itemIndexForMonth(
+                                monthIndexOf(YearMonth(today.year, today.month)),
+                            ),
+                        ),
+                        showWeekNumbers = false,
+                        onOpenDay = {},
+                    )
+                    MonthViewStyle.Dense -> DenseMonthGrid(
+                        state = sample.continuous,
+                        listState = rememberLazyListState(
+                            // Start a week above today's, so the preview shows a
+                            // stream running past the viewport rather than one
+                            // beginning at its top edge.
+                            initialFirstVisibleItemIndex =
+                                weekIndexOf(today, weekStart) - 1,
+                        ),
+                        showWeekNumbers = false,
+                        onOpenDay = {},
+                    )
+                    MonthViewStyle.Split -> {
+                        SplitMonthGrid(
+                            state = sample.month,
+                            selected = today,
+                            showWeekNumbers = false,
+                            onSelectDay = {},
+                        )
+                        SplitDayPane(
+                            date = today,
+                            today = today,
+                            events = sample.month.instancesByDay[today].orEmpty(),
+                            zone = zone,
+                            onOpenDay = {},
+                            onEventClick = {},
+                            onCreateEvent = {},
+                            modifier = Modifier.fillMaxWidth().height(SPLIT_PANE_HEIGHT),
+                        )
+                    }
+                }
             }
-        }
     }
 }
 
+/**
+ * The viewport the preview pretends to be: a phone's width by the height a
+ * calendar view gets under the top bar. Scaling from a fixed height keeps the
+ * three styles comparable — each shows the same slice of screen.
+ */
+private val VIRTUAL_HEIGHT = 440.dp
 private val SPLIT_PANE_HEIGHT = 170.dp
 
 private class SampleMonth(
@@ -103,6 +170,9 @@ private class SampleMonth(
  * A month's worth of stand-in events, laid out through the same
  * [layoutMonthWeeks] / [clipWeekToMonth] the live views use — so the preview
  * exercises the real span, lane and overflow logic rather than approximating it.
+ *
+ * Colours are raw ARGB on purpose: that is what the provider hands out for an
+ * event, so a token here would misrepresent what the grid actually renders.
  */
 private fun sampleMonthState(
     today: LocalDate,
@@ -111,7 +181,7 @@ private fun sampleMonthState(
 ): SampleMonth {
     val ym = YearMonth(today.year, today.month)
     val first = LocalDate(ym.year, ym.month, 1)
-    val events = sampleMonthEvents(first, today, zone)
+    val events = sampleEvents(first, today, zone)
 
     val weeks = layoutMonthWeeks(ym, weekStart, events, zone)
     val month = MonthUiState.Success(
@@ -143,3 +213,72 @@ private fun sampleMonthState(
     )
     return SampleMonth(month, continuous)
 }
+
+private val SAMPLE_COLORS = listOf(
+    0xFF3F7BD4.toInt(),
+    0xFFCE5B4C.toInt(),
+    0xFF4E9A6A.toInt(),
+    0xFF8A63C7.toInt(),
+)
+
+private fun sampleEvents(
+    firstOfMonth: LocalDate,
+    today: LocalDate,
+    zone: TimeZone,
+): List<EventInstance> {
+    var id = 0L
+    fun next() = ++id
+
+    fun timed(day: LocalDate, hour: Int, length: Int, colorIndex: Int) = EventInstance(
+        instanceId = next(),
+        eventId = id,
+        calendarId = 1L,
+        title = SAMPLE_TITLES[(id.toInt() - 1) % SAMPLE_TITLES.size],
+        start = day.atTime(hour, 0).toInstant(zone),
+        end = day.atTime(hour + length, 0).toInstant(zone),
+        isAllDay = false,
+        color = SAMPLE_COLORS[colorIndex % SAMPLE_COLORS.size],
+        location = null,
+    )
+
+    fun allDay(from: LocalDate, days: Int, colorIndex: Int) = EventInstance(
+        instanceId = next(),
+        eventId = id,
+        calendarId = 1L,
+        title = SAMPLE_TITLES[(id.toInt() - 1) % SAMPLE_TITLES.size],
+        // All-day events sit at UTC midnights with an exclusive end.
+        start = from.atTime(0, 0).toInstant(TimeZone.UTC),
+        end = from.plus(days, DateTimeUnit.DAY).atTime(0, 0).toInstant(TimeZone.UTC),
+        isAllDay = true,
+        color = SAMPLE_COLORS[colorIndex % SAMPLE_COLORS.size],
+        location = null,
+    )
+
+    // Spread across the month so most weeks carry something, with one multi-day
+    // bar to show a span bridging cells and a busy today for the split pane.
+    return buildList {
+        add(allDay(firstOfMonth.plus(9, DateTimeUnit.DAY), days = 3, colorIndex = 2))
+        add(timed(firstOfMonth.plus(1, DateTimeUnit.DAY), 9, 1, 0))
+        add(timed(firstOfMonth.plus(4, DateTimeUnit.DAY), 14, 2, 1))
+        add(timed(firstOfMonth.plus(7, DateTimeUnit.DAY), 11, 1, 3))
+        add(timed(firstOfMonth.plus(15, DateTimeUnit.DAY), 10, 1, 0))
+        add(timed(firstOfMonth.plus(18, DateTimeUnit.DAY), 16, 1, 2))
+        add(timed(firstOfMonth.plus(22, DateTimeUnit.DAY), 8, 2, 1))
+        add(timed(firstOfMonth.plus(25, DateTimeUnit.DAY), 13, 1, 3))
+        // Today, so the split pane's list and the grid's dots both have content.
+        add(timed(today, 9, 1, 0))
+        add(timed(today, 12, 1, 1))
+        add(timed(today, 15, 2, 3))
+    }
+}
+
+private val SAMPLE_TITLES = listOf(
+    "Standup",
+    "Lunch",
+    "Review",
+    "Gym",
+    "Call",
+    "Workshop",
+    "Dentist",
+    "Trip",
+)

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

@@ -74,7 +74,7 @@ fun MonthWeek.laneEvents(col: Int, day: LocalDate, laneCap: Int): List<EventInst
  */
 fun MonthWeek.chipAt(col: Int, lane: Int, laneCap: Int): EventInstance? {
     if (col !in days.indices || lane !in 0 until laneCap) return null
-    spanAt(col, lane)?.let { return it.event }
+    spans.firstOrNull { it.lane == lane && col in it.startCol..it.endCol }?.let { return it.event }
     val occupied = spans
         .filter { it.lane < laneCap && col in it.startCol..it.endCol }
         .map { it.lane }
@@ -84,19 +84,6 @@ fun MonthWeek.chipAt(col: Int, lane: Int, laneCap: Int): EventInstance? {
     return timedByDay[days[col]].orEmpty().take(free.size).getOrNull(index)
 }
 
-/**
- * The column the chip drawn in lane [lane] of column [col] begins in. A bar is
- * drawn once, from its own first column, so a chip seated by [chipAt] on the
- * second day it covers belongs a column (or more) to the left (#253). Answers
- * [col] for a single-day chip, and for an empty slot no one should be asking
- * about.
- */
-fun MonthWeek.chipStartCol(col: Int, lane: Int): Int = spanAt(col, lane)?.startCol ?: col
-
-/** The bar covering lane [lane] of column [col], or null where a pill sits there. */
-fun MonthWeek.spanAt(col: Int, lane: Int): MonthSpan? =
-    spans.firstOrNull { it.lane == lane && col in it.startCol..it.endCol }
-
 /**
  * The events on [day] that [laneEvents] had no lane left for — its exact
  * complement, in the same bars-then-pills order. Returned as events rather than
@@ -139,8 +126,6 @@ sealed interface ContinuousMonthUiState {
         val monthsByIndex: Map<Int, List<MonthWeek>>,
         val weeksByIndex: Map<Int, MonthWeek>,
         val weekStart: DayOfWeek,
-        /** As [MonthUiState.Success.zone], and for the same reason. */
-        val zone: TimeZone = TimeZone.currentSystemDefault(),
     ) : ContinuousMonthUiState
 }
 

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

@@ -10,10 +10,8 @@ import de.jeanlucmakiola.calendula.data.prefs.firstDayOfWeek
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
-import de.jeanlucmakiola.calendula.domain.isDeclined
 import de.jeanlucmakiola.calendula.ui.week.coversDay
 import de.jeanlucmakiola.calendula.ui.week.layoutAllDay
-import de.jeanlucmakiola.calendula.ui.week.spansMultipleDays
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -239,7 +237,6 @@ class MonthViewModel @Inject constructor(
             monthsByIndex = months,
             weeksByIndex = weeks,
             weekStart = weekStart,
-            zone = zone,
         )
     }
 
@@ -420,11 +417,8 @@ internal fun layoutCalendarWeek(
     zone: TimeZone,
 ): MonthWeek {
     val weekEvents = instances.filter { ev -> days.any { ev.coversDay(it, zone) } }
-    // A bar is decided by the *event*, not by how much of it this row holds: one
-    // crossing midnight into the next week row covers a single day in each, and
-    // counting per row drew it as two unrelated pills (#253).
     val (bars, singles) = weekEvents.partition { ev ->
-        ev.isAllDay || ev.spansMultipleDays(zone)
+        ev.isAllDay || days.count { ev.coversDay(it, zone) } > 1
     }
     val spans = layoutAllDay(bars, days, zone).map { s ->
         MonthSpan(
@@ -440,18 +434,14 @@ internal fun layoutCalendarWeek(
         days = days,
         spans = spans,
         timedByDay = days.associateWith { d ->
-            // Declined last, so a day that overflows drops the events you said
-            // no to before the ones you are actually going to (#230).
-            singles.filter { it.coversDay(d, zone) }
-                .sortedWith(compareBy<EventInstance> { it.isDeclined }.thenBy { it.start })
+            singles.filter { it.coversDay(d, zone) }.sortedBy { it.start }
         },
         countByDay = days.associateWith { d -> weekEvents.count { it.coversDay(d, zone) } },
     )
 }
 
 /**
- * Every event touching each of [days], declined ones last (#230), then all-day
- * first and by start time within each group. Unlike
+ * Every event touching each of [days], all-day first then by start time. Unlike
  * [MonthWeek.timedByDay] this keeps multi-day and all-day events on every date
  * they cover and applies no display cap, so the split style's day pane can list a
  * date in full without querying the provider again.
@@ -464,11 +454,7 @@ internal fun instancesByDay(
     days.associateWith { day ->
         instances
             .filter { it.coversDay(day, zone) }
-            .sortedWith(
-                compareBy<EventInstance> { it.isDeclined }
-                    .thenByDescending { it.isAllDay }
-                    .thenBy { it.start },
-            )
+            .sortedWith(compareByDescending<EventInstance> { it.isAllDay }.thenBy { it.start })
     }
 
 /**

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

@@ -1,100 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.onboarding
-
-import android.net.Uri
-import androidx.activity.compose.rememberLauncherForActivityResult
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.CloudOff
-import androidx.compose.material.icons.filled.FolderOpen
-import androidx.compose.material.icons.filled.Schedule
-import androidx.compose.material3.Button
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.floret.components.BenefitRow
-import de.jeanlucmakiola.floret.components.OnboardingScaffold
-import de.jeanlucmakiola.floret.components.OnboardingSpace
-
-/**
- * Wizard step shown only when everything you write to is a device-only calendar
- * (#163): the events exist nowhere but this phone, so losing it loses them.
- *
- * The primary action picks a folder and switches automatic backup on in one go.
- * Everything it sets is a normal Backup setting, adjustable afterwards.
- */
-@Composable
-internal fun BackupStep(
-    onEnable: (Uri) -> Unit,
-    onSkip: () -> Unit,
-    modifier: Modifier = Modifier,
-    progress: (@Composable () -> Unit)? = null,
-    navigationIcon: (@Composable () -> Unit)? = null,
-) {
-    val pickFolder = rememberLauncherForActivityResult(
-        contract = ActivityResultContracts.OpenDocumentTree(),
-    ) { uri ->
-        // Cancelling the picker decides nothing and leaves the step open.
-        uri?.let(onEnable)
-    }
-
-    OnboardingScaffold(
-        modifier = modifier,
-        progress = progress,
-        navigationIcon = navigationIcon,
-        topSpacing = OnboardingSpace.lg,
-        hero = { IconHero(Icons.Filled.CloudOff) },
-        actions = {
-            Button(
-                onClick = { runCatching { pickFolder.launch(null) } },
-                modifier = Modifier.fillMaxWidth().height(56.dp),
-            ) {
-                Text(
-                    text = stringResource(R.string.onboarding_backup_enable_button),
-                    style = MaterialTheme.typography.titleMedium,
-                )
-            }
-            TextButton(
-                onClick = onSkip,
-                modifier = Modifier.fillMaxWidth(),
-            ) {
-                Text(stringResource(R.string.onboarding_backup_skip_button))
-            }
-        },
-    ) {
-        Text(
-            text = stringResource(R.string.onboarding_backup_title),
-            style = MaterialTheme.typography.headlineMedium,
-            textAlign = TextAlign.Center,
-        )
-        Spacer(Modifier.height(12.dp))
-        Text(
-            text = stringResource(R.string.onboarding_backup_body),
-            style = MaterialTheme.typography.bodyLarge,
-            color = MaterialTheme.colorScheme.onSurfaceVariant,
-            textAlign = TextAlign.Center,
-        )
-
-        Spacer(Modifier.height(OnboardingSpace.lg))
-
-        BenefitRow(
-            icon = Icons.Filled.FolderOpen,
-            title = stringResource(R.string.onboarding_backup_benefit_folder_title),
-            body = stringResource(R.string.onboarding_backup_benefit_folder_body),
-        )
-        Spacer(Modifier.height(OnboardingSpace.sm))
-        BenefitRow(
-            icon = Icons.Filled.Schedule,
-            title = stringResource(R.string.onboarding_backup_benefit_daily_title),
-            body = stringResource(R.string.onboarding_backup_benefit_daily_body),
-        )
-    }
-}

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

@@ -1,61 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.onboarding
-
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.material3.Button
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.floret.components.OnboardingScaffold
-import de.jeanlucmakiola.floret.components.OnboardingSpace
-
-/**
- * The wizard's closing screen (#163): the flow ends on a full screen saying so
- * rather than dropping into the calendar mid-gesture, and the brand mark wears
- * the check that the last step earned.
- */
-@Composable
-internal fun DoneStep(
-    onFinished: () -> Unit,
-    modifier: Modifier = Modifier,
-    progress: (@Composable () -> Unit)? = null,
-    navigationIcon: (@Composable () -> Unit)? = null,
-) {
-    OnboardingScaffold(
-        modifier = modifier,
-        progress = progress,
-        navigationIcon = navigationIcon,
-        topSpacing = OnboardingSpace.lg,
-        hero = { BrandHero(HeroBadge.Done) },
-        actions = {
-            Button(
-                onClick = onFinished,
-                modifier = Modifier.fillMaxWidth().height(56.dp),
-            ) {
-                Text(
-                    text = stringResource(R.string.onboarding_done_button),
-                    style = MaterialTheme.typography.titleMedium,
-                )
-            }
-        },
-    ) {
-        Text(
-            text = stringResource(R.string.onboarding_done_title),
-            style = MaterialTheme.typography.headlineMedium,
-            textAlign = TextAlign.Center,
-        )
-        Spacer(Modifier.height(12.dp))
-        Text(
-            text = stringResource(R.string.onboarding_done_body),
-            style = MaterialTheme.typography.bodyLarge,
-            color = MaterialTheme.colorScheme.onSurfaceVariant,
-            textAlign = TextAlign.Center,
-        )
-    }
-}

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

@@ -1,58 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.onboarding
-
-import androidx.compose.animation.ContentTransform
-import androidx.compose.animation.SizeTransform
-import androidx.compose.animation.core.FiniteAnimationSpec
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.animation.slideInHorizontally
-import androidx.compose.animation.slideOutHorizontally
-import androidx.compose.animation.togetherWith
-import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.unit.IntOffset
-
-/**
- * The M3 Expressive spatial spring the wizard's steps travel on. Read in
- * composable scope so it can be captured by `AnimatedContent`'s non-composable
- * transitionSpec lambda.
- */
-@OptIn(ExperimentalMaterial3ExpressiveApi::class)
-@Composable
-internal fun rememberOnboardingSlideSpec(): FiniteAnimationSpec<IntOffset> =
-    MaterialTheme.motionScheme.defaultSpatialSpec()
-
-/**
- * Moving between wizard steps (#163): the steps sit side by side and the whole
- * width swipes across, position on a spring so the arriving step settles with a
- * little give rather than stopping dead.
- *
- * No cross-fade, unlike the calendar's shared-axis paging: two steps have
- * nothing in common, so fading one through the other smears. Both are opaque and
- * travel in lockstep, showing one screen pushing the other off.
- *
- * @param slideDir     +1 = forward (incoming from the right), -1 = back.
- * @param spec         spatial spec, typically [rememberOnboardingSlideSpec].
- * @param fadeSpec     effects spec used for the whole transition under reduced
- *                     motion.
- * @param reduceMotion when true, drop the movement and cross-fade alone.
- */
-internal fun onboardingSlideTransition(
-    slideDir: Int,
-    spec: FiniteAnimationSpec<IntOffset>,
-    fadeSpec: FiniteAnimationSpec<Float>,
-    reduceMotion: Boolean,
-): ContentTransform {
-    if (reduceMotion) {
-        return fadeIn(fadeSpec).togetherWith(fadeOut(fadeSpec))
-    }
-    val dir = if (slideDir == 0) 1 else slideDir
-    return ContentTransform(
-        targetContentEnter = slideInHorizontally(spec) { w -> dir * w },
-        initialContentExit = slideOutHorizontally(spec) { w -> -dir * w },
-        // Clipping to the animating container would shear both steps against the
-        // viewport edge as they pass; there is no size change here to contain.
-        sizeTransform = SizeTransform(clip = false),
-    )
-}

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

@@ -1,116 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.onboarding
-
-/** One screen of the first-launch wizard (#163), in the order they are shown. */
-enum class OnboardingStep {
-    /** Required: nothing works without the calendar grant. */
-    Permission,
-
-    /** Whether Calendula delivers reminder notifications itself. */
-    Reminders,
-
-    /** Only when nothing you write to is synced anywhere — offers a backup. */
-    Backup,
-
-    /** Which view the app opens on, chosen from a live preview. */
-    View,
-
-    /** How the Month view lays itself out, chosen from a live preview. */
-    MonthStyle,
-
-    /** Only on an install that has calendars the device is hiding (#75). */
-    Visibility,
-
-    /** The closing screen: everything is answered and the app is ready. */
-    Done,
-}
-
-/**
- * Which steps this install owes and where it has got to. [steps] is the whole
- * flow — completed steps included — so the counter doesn't renumber as steps
- * are finished; [current] is null once nothing is left and the app opens.
- */
-data class OnboardingPlan(
-    val steps: List<OnboardingStep>,
-    val current: OnboardingStep?,
-) {
-    /** 1-based position of [current] in [steps], or 0 when the flow is done. */
-    val index: Int get() = steps.indexOf(current) + 1
-
-    val total: Int get() = steps.size
-
-    /** A one-step flow is not a wizard: there is nothing to count down. */
-    val showsProgress: Boolean get() = total > 1
-
-    /** The step before [current], or null at the start (and once finished). */
-    val previous: OnboardingStep? get() = steps.getOrNull(index - 2).takeIf { current != null }
-
-    /**
-     * Whether the wizard can step back. Everything is re-askable except the
-     * calendar grant, which belongs to the system — once given there is nothing
-     * for a back press to return to.
-     */
-    val canGoBack: Boolean get() = previous != null && previous != OnboardingStep.Permission
-}
-
-/**
- * Work out the flow from what is stored.
- *
- * The optional steps belong to installs still working through their first run.
- * Before the grant that can only be guessed, so one that has not answered the
- * reminder step either counts as fresh — the same condition
- * [de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs.armOnboardingWizard]
- * commits to storage a moment later, and clears again on the closing screen so
- * a later re-grant is only the permission step.
- *
- * [backupApplies] is null until the calendar list can be read, i.e. for the
- * whole permission step; the backup step is assumed to apply until proven
- * otherwise, so the flow can only ever get shorter — never sprout a step the
- * counter had not accounted for.
- *
- * The month-style step is *not* conditional on Month being the chosen view:
- * Month is reachable from the drawer whatever opens first, and a step that came
- * and went as the view is picked would move the counter under the user on the
- * step right before it.
- *
- * [visibilityArmed] carries the one-time notice that the device is hiding some
- * calendars (#75) — the only optional step an *existing* install can be given,
- * which is why it is not gated on `fresh`, and on its own it earns no closing
- * screen.
- */
-fun onboardingPlan(
-    hasPermission: Boolean,
-    remindersDone: Boolean,
-    wizardArmed: Boolean,
-    backupDone: Boolean,
-    viewDone: Boolean,
-    monthStyleDone: Boolean,
-    backupApplies: Boolean?,
-    visibilityArmed: Boolean = false,
-    visibilityDone: Boolean = false,
-    doneShown: Boolean = false,
-): OnboardingPlan {
-    val fresh = wizardArmed || (!hasPermission && !remindersDone)
-    val steps = buildList {
-        if (!hasPermission || fresh) add(OnboardingStep.Permission)
-        if (!remindersDone || fresh) add(OnboardingStep.Reminders)
-        if (fresh && backupApplies != false) add(OnboardingStep.Backup)
-        if (fresh) {
-            add(OnboardingStep.View)
-            add(OnboardingStep.MonthStyle)
-        }
-        if (visibilityArmed) add(OnboardingStep.Visibility)
-        if (fresh) add(OnboardingStep.Done)
-    }
-    val current = steps.firstOrNull { step ->
-        when (step) {
-            OnboardingStep.Permission -> !hasPermission
-            OnboardingStep.Reminders -> !remindersDone
-            OnboardingStep.Backup -> !backupDone
-            OnboardingStep.View -> !viewDone
-            OnboardingStep.MonthStyle -> !monthStyleDone
-            OnboardingStep.Visibility -> !visibilityDone
-            OnboardingStep.Done -> !doneShown
-        }
-    }
-    return OnboardingPlan(steps, current)
-}

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

@@ -1,118 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.onboarding
-
-import androidx.activity.compose.BackHandler
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.automirrored.filled.ArrowBack
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.floret.components.OnboardingProgress
-
-/**
- * Renders the wizard's current [step] (#163). Each step commits its own answer
- * through [viewModel], which then hands the host the next one.
- */
-@Composable
-fun OnboardingSteps(
-    step: OnboardingStep,
-    plan: OnboardingPlan,
-    viewModel: OnboardingViewModel,
-    onPermissionGranted: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    // Collected for every step, not just the two that draw a preview: starting
-    // it when the picker composes would leave that step blank as it slides in.
-    val choice by viewModel.viewChoice.collectAsStateWithLifecycle()
-
-    // Coerced because the outgoing half of a transition may be a step the live
-    // plan has since dropped — the backup step goes once the calendars say it
-    // does not apply — and a "Step 0 of 3" flash is worse than a stale number.
-    val index = (plan.steps.indexOf(step) + 1).coerceAtLeast(1)
-    val progress: (@Composable () -> Unit)? = if (!plan.showsProgress) {
-        null
-    } else {
-        {
-            OnboardingProgress(
-                step = index,
-                total = plan.total,
-                label = stringResource(R.string.onboarding_step_counter, index, plan.total),
-            )
-        }
-    }
-
-    // The system back gesture does the same thing as the button, and stays off
-    // on the first step so back still leaves the app.
-    BackHandler(enabled = plan.canGoBack) { viewModel.goBack() }
-    val navigationIcon: (@Composable () -> Unit)? = if (!plan.canGoBack) {
-        null
-    } else {
-        {
-            IconButton(onClick = viewModel::goBack) {
-                Icon(
-                    imageVector = Icons.AutoMirrored.Filled.ArrowBack,
-                    contentDescription = stringResource(R.string.onboarding_back),
-                )
-            }
-        }
-    }
-
-    when (step) {
-        OnboardingStep.Permission -> PermissionScreen(
-            onGranted = onPermissionGranted,
-            modifier = modifier,
-            progress = progress,
-        )
-        OnboardingStep.Reminders -> ReminderStep(
-            onFinished = viewModel::finishReminders,
-            modifier = modifier,
-            progress = progress,
-            navigationIcon = navigationIcon,
-        )
-        OnboardingStep.Backup -> BackupStep(
-            onEnable = viewModel::enableAutoBackup,
-            onSkip = viewModel::skipBackup,
-            modifier = modifier,
-            progress = progress,
-            navigationIcon = navigationIcon,
-        )
-        // The choice is null only until DataStore's first emission; rendering
-        // nothing for that frame beats a preview built on the wrong defaults.
-        OnboardingStep.View -> choice?.let {
-            ViewStep(
-                choice = it,
-                onSelect = viewModel::setDefaultView,
-                onFinished = viewModel::finishView,
-                modifier = modifier,
-                progress = progress,
-                navigationIcon = navigationIcon,
-            )
-        }
-        OnboardingStep.MonthStyle -> choice?.let {
-            MonthStyleStep(
-                choice = it,
-                onSelect = viewModel::setMonthViewStyle,
-                onFinished = viewModel::finishMonthStyle,
-                modifier = modifier,
-                progress = progress,
-                navigationIcon = navigationIcon,
-            )
-        }
-        OnboardingStep.Visibility -> VisibilityStep(
-            onFinished = viewModel::finishVisibility,
-            modifier = modifier,
-            progress = progress,
-            navigationIcon = navigationIcon,
-        )
-        OnboardingStep.Done -> DoneStep(
-            onFinished = viewModel::finishOnboarding,
-            modifier = modifier,
-            progress = progress,
-            navigationIcon = navigationIcon,
-        )
-    }
-}

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

@@ -1,321 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.onboarding
-
-import android.content.Context
-import android.content.Intent
-import android.net.Uri
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import dagger.hilt.android.lifecycle.HiltViewModel
-import dagger.hilt.android.qualifiers.ApplicationContext
-import de.jeanlucmakiola.calendula.data.backup.BackupScheduler
-import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
-import de.jeanlucmakiola.calendula.data.calendar.CalendarVisibilityReconciler
-import de.jeanlucmakiola.calendula.data.di.IoDispatcher
-import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
-import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
-import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
-import de.jeanlucmakiola.calendula.data.reminders.ReminderScanner
-import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.ui.common.CalendarView
-import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.catch
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.flowOf
-import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.mapLatest
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-/**
- * Drives the first-launch wizard (#163): decides which steps this install owes
- * (see [onboardingPlan]) and commits each answer.
- *
- * [plan] is null until the first stored emission, so the host renders nothing
- * for that frame rather than flashing a step the user has already answered.
- */
-@OptIn(ExperimentalCoroutinesApi::class)
-@HiltViewModel
-class OnboardingViewModel @Inject constructor(
-    @ApplicationContext private val context: Context,
-    private val prefs: SettingsPrefs,
-    private val calendarPrefs: CalendarPrefs,
-    private val repository: CalendarRepository,
-    private val scanner: ReminderScanner,
-    private val visibilityReconciler: CalendarVisibilityReconciler,
-    @IoDispatcher private val io: CoroutineDispatcher,
-) : ViewModel() {
-
-    /** Null until the host reports it — assuming either way would flash a screen. */
-    private val permissionReported = MutableStateFlow<Boolean?>(null)
-
-    /**
-     * The grant as the rest of the flow sees it: published only once the wizard
-     * has been armed for it, since arming is a stored write and the frames
-     * before it lands would collapse the plan to its one-step form.
-     */
-    private val hasPermission: StateFlow<Boolean?> = permissionReported
-        .mapLatest { granted ->
-            if (granted == true) armWizardIfFresh()
-            granted
-        }
-        .stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.Eagerly,
-            initialValue = null,
-        )
-
-    /**
-     * Whether the backup step applies: something of yours is worth exporting and
-     * nothing you write to is synced anywhere. Null while the calendar list
-     * cannot be read: every frame before the grant, and any read that fails —
-     * an empty list is also how a null cursor arrives, and guessing false there
-     * would drop the step for the whole session.
-     */
-    private val backupApplies: Flow<Boolean?> = hasPermission.flatMapLatest { granted ->
-        if (granted != true) {
-            flowOf(null)
-        } else {
-            repository.calendars()
-                .map { calendars -> if (calendars.isEmpty()) null else calendars.backupApplies() }
-                .catch { emit(null) }
-                .flowOn(io)
-        }
-    }
-
-    private val flags: Flow<OnboardingFlags> = combine(
-        prefs.reminderOnboardingDone,
-        prefs.onboardingWizardArmed,
-        prefs.onboardingBackupDone,
-        prefs.onboardingViewDone,
-        prefs.onboardingMonthStyleDone,
-        ::OnboardingFlags,
-    )
-
-    /** The closing steps' own flags, and whether the notice applies at all. */
-    private val closingFlags: Flow<ClosingFlags> = combine(
-        calendarPrefs.visibilityNoticePending.map { it == true },
-        prefs.onboardingVisibilityDone,
-        prefs.onboardingDoneShown,
-        ::ClosingFlags,
-    )
-
-    val plan: StateFlow<OnboardingPlan?> =
-        combine(hasPermission, flags, closingFlags, backupApplies) { granted, stored, closing, backup ->
-            granted?.let {
-                onboardingPlan(
-                    hasPermission = it,
-                    remindersDone = stored.remindersDone,
-                    wizardArmed = stored.wizardArmed,
-                    backupDone = stored.backupDone,
-                    viewDone = stored.viewDone,
-                    monthStyleDone = stored.monthStyleDone,
-                    backupApplies = backup,
-                    visibilityArmed = closing.visibilityArmed,
-                    visibilityDone = closing.visibilityDone,
-                    doneShown = closing.doneShown,
-                )
-            }
-        }.stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5_000L),
-            initialValue = null,
-        )
-
-    /** The current view preferences, for the view step's initial selection. */
-    val viewChoice: StateFlow<ViewChoice?> = combine(
-        prefs.defaultView,
-        prefs.monthViewStyle,
-        prefs.weekStart,
-        ::ViewChoice,
-    ).stateIn(
-        scope = viewModelScope,
-        started = SharingStarted.WhileSubscribed(5_000L),
-        initialValue = null,
-    )
-
-    fun setHasPermission(granted: Boolean) {
-        permissionReported.value = granted
-    }
-
-    /**
-     * Arm the wizard for an install that has yet to answer the reminder step,
-     * whatever route the grant took. Gating this on the in-app grant would
-     * strand anyone who granted on Android's own settings screen and came back
-     * to a restarted process, leaving them the reminder step alone.
-     */
-    private suspend fun armWizardIfFresh() {
-        if (!prefs.reminderOnboardingDone.first()) prefs.armOnboardingWizard()
-    }
-
-    /**
-     * Record the in-app grant. The launch scan ran before it and bailed out
-     * without arming anything, so the first alarm would otherwise wait on the
-     * daily worker.
-     */
-    fun onPermissionGranted() {
-        scanner.scanInBackground()
-    }
-
-    /** Close the reminder step, recording whether notifications stay on. */
-    fun finishReminders(remindersEnabled: Boolean) {
-        viewModelScope.launch {
-            prefs.setRemindersEnabled(remindersEnabled)
-            prefs.setReminderOnboardingDone()
-            // Nothing else re-arms the scan: turning reminders off cancels the
-            // alarm (#75).
-            scanner.scan()
-        }
-    }
-
-    /**
-     * Re-ask the step before the current one, by clearing its answer. The plan
-     * derives the position from those answers, so un-setting one *is* the back
-     * navigation. The calendar grant belongs to the system and cannot be
-     * returned to, which [OnboardingPlan.canGoBack] already refuses.
-     */
-    fun goBack() {
-        viewModelScope.launch {
-            when (plan.value?.previous) {
-                OnboardingStep.Reminders -> prefs.setReminderOnboardingDone(false)
-                OnboardingStep.Backup -> prefs.setOnboardingBackupDone(false)
-                OnboardingStep.View -> prefs.setOnboardingViewDone(false)
-                OnboardingStep.MonthStyle -> prefs.setOnboardingMonthStyleDone(false)
-                OnboardingStep.Visibility -> prefs.setOnboardingVisibilityDone(false)
-                OnboardingStep.Done -> prefs.setOnboardingDoneShown(false)
-                OnboardingStep.Permission, null -> Unit
-            }
-        }
-    }
-
-    /** Close the backup step without setting anything up. */
-    fun skipBackup() {
-        viewModelScope.launch { prefs.setOnboardingBackupDone() }
-    }
-
-    /**
-     * Turn automatic backup on, writing to the folder the user just picked
-     * (taking a durable write grant so background runs can keep writing), and
-     * close the step.
-     */
-    fun enableAutoBackup(folder: Uri) {
-        viewModelScope.launch {
-            runCatching {
-                context.contentResolver.takePersistableUriPermission(
-                    folder,
-                    Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION,
-                )
-            }
-            prefs.setAutoBackupFolderUri(folder.toString())
-            prefs.setAutoBackupEnabled(true)
-            BackupScheduler.apply(
-                context = context,
-                enabled = true,
-                intervalMinutes = prefs.autoBackupIntervalMinutes.first(),
-                hasFolder = true,
-            )
-            // Immediate feedback: the first backup lands while onboarding runs.
-            BackupScheduler.runNow(context)
-            prefs.setOnboardingBackupDone()
-        }
-    }
-
-    fun setDefaultView(view: CalendarView) {
-        viewModelScope.launch { prefs.setDefaultView(view) }
-    }
-
-    fun setMonthViewStyle(style: MonthViewStyle) {
-        viewModelScope.launch { prefs.setMonthViewStyle(style) }
-    }
-
-    /** Close a picker step — the choice itself is saved as it is made. */
-    fun finishView() {
-        viewModelScope.launch { prefs.setOnboardingViewDone() }
-    }
-
-    fun finishMonthStyle() {
-        viewModelScope.launch { prefs.setOnboardingMonthStyleDone() }
-    }
-
-    /** Acknowledge the calendar-visibility notice (#75). */
-    fun finishVisibility() {
-        viewModelScope.launch {
-            prefs.setOnboardingVisibilityDone()
-            // Retiring the notice drops its step, so it waits until nothing
-            // follows — the count must not fall on the way to a later screen.
-            if (plan.value?.steps?.last() == OnboardingStep.Visibility) retireVisibilityNotice()
-        }
-    }
-
-    /** Close the wizard from its last screen. */
-    fun finishOnboarding() {
-        viewModelScope.launch {
-            prefs.finishOnboardingWizard()
-            retireVisibilityNotice()
-        }
-    }
-
-    /**
-     * Put the one-time visibility notice away for good — nothing else clears it
-     * now that the wizard owns it, and left standing it would keep its step in
-     * every later plan.
-     */
-    private suspend fun retireVisibilityNotice() {
-        if (calendarPrefs.visibilityNoticePending.first() == true) {
-            calendarPrefs.setVisibilityNoticePending(false)
-        }
-    }
-
-    /**
-     * Fold the retired app-local calendar visibility into the device's own, and
-     * arm the notice if this install has anything to announce. Runs whenever the
-     * app comes up holding the permission, however it was granted — one taken on
-     * Android's app-settings screen never reaches the permission step's callback.
-     */
-    fun reconcileCalendarVisibility() {
-        viewModelScope.launch { visibilityReconciler.run() }
-    }
-}
-
-/** The stored answers the plan is derived from. */
-private data class OnboardingFlags(
-    val remindersDone: Boolean,
-    val wizardArmed: Boolean,
-    val backupDone: Boolean,
-    val viewDone: Boolean,
-    val monthStyleDone: Boolean,
-)
-
-/** The tail of the flow: the visibility notice and the closing screen. */
-private data class ClosingFlags(
-    val visibilityArmed: Boolean,
-    val visibilityDone: Boolean,
-    val doneShown: Boolean,
-)
-
-/** What the view step starts from, and renders its previews with. */
-data class ViewChoice(
-    val defaultView: CalendarView,
-    val monthViewStyle: MonthViewStyle,
-    val weekStart: WeekStartPref,
-)
-
-/**
- * True when this device holds events that live nowhere else: at least one local
- * calendar worth exporting, and no writable synced calendar to carry them.
- * A read-only subscription is not a backup, so it does not count.
- */
-private fun List<CalendarSource>.backupApplies(): Boolean {
-    val exportable = any { it.isLocal && it.canModifyContents && !it.isManaged }
-    val syncedTarget = any { !it.isLocal && it.canModifyContents }
-    return exportable && !syncedTarget
-}

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

@@ -1,209 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.onboarding
-
-import androidx.compose.foundation.layout.ColumnScope
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.Button
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
-import de.jeanlucmakiola.calendula.ui.agenda.AgendaViewPreview
-import de.jeanlucmakiola.calendula.ui.common.CalendarView
-import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
-import de.jeanlucmakiola.calendula.ui.common.PickerDescription
-import de.jeanlucmakiola.calendula.ui.common.ViewPreviewFrame
-import de.jeanlucmakiola.calendula.ui.common.icon
-import de.jeanlucmakiola.calendula.ui.common.labelRes
-import de.jeanlucmakiola.calendula.ui.day.DayViewPreview
-import de.jeanlucmakiola.calendula.ui.month.MonthStylePreview
-import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
-import de.jeanlucmakiola.calendula.ui.month.descriptionRes
-import de.jeanlucmakiola.calendula.ui.month.labelRes
-import de.jeanlucmakiola.calendula.ui.week.WeekViewPreview
-import de.jeanlucmakiola.floret.components.GroupedListInset
-import de.jeanlucmakiola.floret.components.OnboardingScaffold
-import de.jeanlucmakiola.floret.components.OnboardingSpace
-import de.jeanlucmakiola.floret.components.GroupedRow
-import de.jeanlucmakiola.floret.components.SelectedCheck
-import de.jeanlucmakiola.floret.components.positionOf
-import de.jeanlucmakiola.floret.locale.currentLocale
-
-/**
- * Wizard step: which view the app opens on (#163). Built like the Settings
- * picker it mirrors — a live preview over connected grouped rows. Selecting
- * applies immediately and leaves the step open; the preview is the confirmation.
- */
-@Composable
-internal fun ViewStep(
-    choice: ViewChoice,
-    onSelect: (CalendarView) -> Unit,
-    onFinished: () -> Unit,
-    modifier: Modifier = Modifier,
-    progress: (@Composable () -> Unit)? = null,
-    navigationIcon: (@Composable () -> Unit)? = null,
-) {
-    val weekStart = choice.weekStart.resolveFirstDay(currentLocale())
-
-    StepPickerScaffold(
-        title = stringResource(R.string.onboarding_view_title),
-        onFinished = onFinished,
-        modifier = modifier,
-        progress = progress,
-        navigationIcon = navigationIcon,
-    ) {
-        StepPreview(selected = choice.defaultView) { view ->
-            when (view) {
-                CalendarView.Month -> MonthStylePreview(
-                    style = choice.monthViewStyle,
-                    weekStart = weekStart,
-                    height = PREVIEW_HEIGHT,
-                )
-                CalendarView.Week -> WeekViewPreview(weekStart = weekStart, height = PREVIEW_HEIGHT)
-                CalendarView.Day -> DayViewPreview(height = PREVIEW_HEIGHT)
-                CalendarView.Agenda -> AgendaViewPreview(height = PREVIEW_HEIGHT)
-            }
-        }
-        IMPLEMENTED_VIEWS.forEachIndexed { index, view ->
-            val isSelected = view == choice.defaultView
-            GroupedRow(
-                title = stringResource(view.labelRes),
-                position = positionOf(index, IMPLEMENTED_VIEWS.size),
-                selected = isSelected,
-                leading = {
-                    Icon(
-                        imageVector = view.icon,
-                        contentDescription = null,
-                        tint = MaterialTheme.colorScheme.onSurfaceVariant,
-                    )
-                },
-                trailing = if (isSelected) {
-                    { SelectedCheck() }
-                } else {
-                    null
-                },
-                onClick = { onSelect(view) },
-            )
-        }
-    }
-}
-
-/**
- * Wizard step: how the Month view lays itself out (#163). The same shape as
- * [ViewStep] and as the Settings chooser this duplicates, down to the selected
- * style's own blurb sitting under its preview rather than on every row.
- */
-@Composable
-internal fun MonthStyleStep(
-    choice: ViewChoice,
-    onSelect: (MonthViewStyle) -> Unit,
-    onFinished: () -> Unit,
-    modifier: Modifier = Modifier,
-    progress: (@Composable () -> Unit)? = null,
-    navigationIcon: (@Composable () -> Unit)? = null,
-) {
-    val weekStart = choice.weekStart.resolveFirstDay(currentLocale())
-    val options = MonthViewStyle.entries
-
-    StepPickerScaffold(
-        title = stringResource(R.string.onboarding_month_style_title),
-        onFinished = onFinished,
-        modifier = modifier,
-        progress = progress,
-        navigationIcon = navigationIcon,
-    ) {
-        StepPreview(selected = choice.monthViewStyle) { style ->
-            MonthStylePreview(style = style, weekStart = weekStart, height = PREVIEW_HEIGHT)
-        }
-        PickerDescription(stringResource(choice.monthViewStyle.descriptionRes))
-        options.forEachIndexed { index, style ->
-            val isSelected = style == choice.monthViewStyle
-            GroupedRow(
-                title = stringResource(style.labelRes),
-                position = positionOf(index, options.size),
-                selected = isSelected,
-                trailing = if (isSelected) {
-                    { SelectedCheck() }
-                } else {
-                    null
-                },
-                onClick = { onSelect(style) },
-            )
-        }
-    }
-}
-
-/**
- * The shell both picker steps share: the wizard chrome around a title and a
- * full-bleed column, since grouped rows carry their own inset.
- */
-@Composable
-private fun StepPickerScaffold(
-    title: String,
-    onFinished: () -> Unit,
-    modifier: Modifier = Modifier,
-    progress: (@Composable () -> Unit)? = null,
-    navigationIcon: (@Composable () -> Unit)? = null,
-    body: @Composable ColumnScope.() -> Unit,
-) {
-    OnboardingScaffold(
-        modifier = modifier,
-        progress = progress,
-        navigationIcon = navigationIcon,
-        topSpacing = OnboardingSpace.xs,
-        contentPadding = 0.dp,
-        // The preview gets the room it needs; Continue scrolls in under the
-        // options rather than pinning to the bottom.
-        scrollingActions = true,
-        hero = {
-            Text(
-                text = title,
-                style = MaterialTheme.typography.headlineSmall,
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(horizontal = GroupedListInset),
-            )
-        },
-        actions = {
-            Button(
-                onClick = onFinished,
-                // Full-bleed step: the button takes the grouped rows' own inset
-                // and ends up as wide as the options above it.
-                modifier = Modifier
-                    .padding(horizontal = GroupedListInset)
-                    .fillMaxWidth()
-                    .height(56.dp),
-            ) {
-                Text(
-                    text = stringResource(R.string.onboarding_view_continue_button),
-                    style = MaterialTheme.typography.titleMedium,
-                )
-            }
-        },
-        body = body,
-    )
-}
-
-/**
- * The live preview, framed like the picker's. The wider gap below keeps the rows
- * reading as a group of their own rather than as the preview's caption.
- */
-@Composable
-private fun <T> StepPreview(selected: T, content: @Composable (T) -> Unit) {
-    ViewPreviewFrame(
-        selected = selected,
-        label = "step-preview",
-        modifier = Modifier.padding(top = OnboardingSpace.xs, bottom = OnboardingSpace.md),
-        content = content,
-    )
-}
-
-/** The same size the Settings chooser gives it. */
-private val PREVIEW_HEIGHT: Dp = 280.dp

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

@@ -1,65 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.onboarding
-
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.VisibilityOff
-import androidx.compose.material3.Button
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.floret.components.OnboardingScaffold
-import de.jeanlucmakiola.floret.components.OnboardingSpace
-
-/**
- * Wizard step for the one-time notice that Calendula now follows the device's
- * own per-calendar visibility and some of yours are switched off (#75, #163).
- *
- * Nothing to decide here — the app does not switch those calendars back on,
- * since that would un-hide them everywhere else too.
- */
-@Composable
-internal fun VisibilityStep(
-    onFinished: () -> Unit,
-    modifier: Modifier = Modifier,
-    progress: (@Composable () -> Unit)? = null,
-    navigationIcon: (@Composable () -> Unit)? = null,
-) {
-    OnboardingScaffold(
-        modifier = modifier,
-        progress = progress,
-        navigationIcon = navigationIcon,
-        topSpacing = OnboardingSpace.lg,
-        hero = { IconHero(Icons.Filled.VisibilityOff) },
-        actions = {
-            Button(
-                onClick = onFinished,
-                modifier = Modifier.fillMaxWidth().height(56.dp),
-            ) {
-                Text(
-                    text = stringResource(R.string.onboarding_visibility_button),
-                    style = MaterialTheme.typography.titleMedium,
-                )
-            }
-        },
-    ) {
-        Text(
-            text = stringResource(R.string.calendars_visibility_notice_title),
-            style = MaterialTheme.typography.headlineMedium,
-            textAlign = TextAlign.Center,
-        )
-        Spacer(Modifier.height(12.dp))
-        Text(
-            text = stringResource(R.string.calendars_visibility_notice_message),
-            style = MaterialTheme.typography.bodyLarge,
-            color = MaterialTheme.colorScheme.onSurfaceVariant,
-            textAlign = TextAlign.Center,
-        )
-    }
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/permission/BrandHero.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.onboarding
+package de.jeanlucmakiola.calendula.ui.permission
 
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.background
@@ -9,7 +9,6 @@ import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Check
 import androidx.compose.material.icons.filled.Lock
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
@@ -17,25 +16,20 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.colorResource
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 
-/** What, if anything, the brand mark is wearing in its corner. */
-internal enum class HeroBadge { Denied, Done }
-
 /**
  * The app's adaptive launcher mark, reconstructed as a large branded squircle —
  * the hero of the onboarding screens (floret-kit's OnboardingScaffold supplies
  * the shell; the mark stays app-local so each sibling keeps its own identity).
- * A [badge] overlays the corner where the screen has a verdict to give: blocked,
- * or finished.
+ * A lock badge overlays the corner when permission has been [denied].
  */
 @Composable
-internal fun BrandHero(badge: HeroBadge? = null) {
+internal fun BrandHero(denied: Boolean) {
     Box(contentAlignment = Alignment.Center) {
         Box(
             modifier = Modifier
@@ -49,56 +43,24 @@ internal fun BrandHero(badge: HeroBadge? = null) {
                 modifier = Modifier.fillMaxSize(),
             )
         }
-        if (badge != null) {
-            val container = when (badge) {
-                HeroBadge.Denied -> MaterialTheme.colorScheme.errorContainer
-                HeroBadge.Done -> MaterialTheme.colorScheme.primaryContainer
-            }
-            val onContainer = when (badge) {
-                HeroBadge.Denied -> MaterialTheme.colorScheme.onErrorContainer
-                HeroBadge.Done -> MaterialTheme.colorScheme.onPrimaryContainer
-            }
+        if (denied) {
+            // A small lock badge sits over the corner to signal "blocked".
             Box(
                 modifier = Modifier
                     .align(Alignment.BottomEnd)
                     .offset(x = 10.dp, y = 10.dp)
                     .size(44.dp)
                     .clip(CircleShape)
-                    .background(container),
+                    .background(MaterialTheme.colorScheme.errorContainer),
                 contentAlignment = Alignment.Center,
             ) {
                 Icon(
-                    imageVector = when (badge) {
-                        HeroBadge.Denied -> Icons.Filled.Lock
-                        HeroBadge.Done -> Icons.Filled.Check
-                    },
+                    imageVector = Icons.Filled.Lock,
                     contentDescription = null,
-                    tint = onContainer,
+                    tint = MaterialTheme.colorScheme.onErrorContainer,
                     modifier = Modifier.size(24.dp),
                 )
             }
         }
     }
 }
-
-/**
- * A single [icon] in the brand squircle — the same silhouette as [BrandHero],
- * for the wizard steps that stand for a feature rather than for the app itself.
- */
-@Composable
-internal fun IconHero(icon: ImageVector) {
-    Box(
-        modifier = Modifier
-            .size(128.dp)
-            .clip(RoundedCornerShape(34.dp))
-            .background(MaterialTheme.colorScheme.primaryContainer),
-        contentAlignment = Alignment.Center,
-    ) {
-        Icon(
-            imageVector = icon,
-            contentDescription = null,
-            tint = MaterialTheme.colorScheme.onPrimaryContainer,
-            modifier = Modifier.size(56.dp),
-        )
-    }
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/permission/PermissionScreen.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.onboarding
+package de.jeanlucmakiola.calendula.ui.permission
 
 import de.jeanlucmakiola.floret.components.BenefitRow
 import de.jeanlucmakiola.floret.components.OnboardingScaffold
@@ -10,15 +10,19 @@ import android.net.Uri
 import android.provider.Settings
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
 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.foundation.layout.width
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowForward
 import androidx.compose.material.icons.filled.CalendarMonth
 import androidx.compose.material.icons.filled.Lock
+import androidx.compose.material.icons.filled.VisibilityOff
 import androidx.compose.material3.Button
 import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.Icon
@@ -28,11 +32,13 @@ import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
@@ -46,7 +52,6 @@ private val CALENDAR_PERMISSIONS = arrayOf(
 fun PermissionScreen(
     onGranted: () -> Unit,
     modifier: Modifier = Modifier,
-    progress: (@Composable () -> Unit)? = null,
     viewModel: PermissionViewModel = hiltViewModel(),
 ) {
     val state by viewModel.state.collectAsStateWithLifecycle()
@@ -71,7 +76,6 @@ fun PermissionScreen(
     when (state) {
         is PermissionUiState.Rationale -> RationaleContent(
             onRequest = { launcher.launch(CALENDAR_PERMISSIONS) },
-            progress = progress,
             modifier = modifier,
         )
         is PermissionUiState.Denied -> DeniedContent(
@@ -79,7 +83,6 @@ fun PermissionScreen(
                 viewModel.onRetry()
                 launcher.launch(CALENDAR_PERMISSIONS)
             },
-            progress = progress,
             modifier = modifier,
         )
         is PermissionUiState.Granted -> {
@@ -91,14 +94,11 @@ fun PermissionScreen(
 @Composable
 private fun RationaleContent(
     onRequest: () -> Unit,
-    progress: (@Composable () -> Unit)?,
     modifier: Modifier = Modifier,
 ) {
     OnboardingScaffold(
         modifier = modifier,
-        progress = progress,
-        topSpacing = OnboardingSpace.lg,
-        hero = { BrandHero() },
+        hero = { BrandHero(denied = false) },
         actions = {
             Button(
                 onClick = onRequest,
@@ -116,8 +116,16 @@ private fun RationaleContent(
                     modifier = Modifier.size(20.dp),
                 )
             }
+            PrivacyFootnote()
         },
     ) {
+        Text(
+            text = stringResource(R.string.app_name).uppercase(),
+            style = MaterialTheme.typography.labelLarge,
+            color = MaterialTheme.colorScheme.primary,
+            letterSpacing = 2.sp,
+        )
+        Spacer(Modifier.height(OnboardingSpace.xs))
         Text(
             text = stringResource(R.string.permission_rationale_title),
             style = MaterialTheme.typography.headlineMedium,
@@ -131,8 +139,14 @@ private fun RationaleContent(
             textAlign = TextAlign.Center,
         )
 
-        Spacer(Modifier.height(OnboardingSpace.lg))
+        Spacer(Modifier.height(OnboardingSpace.xl))
 
+        BenefitRow(
+            icon = Icons.Filled.Lock,
+            title = stringResource(R.string.permission_benefit_private_title),
+            body = stringResource(R.string.permission_benefit_private_body),
+        )
+        Spacer(Modifier.height(OnboardingSpace.sm))
         BenefitRow(
             icon = Icons.Filled.CalendarMonth,
             title = stringResource(R.string.permission_benefit_sync_title),
@@ -140,9 +154,9 @@ private fun RationaleContent(
         )
         Spacer(Modifier.height(OnboardingSpace.sm))
         BenefitRow(
-            icon = Icons.Filled.Lock,
-            title = stringResource(R.string.permission_benefit_private_title),
-            body = stringResource(R.string.permission_benefit_private_body),
+            icon = Icons.Filled.VisibilityOff,
+            title = stringResource(R.string.permission_benefit_privacy_title),
+            body = stringResource(R.string.permission_benefit_privacy_body),
         )
     }
 }
@@ -150,14 +164,12 @@ private fun RationaleContent(
 @Composable
 private fun DeniedContent(
     onRetry: () -> Unit,
-    progress: (@Composable () -> Unit)?,
     modifier: Modifier = Modifier,
 ) {
     val context = LocalContext.current
     OnboardingScaffold(
         modifier = modifier,
-        progress = progress,
-        hero = { BrandHero(HeroBadge.Denied) },
+        hero = { BrandHero(denied = true) },
         actions = {
             Button(
                 onClick = {
@@ -196,3 +208,25 @@ private fun DeniedContent(
         )
     }
 }
+
+@Composable
+private fun PrivacyFootnote() {
+    Row(
+        modifier = Modifier.fillMaxWidth().padding(top = 4.dp),
+        horizontalArrangement = Arrangement.Center,
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Icon(
+            imageVector = Icons.Filled.Lock,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.size(14.dp),
+        )
+        Spacer(Modifier.width(6.dp))
+        Text(
+            text = stringResource(R.string.permission_privacy_footnote),
+            style = MaterialTheme.typography.labelMedium,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+        )
+    }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/permission/PermissionUiState.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.onboarding
+package de.jeanlucmakiola.calendula.ui.permission
 
 sealed interface PermissionUiState {
     data object Rationale : PermissionUiState

app/src/main/java/de/jeanlucmakiola/calendula/ui/permission/PermissionViewModel.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.onboarding
+package de.jeanlucmakiola.calendula.ui.permission
 
 import androidx.lifecycle.ViewModel
 import dagger.hilt.android.lifecycle.HiltViewModel

app/src/main/java/de/jeanlucmakiola/calendula/ui/permission/ReminderOnboardingScreen.kt

@@ -1,4 +1,4 @@
-package de.jeanlucmakiola.calendula.ui.onboarding
+package de.jeanlucmakiola.calendula.ui.permission
 
 import de.jeanlucmakiola.floret.components.BenefitRow
 import de.jeanlucmakiola.floret.components.OnboardingScaffold
@@ -8,25 +8,34 @@ import android.Manifest
 import android.os.Build
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.NotificationsActive
 import androidx.compose.material.icons.filled.ContentCopy
+import androidx.compose.material.icons.filled.Tune
 import androidx.compose.material3.Button
+import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
 import de.jeanlucmakiola.calendula.R
 
 /**
- * Wizard step after the calendar grant (v1.4): explains that
+ * One-time onboarding step after the calendar grant (v1.4): explains that
  * Calendula delivers reminder notifications itself, warns about duplicates
  * when a second calendar app has notifications on, and requests
  * `POST_NOTIFICATIONS` (a system dialog on API 33+ only; minSdk is 29).
@@ -36,11 +45,9 @@ import de.jeanlucmakiola.calendula.R
  * the Settings toggle re-requests it. "Not now" turns the in-app toggle off.
  */
 @Composable
-fun ReminderStep(
+fun ReminderOnboardingScreen(
     onFinished: (remindersEnabled: Boolean) -> Unit,
     modifier: Modifier = Modifier,
-    progress: (@Composable () -> Unit)? = null,
-    navigationIcon: (@Composable () -> Unit)? = null,
 ) {
     val launcher = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.RequestPermission(),
@@ -48,10 +55,7 @@ fun ReminderStep(
 
     OnboardingScaffold(
         modifier = modifier,
-        progress = progress,
-        navigationIcon = navigationIcon,
-        topSpacing = OnboardingSpace.lg,
-        hero = { IconHero(Icons.Filled.NotificationsActive) },
+        hero = { BellHero() },
         actions = {
             Button(
                 onClick = {
@@ -76,6 +80,13 @@ fun ReminderStep(
             }
         },
     ) {
+        Text(
+            text = stringResource(R.string.app_name).uppercase(),
+            style = MaterialTheme.typography.labelLarge,
+            color = MaterialTheme.colorScheme.primary,
+            letterSpacing = 2.sp,
+        )
+        Spacer(Modifier.height(OnboardingSpace.xs))
         Text(
             text = stringResource(R.string.reminder_onboarding_title),
             style = MaterialTheme.typography.headlineMedium,
@@ -89,7 +100,7 @@ fun ReminderStep(
             textAlign = TextAlign.Center,
         )
 
-        Spacer(Modifier.height(OnboardingSpace.lg))
+        Spacer(Modifier.height(OnboardingSpace.xl))
 
         BenefitRow(
             icon = Icons.Filled.NotificationsActive,
@@ -102,5 +113,30 @@ fun ReminderStep(
             title = stringResource(R.string.reminder_benefit_duplicates_title),
             body = stringResource(R.string.reminder_benefit_duplicates_body),
         )
+        Spacer(Modifier.height(OnboardingSpace.sm))
+        BenefitRow(
+            icon = Icons.Filled.Tune,
+            title = stringResource(R.string.reminder_benefit_reversible_title),
+            body = stringResource(R.string.reminder_benefit_reversible_body),
+        )
+    }
+}
+
+/** A bell in the brand squircle — same silhouette as the permission hero. */
+@Composable
+private fun BellHero() {
+    Box(
+        modifier = Modifier
+            .size(128.dp)
+            .clip(RoundedCornerShape(34.dp))
+            .background(MaterialTheme.colorScheme.primaryContainer),
+        contentAlignment = Alignment.Center,
+    ) {
+        Icon(
+            imageVector = Icons.Filled.NotificationsActive,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.onPrimaryContainer,
+            modifier = Modifier.size(56.dp),
+        )
     }
 }

app/src/main/java/de/jeanlucmakiola/calendula/ui/permission/ReminderOnboardingViewModel.kt

@@ -0,0 +1,53 @@
+package de.jeanlucmakiola.calendula.ui.permission
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
+import de.jeanlucmakiola.calendula.data.reminders.ReminderScanner
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+/**
+ * Gates the one-time reminder onboarding step (v1.4) shown after the calendar
+ * grant. [onboardingDone] is null until DataStore's first emission so the
+ * step neither flashes for users who completed it nor gets skipped.
+ */
+@HiltViewModel
+class ReminderOnboardingViewModel @Inject constructor(
+    private val prefs: SettingsPrefs,
+    private val scanner: ReminderScanner,
+) : ViewModel() {
+
+    val onboardingDone: StateFlow<Boolean?> = prefs.reminderOnboardingDone
+        .map { done -> done as Boolean? }
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
+            initialValue = null,
+        )
+
+    /** Close the step, recording whether reminder notifications stay on. */
+    fun finish(remindersEnabled: Boolean) {
+        viewModelScope.launch {
+            prefs.setRemindersEnabled(remindersEnabled)
+            prefs.setReminderOnboardingDone()
+            // Nothing else re-arms the scan: turning reminders off cancels the
+            // alarm (#75).
+            scanner.scan()
+        }
+    }
+
+    /**
+     * Re-scan after the calendar permission is granted. The launch scan runs
+     * before the grant and bails out without arming anything, so without this
+     * the first alarm waits on the daily worker.
+     */
+    fun rearmAfterGrant() {
+        scanner.scanInBackground()
+    }
+}

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

@@ -22,9 +22,7 @@ import androidx.compose.foundation.layout.imePadding
 import androidx.compose.foundation.layout.navigationBarsPadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.LazyListScope
 import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
@@ -55,20 +53,14 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalSoftwareKeyboardController
 import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.AnnotatedString
-import androidx.compose.ui.text.SpanStyle
-import androidx.compose.ui.text.buildAnnotatedString
-import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.text.style.TextAlign
@@ -78,15 +70,10 @@ import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.domain.MatchSpan
 import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
-import de.jeanlucmakiola.calendula.domain.SearchHit
-import de.jeanlucmakiola.calendula.domain.SearchMonth
-import de.jeanlucmakiola.calendula.domain.isDeclined
 import de.jeanlucmakiola.floret.identity.animateItemMotion
 import de.jeanlucmakiola.floret.identity.fadeThrough
 import de.jeanlucmakiola.floret.identity.predictiveBack
-import de.jeanlucmakiola.calendula.ui.common.declinedTitle
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.InlineTextField
 import de.jeanlucmakiola.floret.components.Position
@@ -94,8 +81,6 @@ import de.jeanlucmakiola.floret.components.SnackChip
 import de.jeanlucmakiola.floret.components.SnackChipHeight
 import de.jeanlucmakiola.floret.components.SnackChipMargin
 import de.jeanlucmakiola.floret.locale.currentLocale
-import de.jeanlucmakiola.floret.locale.localizedDateFormatter
-import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.RecurringScopeDialog
 import de.jeanlucmakiola.calendula.ui.common.eventAccent
@@ -116,9 +101,11 @@ import java.time.format.FormatStyle
 private const val CHIP_MILLIS = 4_000L
 
 /**
- * Full-text event search over title / location / description: tap a result to
- * open its detail, long-press to select several and delete them at once (#80).
- * A full-screen overlay hosted by [de.jeanlucmakiola.calendula.ui.CalendarHost].
+ * Full-text event search (top-bar entry). Type a query → matching events
+ * (title / location / description) across the whole calendar, newest-relevant
+ * first; tap a result to open its detail. Long-press a result to enter selection
+ * mode and delete several at once (#80). A full-screen overlay hosted by
+ * [de.jeanlucmakiola.calendula.ui.CalendarHost].
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -138,20 +125,12 @@ fun SearchScreen(
     val inSelection = selection.isNotEmpty()
     var showDeleteDialog by remember { mutableStateOf(false) }
 
-    // The ViewModel is activity-scoped, so a re-enter is what resets the last
-    // search, its selection and any delete receipt still up. Peeking a result
-    // doesn't re-run this — the screen stays composed under the detail.
+    // Each fresh open starts blank and straight into typing. The ViewModel is
+    // activity-scoped so it outlives the overlay; clearing on (re)enter is what
+    // resets a previous search. Peeking a result doesn't re-run this (the screen
+    // stays composed under the detail), so backing out keeps the query.
     LaunchedEffect(Unit) {
         viewModel.setQuery("")
-        viewModel.clearSelection()
-        viewModel.consumeDeleteResult()
-    }
-    // The field only exists out of selection mode, so a recreation that lands
-    // mid-selection has to wait for the clear above before it can be focused.
-    var focusPending by remember { mutableStateOf(true) }
-    LaunchedEffect(inSelection) {
-        if (inSelection || !focusPending) return@LaunchedEffect
-        focusPending = false
         focusRequester.requestFocus()
         keyboard?.show()
     }
@@ -178,9 +157,9 @@ fun SearchScreen(
         }
     }
 
-    // Back leaves selection mode before it leaves the screen, and without the
-    // predictive-back scale-out — that would read as search closing and snapping
-    // back. The two handlers are mutually exclusive on [inSelection].
+    // Back leaves selection mode before it leaves the screen — and without the
+    // predictive-back scale-out, which would read as closing search only to have
+    // it snap back. The two handlers are mutually exclusive on [inSelection].
     BackHandler(enabled = inSelection) { viewModel.clearSelection() }
 
     Scaffold(
@@ -201,8 +180,9 @@ fun SearchScreen(
             )
         },
     ) { padding ->
-        // imePadding so the idle/empty message re-centres above the keyboard and
-        // the results list lifts clear of it.
+        // imePadding shrinks the content by the keyboard, so the centered
+        // idle/empty message re-centres in the space above it (and the results
+        // list lifts clear of the keyboard too).
         Box(
             modifier = Modifier
                 .fillMaxSize()
@@ -278,8 +258,9 @@ fun SearchScreen(
 }
 
 /**
- * The search field and the contextual selection bar as one bar: the bar stays
- * in place across the swap, easing its colour and fading its slots through.
+ * The search field and the contextual selection bar as one bar: entering or
+ * leaving selection mode keeps the bar itself in place, eases its container
+ * colour and fades its slots through, rather than cutting between two bars.
  */
 @OptIn(ExperimentalMaterial3Api::class, ExperimentalMaterial3ExpressiveApi::class)
 @Composable
@@ -304,8 +285,8 @@ private fun SearchTopBar(
         animationSpec = MaterialTheme.motionScheme.fastEffectsSpec(),
         label = "search-top-bar-color",
     )
-    // Held past the selection emptying, so the count has something to draw while
-    // it fades out.
+    // Held past the selection emptying so the count has something to draw while
+    // it fades out — by then the set is already at zero.
     var lastCount by remember { mutableIntStateOf(0) }
     if (selectedCount > 0) lastCount = selectedCount
 
@@ -403,7 +384,6 @@ private fun SearchTopBar(
     )
 }
 
-@OptIn(ExperimentalFoundationApi::class)
 @Composable
 private fun SearchResults(
     results: SearchUiState.Results,
@@ -412,94 +392,41 @@ private fun SearchResults(
     onEventClick: (EventInstance) -> Unit,
     onToggle: (Long) -> Unit,
 ) {
+    val events = results.events
     LazyColumn(
         modifier = Modifier.fillMaxSize(),
-        // No horizontal inset: GroupedRow already insets itself.
+        // No horizontal inset here: GroupedRow already insets itself, and adding
+        // another 16dp made the results narrower than every other list.
         contentPadding = PaddingValues(top = 8.dp, bottom = 96.dp),
     ) {
-        results.results.months.forEach { month ->
-            stickyHeader(key = "month-${month.year}-${month.monthNumber}") {
-                SearchSectionHeader(text = monthLabel(month))
-            }
-            hitRows(month.hits, results, selection, inSelection, onEventClick, onToggle)
-        }
-        // Held back from the calendar above: matched only in the notes.
-        if (results.results.inDescriptions.isNotEmpty()) {
-            stickyHeader(key = "in-descriptions") {
-                SearchSectionHeader(text = stringResource(R.string.search_in_descriptions))
-            }
-            hitRows(
-                results.results.inDescriptions,
-                results,
-                selection,
-                inSelection,
-                onEventClick,
-                onToggle,
+        itemsIndexed(
+            items = events,
+            key = { _, event -> event.eventId },
+        ) { index, event ->
+            val deletable = results.isDeletable(event)
+            SearchResultRow(
+                event = event,
+                position = positionOf(index, events.size),
+                modifier = animateItemMotion(),
+                selected = event.eventId in selection,
+                // A read-only calendar's row can't join a batch, so in selection
+                // mode it goes quiet rather than offering a checkbox that fails.
+                inSelection = inSelection,
+                selectable = deletable,
+                onClick = when {
+                    inSelection && deletable -> ({ onToggle(event.eventId) })
+                    inSelection -> null
+                    else -> ({ onEventClick(event) })
+                },
+                onLongClick = { onToggle(event.eventId) }.takeIf { deletable && !inSelection },
             )
         }
     }
 }
 
-/** One section's rows, sharing a grouped-card run. */
-private fun LazyListScope.hitRows(
-    hits: List<SearchHit>,
-    results: SearchUiState.Results,
-    selection: Set<Long>,
-    inSelection: Boolean,
-    onEventClick: (EventInstance) -> Unit,
-    onToggle: (Long) -> Unit,
-) {
-    itemsIndexed(
-        items = hits,
-        key = { _, hit -> hit.event.eventId },
-    ) { index, hit ->
-        val event = hit.event
-        val deletable = results.isDeletable(event)
-        SearchResultRow(
-            hit = hit,
-            position = positionOf(index, hits.size),
-            modifier = animateItemMotion(),
-            selected = event.eventId in selection,
-            // A read-only calendar's row can't join a batch, so in selection
-            // mode it goes quiet rather than offering a checkbox that fails.
-            inSelection = inSelection,
-            selectable = deletable,
-            onClick = when {
-                inSelection && deletable -> ({ onToggle(event.eventId) })
-                inSelection -> null
-                else -> ({ onEventClick(event) })
-            },
-            onLongClick = { onToggle(event.eventId) }.takeIf { deletable && !inSelection },
-        )
-    }
-}
-
-/** Pinned section label, styled like the agenda's day headers. */
-@Composable
-private fun SearchSectionHeader(text: String) {
-    Surface(color = MaterialTheme.colorScheme.surface, modifier = Modifier.fillMaxWidth()) {
-        Text(
-            text = text,
-            style = MaterialTheme.typography.titleSmall,
-            color = MaterialTheme.colorScheme.onSurfaceVariant,
-            modifier = Modifier.padding(start = 28.dp, end = 28.dp, top = 16.dp, bottom = 8.dp),
-        )
-    }
-}
-
-/** "August 2026" in the locale's own field order. */
-@Composable
-private fun monthLabel(month: SearchMonth): String {
-    val locale = currentLocale()
-    return remember(month.year, month.monthNumber, locale) {
-        localizedDateFormatter(locale, "LLLLy")
-            .format(java.time.LocalDate.of(month.year, month.monthNumber, 1))
-    }
-}
-
 @Composable
 private fun SearchResultRow(
-    hit: SearchHit,
+    event: EventInstance,
     position: Position,
     modifier: Modifier = Modifier,
     selected: Boolean = false,
@@ -508,21 +435,12 @@ private fun SearchResultRow(
     onClick: (() -> Unit)?,
     onLongClick: (() -> Unit)? = null,
 ) {
-    val event = hit.event
     val dark = isSystemInDarkTheme()
     val soften = LocalSoftenColors.current
-    // On a picked row the headline is already recoloured for the secondary
-    // container, so the match is carried by weight alone there.
-    val highlight = SpanStyle(
-        fontWeight = FontWeight.Bold,
-        color = if (selected) Color.Unspecified else MaterialTheme.colorScheme.primary,
-    )
     GroupedRow(
-        // Faded like a past event anywhere else in the app — search reaches back
-        // through the whole history.
-        modifier = if (hit.isPast) modifier.alpha(EventDimAlpha) else modifier,
-        title = declinedTitle(marked(event.title, hit.titleSpans, highlight), event.isDeclined),
-        summary = searchSummary(hit, highlight),
+        modifier = modifier,
+        title = event.title,
+        summary = searchSummary(event),
         position = position,
         minHeight = 64.dp,
         selected = selected,
@@ -551,8 +469,9 @@ private fun SearchResultRow(
 }
 
 /**
- * The batch's receipt: how many went, and whether any refused. No Undo — the
- * provider can't put a deleted event back.
+ * The batch's receipt: how many events went, and whether any refused. Sits on
+ * the FAB band so the shortened list stays visible behind it. Deletes aren't
+ * reversible through the provider, so this carries no Undo.
  */
 @Composable
 private fun DeleteOutcomeChip(
@@ -573,11 +492,7 @@ private fun DeleteOutcomeChip(
                 deleteState.deleted,
             )
         }
-        is BulkDeleteUiState.NeedsPermission -> if (deleteState.deleted > 0) {
-            stringResource(R.string.search_delete_denied_partial, deleteState.deleted)
-        } else {
-            stringResource(R.string.event_delete_write_denied)
-        }
+        BulkDeleteUiState.NeedsPermission -> stringResource(R.string.event_delete_write_denied)
         else -> null
     }
     // Held past the state being consumed so the chip has something to draw while
@@ -601,31 +516,17 @@ private fun DeleteOutcomeChip(
     }
 }
 
-/** [text] with every matched run emphasised. */
-private fun marked(text: String, spans: List<MatchSpan>, style: SpanStyle): AnnotatedString =
-    if (spans.isEmpty()) {
-        AnnotatedString(text)
-    } else {
-        buildAnnotatedString {
-            append(text)
-            spans.forEach { addStyle(style, it.start, it.end) }
-        }
-    }
-
-/**
- * "Wed, 17 Jun 2026 · 09:00 · Office", with a second line excerpting the
- * description when that is where the query matched.
- */
+/** "Wed, 17 Jun 2026 · 09:00 · Office" — date, then time (or All day), then location. */
 @Composable
-private fun searchSummary(hit: SearchHit, highlight: SpanStyle): AnnotatedString {
-    val event = hit.event
+private fun searchSummary(event: EventInstance): String {
     val locale = currentLocale()
     val zone = remember { ZoneId.systemDefault() }
     val start = remember(event.start, zone) {
         JavaInstant.ofEpochMilli(event.start.toEpochMilliseconds()).atZone(zone)
     }
-    // From the span rule, not [start]: an all-day event sits at UTC midnight and
-    // would name the day before west of UTC (#82).
+    // From the shared span rule, not [start]: an all-day event sits at UTC
+    // midnight and would name the day before west of UTC (#82). The clock time
+    // below stays device-zone — it is only rendered for timed events.
     val dateText = remember(event.start, event.end, event.isAllDay, locale) {
         DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
             .format(event.spanFirstDay(TimeZone.currentSystemDefault()).toJavaLocalDate())
@@ -636,23 +537,8 @@ private fun searchSummary(hit: SearchHit, highlight: SpanStyle): AnnotatedString
     } else {
         remember(locale, use24Hour) { timeOfDayFormatter(use24Hour, locale) }.format(start)
     }
-    return buildAnnotatedString {
-        append("$dateText · $timeText")
-        event.location?.takeIf { it.isNotBlank() }?.let { location ->
-            append(" · ")
-            val offset = length
-            append(location)
-            hit.locationSpans.forEach {
-                addStyle(highlight, offset + it.start, offset + it.end)
-            }
-        }
-        hit.descriptionSnippet?.let { snippet ->
-            append("\n")
-            val offset = length
-            append(snippet.text)
-            snippet.spans.forEach { addStyle(highlight, offset + it.start, offset + it.end) }
-        }
-    }
+    val base = "$dateText · $timeText"
+    return event.location?.takeIf { it.isNotBlank() }?.let { "$base · $it" } ?: base
 }
 
 @Composable

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

@@ -6,9 +6,7 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.domain.EventSearch
 import de.jeanlucmakiola.calendula.domain.RecurringWriteScope
-import de.jeanlucmakiola.calendula.domain.SearchResults
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
@@ -28,9 +26,6 @@ import kotlinx.coroutines.flow.mapLatest
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.atStartOfDayIn
-import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Clock
 import javax.inject.Inject
 
@@ -44,14 +39,16 @@ sealed interface SearchUiState {
     /** A query ran but matched nothing. */
     data class Empty(val query: String) : SearchUiState
 
-    /** Matches by month — see [de.jeanlucmakiola.calendula.domain.EventSearch]. */
+    /** Matches, ordered nearest-to-today first (upcoming ascending, then past descending). */
     data class Results(
-        val results: SearchResults,
-        /** Rows from these are kept out of selection rather than failing later. */
+        val events: List<EventInstance>,
+        /**
+         * Calendars among the results that can't be written to (WebCal, birthday
+         * mirrors, …). Their rows are excluded from selection rather than failing
+         * at delete time.
+         */
         val readOnlyCalendarIds: Set<Long> = emptySet(),
     ) : SearchUiState {
-        val events: List<EventInstance> get() = results.allHits.map { it.event }
-
         fun isDeletable(event: EventInstance): Boolean =
             event.calendarId !in readOnlyCalendarIds
     }
@@ -66,8 +63,8 @@ sealed interface BulkDeleteUiState {
     /** Terminal: [deleted] events went, [failed] wouldn't. */
     data class Done(val deleted: Int, val failed: Int) : BulkDeleteUiState
 
-    /** WRITE_CALENDAR was revoked after [deleted] went; the rest wasn't tried. */
-    data class NeedsPermission(val deleted: Int) : BulkDeleteUiState
+    /** WRITE_CALENDAR was revoked mid-flight; nothing further was attempted. */
+    data object NeedsPermission : BulkDeleteUiState
 }
 
 @OptIn(ExperimentalCoroutinesApi::class, FlowPreview::class)
@@ -99,20 +96,12 @@ class SearchViewModel @Inject constructor(
             if (q.length < MIN_QUERY_LENGTH) {
                 SearchUiState.Idle
             } else {
-                val now = Clock.System.now()
-                val zone = TimeZone.currentSystemDefault()
-                val results = EventSearch.search(
-                    candidates = repository.searchEvents(q),
-                    query = q,
-                    now = now,
-                    todayStart = now.toLocalDateTime(zone).date.atStartOfDayIn(zone),
-                    zone = zone,
-                )
-                if (results.isEmpty) {
+                val results = repository.searchEvents(q)
+                if (results.isEmpty()) {
                     SearchUiState.Empty(q)
                 } else {
                     SearchUiState.Results(
-                        results = results,
+                        events = sortNearestFirst(results),
                         readOnlyCalendarIds = readOnlyCalendarIds(),
                     )
                 }
@@ -144,7 +133,10 @@ class SearchViewModel @Inject constructor(
         _selection.value = emptySet()
     }
 
-    /** Whether the batch needs a [RecurringWriteScope] decision before it runs. */
+    /**
+     * Whether the current selection contains a recurring event, i.e. whether the
+     * batch needs a [RecurringWriteScope] decision before it can run.
+     */
     fun selectionHasRecurring(): Boolean {
         val results = state.value as? SearchUiState.Results ?: return false
         val picked = _selection.value
@@ -152,9 +144,10 @@ class SearchViewModel @Inject constructor(
     }
 
     /**
-     * Delete every selected event. [scope] reaches the recurring ones only; a
-     * one-off always goes whole. One at a time, so a single failure doesn't take
-     * the rest with it — the tally lands in [deleteState].
+     * Delete every selected event. [scope] applies to the recurring ones only —
+     * a one-off is always removed whole, whatever the batch decision was. Runs
+     * one event at a time so a single failure doesn't take the rest with it;
+     * the tally lands in [deleteState].
      */
     fun deleteSelected(scope: RecurringWriteScope) {
         if (_deleteState.value == BulkDeleteUiState.Deleting) return
@@ -184,7 +177,7 @@ class SearchViewModel @Inject constructor(
             _selection.value = emptySet()
             _reload.value += 1
             _deleteState.value = if (denied) {
-                BulkDeleteUiState.NeedsPermission(deleted = deleted)
+                BulkDeleteUiState.NeedsPermission
             } else {
                 BulkDeleteUiState.Done(deleted = deleted, failed = failed)
             }
@@ -213,4 +206,11 @@ class SearchViewModel @Inject constructor(
             .filterNot { it.canModifyContents }
             .map { it.id }
             .toSet()
+
+    /** Soonest upcoming (and ongoing) first, then the most recent past. */
+    private fun sortNearestFirst(events: List<EventInstance>): List<EventInstance> {
+        val now = Clock.System.now()
+        val (upcoming, past) = events.partition { it.end >= now }
+        return upcoming.sortedBy { it.start } + past.sortedByDescending { it.start }
+    }
 }

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

@@ -1,13 +1,24 @@
 package de.jeanlucmakiola.calendula.ui.settings
 
+import androidx.compose.animation.Crossfade
+import androidx.compose.animation.core.snap
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.ui.common.PickerDescription
-import de.jeanlucmakiola.calendula.ui.common.ViewPreviewFrame
 import de.jeanlucmakiola.calendula.ui.month.MonthStylePreview
 import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
 import de.jeanlucmakiola.calendula.ui.month.descriptionRes
@@ -16,6 +27,7 @@ import de.jeanlucmakiola.floret.components.FullScreenPicker
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.SelectedCheck
 import de.jeanlucmakiola.floret.components.positionOf
+import de.jeanlucmakiola.floret.identity.rememberReduceMotion
 import kotlinx.datetime.DayOfWeek
 
 /**
@@ -39,21 +51,39 @@ internal fun MonthViewStylePicker(
     onDismiss: () -> Unit,
 ) {
     val options = MonthViewStyle.entries
+    val reduceMotion = rememberReduceMotion()
     FullScreenPicker(
         title = stringResource(R.string.settings_month_view_style),
         onDismiss = onDismiss,
         predictiveBack = true,
     ) {
-        ViewPreviewFrame(
-            selected = selected,
-            label = "month-style-preview",
-            modifier = Modifier.padding(vertical = 8.dp),
-        ) { shown ->
-            MonthStylePreview(
-                style = shown,
-                weekStart = weekStart,
-                height = PREVIEW_HEIGHT,
-            )
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(horizontal = 12.dp, vertical = 8.dp)
+                .height(PREVIEW_HEIGHT),
+            contentAlignment = Alignment.Center,
+        ) {
+            Crossfade(
+                targetState = selected,
+                animationSpec = if (reduceMotion) snap() else tween(durationMillis = 250),
+                label = "month-style-preview",
+            ) { shown ->
+                // The preview renders the real grid at phone size and scales it
+                // down, so its own corners are square — the frame rounds it.
+                Box(
+                    modifier = Modifier
+                        .clip(PREVIEW_SHAPE)
+                        .background(MaterialTheme.colorScheme.surface)
+                        .clipToBounds(),
+                ) {
+                    MonthStylePreview(
+                        style = shown,
+                        weekStart = weekStart,
+                        height = PREVIEW_HEIGHT,
+                    )
+                }
+            }
         }
         // The selected style's own blurb lives here, under its preview, rather
         // than on every row — the rows stay single-line and dense, and the words
@@ -79,3 +109,4 @@ internal fun MonthViewStylePicker(
 }
 
 private val PREVIEW_HEIGHT = 280.dp
+private val PREVIEW_SHAPE = RoundedCornerShape(12.dp)

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

@@ -302,14 +302,13 @@ private fun ReportProblemRow(position: Position) {
 @Composable
 private fun LanguageRow(position: Position) {
     val context = LocalContext.current
-    val supported = remember { AppLanguage.supportedTags(context, R.xml.locales_config) }
     // Setting a locale recreates the activity; mirror the choice locally so the
     // row updates instantly even before the recreation lands.
-    var current by remember { mutableStateOf(AppLanguage.currentTag(supported)) }
+    var current by remember { mutableStateOf(AppLanguage.currentTag()) }
     var showDialog by remember { mutableStateOf(false) }
 
     // null = follow the system; the rest are BCP-47 tags from locales_config.xml.
-    val options = remember(supported) { listOf<String?>(null) + supported }
+    val options = remember { listOf<String?>(null) + AppLanguage.supportedTags(context, R.xml.locales_config) }
 
     GroupedRow(
         title = stringResource(R.string.settings_language),

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

@@ -42,8 +42,6 @@ data class SettingsUiState(
     val showWeekNumbers: Boolean = false,
     /** Whether the jump-to-today control sits in the top bar instead of the FAB (#60). */
     val todayButtonInToolbar: Boolean = false,
-    /** Whether events can be dragged to another slot to reschedule them (#68, #173). */
-    val dragToReschedule: Boolean = true,
     /** How far ahead the in-app Agenda screen shows events (v2.11). */
     val agendaScreenRange: AgendaRange = AgendaRange.Month,
     /** How far ahead the agenda widget shows events (v2.11). */

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

@@ -145,15 +145,9 @@ class SettingsViewModel @Inject constructor(
                     prefs.showWeekNumbers,
                     prefs.agendaShowToday,
                     prefs.softenCalendarColors,
-                    combine(
-                        prefs.todayButtonInToolbar,
-                        prefs.dragToReschedule,
-                        ::Pair,
-                    ),
-                ) { hourLines, weekNumbers, showToday, soften, (todayInToolbar, dragToMove) ->
-                    DisplayToggles(
-                        hourLines, weekNumbers, showToday, soften, todayInToolbar, dragToMove,
-                    )
+                    prefs.todayButtonInToolbar,
+                ) { hourLines, weekNumbers, showToday, soften, todayInToolbar ->
+                    DisplayToggles(hourLines, weekNumbers, showToday, soften, todayInToolbar)
                 },
             ) { view, screenRange, widgetRange, timeFormat, toggles ->
                 ViewSettings(
@@ -163,7 +157,6 @@ class SettingsViewModel @Inject constructor(
                     agendaShowToday = toggles.agendaShowToday,
                     softenColors = toggles.softenColors,
                     todayButtonInToolbar = toggles.todayButtonInToolbar,
-                    dragToReschedule = toggles.dragToReschedule,
                 )
             },
             combine(
@@ -196,7 +189,6 @@ class SettingsViewModel @Inject constructor(
                 agendaShowToday = views.agendaShowToday,
                 softenColors = views.softenColors,
                 todayButtonInToolbar = views.todayButtonInToolbar,
-                dragToReschedule = views.dragToReschedule,
                 agendaShowRangeBar = misc.showRangeBar,
                 autofocusEventTitle = misc.autofocusEventTitle,
                 pastEventDisplay = misc.pastEventDisplay,
@@ -297,7 +289,6 @@ class SettingsViewModel @Inject constructor(
         val agendaShowToday: Boolean,
         val softenColors: Boolean,
         val todayButtonInToolbar: Boolean,
-        val dragToReschedule: Boolean,
     )
 
     private data class DisplayToggles(
@@ -306,7 +297,6 @@ class SettingsViewModel @Inject constructor(
         val agendaShowToday: Boolean,
         val softenColors: Boolean,
         val todayButtonInToolbar: Boolean,
-        val dragToReschedule: Boolean,
     )
 
     private data class MiscSettings(
@@ -544,10 +534,6 @@ class SettingsViewModel @Inject constructor(
         viewModelScope.launch { prefs.setTodayButtonInToolbar(enabled) }
     }
 
-    fun setDragToReschedule(enabled: Boolean) {
-        viewModelScope.launch { prefs.setDragToReschedule(enabled) }
-    }
-
     /**
      * Switch the launcher label (#44). The card highlights at once, then settles
      * on what the component state reports; the writes are binder round-trips and
@@ -591,15 +577,15 @@ class SettingsViewModel @Inject constructor(
 
     /**
      * Enable or disable [view] in the quick-switch cycle, via an atomic
-     * read-modify-write so a concurrent reorder can't clobber it. Any number of
-     * views may be turned off; below two the pill hides itself (#150).
+     * read-modify-write so a concurrent reorder can't clobber it. The
+     * MIN_ENABLED floor is re-checked inside the transform, because the screen's
+     * own guard reads an async-echoed snapshot.
      */
     fun setQuickSwitchViewEnabled(view: CalendarView, enabled: Boolean) {
         viewModelScope.launch {
             prefs.updateQuickSwitch { config ->
-                config.copy(
-                    enabled = if (enabled) config.enabled + view else config.enabled - view,
-                )
+                val next = if (enabled) config.enabled + view else config.enabled - view
+                if (next.size < QuickSwitchConfig.MIN_ENABLED) config else config.copy(enabled = next)
             }
         }
     }

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

@@ -32,6 +32,7 @@ import de.jeanlucmakiola.calendula.ui.common.AgendaRangePicker
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.PickerDescription
+import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
 import de.jeanlucmakiola.calendula.ui.common.TimelineScale
 import de.jeanlucmakiola.calendula.ui.common.agendaRangeLabel
 import de.jeanlucmakiola.calendula.ui.common.descriptionRes
@@ -54,8 +55,8 @@ import java.time.format.TextStyle as JavaTextStyle
  * it belongs to, plus the two cross-view ordering lists (#24, #69).
  *
  * The quick-switch cycle and the drawer list are independent orders — a view
- * off in the cycle is still reachable from the drawer, including when the cycle
- * is emptied and the pill disappears (#150).
+ * off in the cycle is still reachable from the drawer. The cycle needs at least
+ * [QuickSwitchConfig.MIN_ENABLED] targets.
  */
 @Composable
 internal fun ViewsScreen(
@@ -113,7 +114,7 @@ internal fun ViewsScreen(
         GroupedRow(
             title = stringResource(R.string.settings_dim_completed),
             summary = stringResource(R.string.settings_dim_completed_summary),
-            position = Position.Middle,
+            position = Position.Bottom,
             trailing = {
                 Switch(
                     checked = state.dimCompletedEvents,
@@ -122,18 +123,6 @@ internal fun ViewsScreen(
             },
             onClick = { viewModel.setDimCompletedEvents(!state.dimCompletedEvents) },
         )
-        GroupedRow(
-            title = stringResource(R.string.settings_drag_to_reschedule),
-            summary = stringResource(R.string.settings_drag_to_reschedule_summary),
-            position = Position.Bottom,
-            trailing = {
-                Switch(
-                    checked = state.dragToReschedule,
-                    onCheckedChange = viewModel::setDragToReschedule,
-                )
-            },
-            onClick = { viewModel.setDragToReschedule(!state.dragToReschedule) },
-        )
 
         Spacer(Modifier.height(8.dp))
         SectionHeader(stringResource(R.string.settings_month_header))
@@ -220,6 +209,8 @@ internal fun ViewsScreen(
         SectionHeader(stringResource(R.string.settings_quick_switch_header))
         SettingsHint(stringResource(R.string.settings_quick_switch_hint))
         Spacer(Modifier.height(8.dp))
+        // Turning a view off is blocked once only the minimum remain enabled.
+        val canDisable = config.enabled.size > QuickSwitchConfig.MIN_ENABLED
         ReorderableColumn(
             items = config.order,
             keyOf = { it },
@@ -235,6 +226,8 @@ internal fun ViewsScreen(
                 trailing = {
                     Switch(
                         checked = checked,
+                        // Keep the last two on: with fewer, the pill can't switch.
+                        enabled = !checked || canDisable,
                         onCheckedChange = { on -> viewModel.setQuickSwitchViewEnabled(view, on) },
                     )
                 },

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

@@ -1,21 +1,33 @@
 package de.jeanlucmakiola.calendula.ui.settings
 
+import androidx.compose.animation.Crossfade
+import androidx.compose.animation.core.snap
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
 import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import de.jeanlucmakiola.calendula.ui.common.PickerDescription
-import de.jeanlucmakiola.calendula.ui.common.ViewPreviewFrame
 import de.jeanlucmakiola.calendula.ui.month.MonthStylePreview
 import de.jeanlucmakiola.calendula.ui.month.MonthViewStyle
 import de.jeanlucmakiola.floret.components.FullScreenPicker
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.SelectedCheck
 import de.jeanlucmakiola.floret.components.positionOf
+import de.jeanlucmakiola.floret.identity.rememberReduceMotion
 import de.jeanlucmakiola.floret.locale.currentLocale
 
 /**
@@ -34,22 +46,38 @@ internal fun WeekStartPicker(
     onDismiss: () -> Unit,
 ) {
     val locale = currentLocale()
+    val reduceMotion = rememberReduceMotion()
     val resolved = selected.resolveFirstDay(locale)
     FullScreenPicker(
         title = stringResource(R.string.settings_week_start),
         onDismiss = onDismiss,
         predictiveBack = true,
     ) {
-        ViewPreviewFrame(
-            selected = resolved,
-            label = "week-start-preview",
-            modifier = Modifier.padding(vertical = 8.dp),
-        ) { day ->
-            MonthStylePreview(
-                style = monthStyle,
-                weekStart = day,
-                height = PREVIEW_HEIGHT,
-            )
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(horizontal = 12.dp, vertical = 8.dp)
+                .height(PREVIEW_HEIGHT),
+            contentAlignment = Alignment.Center,
+        ) {
+            Crossfade(
+                targetState = resolved,
+                animationSpec = if (reduceMotion) snap() else tween(durationMillis = 250),
+                label = "week-start-preview",
+            ) { day ->
+                Box(
+                    modifier = Modifier
+                        .clip(PREVIEW_SHAPE)
+                        .background(MaterialTheme.colorScheme.surface)
+                        .clipToBounds(),
+                ) {
+                    MonthStylePreview(
+                        style = monthStyle,
+                        weekStart = day,
+                        height = PREVIEW_HEIGHT,
+                    )
+                }
+            }
         }
         PickerDescription(stringResource(R.string.settings_week_start_hint))
         options.forEachIndexed { index, option ->
@@ -79,3 +107,4 @@ internal fun WeekStartPicker(
 
 /** Short enough to leave the first options on screen under it. */
 private val PREVIEW_HEIGHT = 200.dp
+private val PREVIEW_SHAPE = RoundedCornerShape(12.dp)

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

@@ -1,6 +1,7 @@
 package de.jeanlucmakiola.calendula.ui.week
 
 import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.animateColorAsState
 import androidx.compose.animation.core.animateDpAsState
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
@@ -51,7 +52,6 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.snapshotFlow
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
@@ -59,7 +59,9 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.clipToBounds
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.RectangleShape
+import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.platform.LocalDensity
@@ -69,6 +71,7 @@ import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.customActions
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
@@ -77,9 +80,6 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.hasEnded
-import de.jeanlucmakiola.calendula.ui.common.LocalChipGround
-import de.jeanlucmakiola.calendula.ui.common.eventPaint
-import de.jeanlucmakiola.calendula.ui.common.eventSurface
 import de.jeanlucmakiola.calendula.ui.common.formatCalendarTitle
 import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
 import de.jeanlucmakiola.calendula.ui.common.CalendarTitleButton
@@ -89,13 +89,7 @@ import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
-import de.jeanlucmakiola.calendula.ui.common.BLOCK_OUTER_INSET
-import de.jeanlucmakiola.calendula.ui.common.BLOCK_TEXT_PADDING
-import de.jeanlucmakiola.calendula.ui.common.BLOCK_TEXT_INSET
 import de.jeanlucmakiola.calendula.ui.common.BlockTimeLabel
-import de.jeanlucmakiola.calendula.ui.common.BlockTitle
-import de.jeanlucmakiola.calendula.ui.common.blockTextLines
-import de.jeanlucmakiola.calendula.ui.common.blockTimeLines
 import de.jeanlucmakiola.calendula.ui.common.animatedBlockPlacement
 import de.jeanlucmakiola.calendula.ui.common.ghostAlpha
 import de.jeanlucmakiola.calendula.ui.common.LocalEventMove
@@ -104,26 +98,21 @@ import de.jeanlucmakiola.calendula.ui.common.MoveTarget
 import de.jeanlucmakiola.calendula.ui.common.TimelineDragController
 import de.jeanlucmakiola.calendula.ui.common.TimelineDragOverlay
 import de.jeanlucmakiola.calendula.ui.common.TimelineDrop
-import de.jeanlucmakiola.calendula.ui.common.clipOffsetMinutes
-import de.jeanlucmakiola.calendula.ui.common.continuesAfter
-import de.jeanlucmakiola.calendula.ui.common.continuesBefore
-import de.jeanlucmakiola.calendula.ui.common.timedBlockCuts
-import de.jeanlucmakiola.calendula.ui.common.timedBlockShape
-import de.jeanlucmakiola.calendula.ui.common.eventDragAllowed
+import de.jeanlucmakiola.calendula.ui.common.beginsOn
 import de.jeanlucmakiola.calendula.ui.common.eventMoveAction
-import de.jeanlucmakiola.calendula.ui.common.eventTitleOverflow
 import de.jeanlucmakiola.calendula.ui.common.rememberEventDragSource
 import de.jeanlucmakiola.calendula.ui.common.rememberTimelineDragController
 import de.jeanlucmakiola.calendula.ui.common.startInstant
 import de.jeanlucmakiola.calendula.ui.common.LocalDimCutoff
-import de.jeanlucmakiola.calendula.ui.common.EventChipShape
+import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
+import de.jeanlucmakiola.calendula.ui.common.eventFill
+import de.jeanlucmakiola.calendula.ui.common.eventInk
 import de.jeanlucmakiola.calendula.ui.common.NowLine
 import de.jeanlucmakiola.calendula.ui.common.rememberCurrentMinute
 import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
 import de.jeanlucmakiola.calendula.ui.common.calendarSlideTransition
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarPageSwipe
-import de.jeanlucmakiola.calendula.ui.common.withTitleWeight
 import de.jeanlucmakiola.floret.identity.rememberReduceMotion
 import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
@@ -131,15 +120,14 @@ import de.jeanlucmakiola.calendula.ui.common.LocalShowHourLines
 import de.jeanlucmakiola.calendula.ui.common.LocalTimelineZoom
 import de.jeanlucmakiola.calendula.ui.common.MIN_EVENT_FRACTION
 import de.jeanlucmakiola.calendula.ui.common.MIN_TITLE_WRAP_WIDTH
+import de.jeanlucmakiola.calendula.ui.common.SECONDARY_INK_ALPHA
 import de.jeanlucmakiola.calendula.ui.common.hourHeight
 import de.jeanlucmakiola.calendula.ui.common.rememberTimelinePinchZoom
 import de.jeanlucmakiola.calendula.ui.common.formatMinuteOfDay
 import de.jeanlucmakiola.calendula.ui.common.GUTTER_CONTENT_START_INSET
 import de.jeanlucmakiola.calendula.ui.common.GUTTER_WIDTH
 import de.jeanlucmakiola.calendula.ui.common.HourGutter
-import de.jeanlucmakiola.calendula.ui.common.TIMELINE_CONTENT_END_INSET
 import de.jeanlucmakiola.calendula.ui.common.hourSeparatorLines
-import de.jeanlucmakiola.calendula.ui.common.tappedMinuteOfDay
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.common.next
 import de.jeanlucmakiola.floret.time.isoWeekNumber
@@ -160,7 +148,7 @@ private val ALL_DAY_VERTICAL_PADDING = 6.dp
 private val COLUMN_GAP = 2.dp
 
 /** Total all-day strip height for a week (0 when there are no all-day events). */
-internal fun WeekUiState.Success.allDayStripHeight(): Dp {
+private fun WeekUiState.Success.allDayStripHeight(): Dp {
     if (allDaySpans.isEmpty()) return 0.dp
     val lanes = allDaySpans.maxOf { it.lane } + 1
     return ALL_DAY_ROW_HEIGHT * lanes + ALL_DAY_VERTICAL_PADDING * 2
@@ -193,9 +181,21 @@ fun WeekScreen(
         derivedStateOf { if (dimCompleted) nowState.value else null }
     }
 
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
     val drawerState = rememberDrawerState(DrawerValue.Closed)
     val scope = rememberCoroutineScope()
 
+    // The static header + all-day strip share the app bar's scrolled colour so
+    // the whole top region elevates together once the timeline scrolls under it.
+    val topSectionColor by animateColorAsState(
+        targetValue = if (scrollBehavior.state.overlappedFraction > 0.01f) {
+            MaterialTheme.colorScheme.surfaceContainer
+        } else {
+            MaterialTheme.colorScheme.surface
+        },
+        label = "week-top-section-color",
+    )
+
     val isOnCurrentWeek = when (val s = state) {
         // True when today falls inside the displayed week — independent of which
         // weekday the user picked as the first day.
@@ -256,19 +256,19 @@ fun WeekScreen(
         },
     ) {
         Scaffold(
-            modifier = modifier,
+            modifier = modifier.nestedScroll(scrollBehavior.nestedScrollConnection),
             topBar = {
                 WeekTopBar(
                     weekStart = weekStart,
                     currentYear = currentYear,
                     selectedView = selectedView,
                     onCycleView = { onSelectView(selectedView.next(quickSwitchViews)) },
-                    quickSwitchViews = quickSwitchViews,
                     onOpenDrawer = { scope.launch { drawerState.open() } },
                     onOpenSearch = onOpenSearch,
                     onJumpToDate = jumpToDate,
                     showTodayButton = todayInToolbar,
                     onToday = jumpToToday,
+                    scrollBehavior = scrollBehavior,
                 )
             },
             floatingActionButton = {
@@ -289,6 +289,7 @@ fun WeekScreen(
                 WeekContent(
                     state = state,
                     slideDir = slideDir,
+                    topSectionColor = topSectionColor,
                     onSwipeNext = goNext,
                     onSwipePrev = goPrev,
                     onRetry = jumpToToday,
@@ -308,6 +309,7 @@ fun WeekScreen(
 private fun WeekContent(
     state: WeekUiState,
     slideDir: Int,
+    topSectionColor: Color,
     onSwipeNext: () -> Unit,
     onSwipePrev: () -> Unit,
     onRetry: () -> Unit,
@@ -372,6 +374,7 @@ private fun WeekContent(
                 is WeekUiState.Failure -> CalendarFailure(reason = s.reason, onRetry = onRetry)
                 is WeekUiState.Success -> WeekSuccess(
                     state = s,
+                    topSectionColor = topSectionColor,
                     scrollState = scrollState,
                     allDayHeight = allDayHeight,
                     dragController = dragController,
@@ -379,7 +382,7 @@ private fun WeekContent(
                     onOpenDay = onOpenDay,
                     onCreateAt = onCreateAt,
                     onDrop = { drop ->
-                        move?.move(
+                        val took = move?.move(
                             MoveRequest(
                                 eventId = drop.event.eventId,
                                 beginMillis = drop.event.start.toEpochMilliseconds(),
@@ -387,6 +390,9 @@ private fun WeekContent(
                                 target = MoveTarget.Start(drop.startInstant(zone)),
                             ),
                         )
+                        // Refused, so nothing will land: let the copy go now
+                        // rather than hold it out for a settle that never comes.
+                        if (took != true) dragController.release()
                     },
                 )
             }
@@ -396,8 +402,9 @@ private fun WeekContent(
 }
 
 @Composable
-internal fun WeekSuccess(
+private fun WeekSuccess(
     state: WeekUiState.Success,
+    topSectionColor: Color,
     scrollState: ScrollState,
     allDayHeight: Dp,
     dragController: TimelineDragController,
@@ -410,19 +417,13 @@ internal fun WeekSuccess(
         Column(
             modifier = Modifier
                 .fillMaxWidth()
-                .background(MaterialTheme.colorScheme.surface),
+                .background(topSectionColor),
         ) {
             WeekDayHeader(days = state.days, today = state.today, onOpenDay = onOpenDay)
-            // This strip is painted on `surface`, so an outlined chip has to
-            // fill with that and not with the columns' container (#230).
-            CompositionLocalProvider(
-                LocalChipGround provides MaterialTheme.colorScheme.surface,
-            ) {
-                AllDayStrip(state = state, height = allDayHeight, onEventClick = onEventClick)
-            }
+            AllDayStrip(state = state, height = allDayHeight, onEventClick = onEventClick)
         }
-        // Breathing room between the top section and the scrolling timeline
-        // below.
+        // Breathing room between the (colour-shifting) top section and the
+        // scrolling timeline below.
         Spacer(Modifier.height(8.dp))
         Timeline(
             state = state,
@@ -442,25 +443,20 @@ private fun WeekTopBar(
     currentYear: Int,
     selectedView: CalendarView,
     onCycleView: () -> Unit,
-    quickSwitchViews: List<CalendarView>,
     onOpenDrawer: () -> Unit,
     onOpenSearch: () -> Unit,
     onJumpToDate: (LocalDate) -> Unit,
     showTodayButton: Boolean,
     onToday: () -> Unit,
+    scrollBehavior: androidx.compose.material3.TopAppBarScrollBehavior,
 ) {
     val locale = currentLocale()
-    val (title, shortTitle) = remember(weekStart, locale, currentYear) {
-        formatWeekTitle(weekStart, locale, currentYear) to
-            formatWeekTitle(weekStart, locale, currentYear, abbreviated = true)
-    }
     TopAppBar(
         title = {
             CalendarTitleButton(
-                title = title,
+                title = formatWeekTitle(weekStart, locale, currentYear),
                 currentDate = weekStart,
                 onJumpToDate = onJumpToDate,
-                shortTitle = shortTitle,
             )
         },
         navigationIcon = {
@@ -481,17 +477,17 @@ private fun WeekTopBar(
             }
             ViewSwitcherPill(
                 current = selectedView,
-                cycle = quickSwitchViews,
                 onCycle = onCycleView,
+                modifier = Modifier.padding(end = 8.dp),
             )
         },
-        // Deliberately flat: M3 lifts the bar to mark content scrolling under
-        // it, but here the bar meets the header on the same surface and the
-        // tint is what makes that seam look like a separate block (#186).
+        // Match the static top section exactly: plain surface, lifting to
+        // surfaceContainer once content scrolls under the bar.
         colors = TopAppBarDefaults.topAppBarColors(
             containerColor = MaterialTheme.colorScheme.surface,
-            scrolledContainerColor = MaterialTheme.colorScheme.surface,
+            scrolledContainerColor = MaterialTheme.colorScheme.surfaceContainer,
         ),
+        scrollBehavior = scrollBehavior,
     )
 }
 
@@ -507,7 +503,7 @@ private fun WeekDayHeader(
     Row(
         modifier = Modifier
             .fillMaxWidth()
-            .padding(top = 4.dp, bottom = 8.dp, end = TIMELINE_CONTENT_END_INSET),
+            .padding(top = 4.dp, bottom = 8.dp),
     ) {
         // Mirror the day-column layout (empty weekday line + spacer) so the
         // badge lines up vertically with the date numbers. The start inset centres
@@ -603,11 +599,7 @@ private fun AllDayStrip(
             // Height is hoisted + animated so it slides and resizes smoothly;
             // padding sits inside it so the content area is lanes * row height.
             .height(height)
-            .padding(
-                top = ALL_DAY_VERTICAL_PADDING,
-                bottom = ALL_DAY_VERTICAL_PADDING,
-                end = TIMELINE_CONTENT_END_INSET,
-            ),
+            .padding(vertical = ALL_DAY_VERTICAL_PADDING),
     ) {
         // Keep the gutter-width offset so the bars line up with the day columns.
         Spacer(Modifier.width(GUTTER_WIDTH))
@@ -651,25 +643,22 @@ private fun AllDayBar(
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
     val dimCutoff = LocalDimCutoff.current
     val dimmed = dimCutoff != null && event.hasEnded(dimCutoff)
-    val paint = eventPaint(event, dark)
+    val soften = LocalSoftenColors.current
+    val fill = eventFill(event.color, dark, soften)
     Box(
         modifier = (if (dimmed) modifier.alpha(EventDimAlpha) else modifier)
-            .eventSurface(paint, EventChipShape)
+            .background(fill, RoundedCornerShape(4.dp))
             .clickable(onClick = onClick)
             .padding(horizontal = 6.dp, vertical = 2.dp)
             .semantics { contentDescription = title },
         contentAlignment = Alignment.CenterStart,
     ) {
-        val titleOverflow = eventTitleOverflow()
         Text(
             text = title,
             style = MaterialTheme.typography.labelSmall,
             maxLines = 1,
-            overflow = titleOverflow.overflow,
-            softWrap = titleOverflow.softWrap,
-            color = paint.titleInk,
-            fontWeight = paint.titleWeight,
-            textDecoration = paint.decoration,
+            overflow = TextOverflow.Ellipsis,
+            color = eventInk(fill),
         )
     }
 }
@@ -716,7 +705,6 @@ private fun Timeline(
                 modifier = Modifier
                     .weight(1f)
                     .fillMaxHeight()
-                    .padding(end = TIMELINE_CONTENT_END_INSET)
                     .clip(RoundedCornerShape(16.dp))
                     .verticalScroll(scrollState)
                     .onGloballyPositioned { dragController.geometry.viewport = it },
@@ -783,12 +771,6 @@ private fun DayColumnCard(
     LaunchedEffect(blocks, dragController.settling) {
         dragController.noteGrid(date, blocks)
     }
-    // The tap detector outlives the composition that installed it — a pinch or a
-    // Settings change moves the hour height without restarting it — so it reads
-    // the height and the callback through state handles instead of capturing
-    // them, or taps land on the scale the column had before the zoom (#148).
-    val currentHourPx = rememberUpdatedState(hourPx)
-    val currentOnCreateAt = rememberUpdatedState(onCreateAt)
     Card(
         // Plain rectangular columns — the soft corners come from the outer
         // rounded scroll viewport, so inner rounding would look odd at the edges.
@@ -808,10 +790,8 @@ private fun DayColumnCard(
                 // blocks are consumed by their own handler first. Snaps to hour.
                 .pointerInput(date) {
                     detectTapGestures { offset ->
-                        currentOnCreateAt.value(
-                            date,
-                            tappedMinuteOfDay(offset.y, currentHourPx.value),
-                        )
+                        val hour = (offset.y / hourPx).toInt().coerceIn(0, 23)
+                        onCreateAt(date, hour * 60)
                     }
                 },
         ) {
@@ -847,7 +827,7 @@ private fun DayColumnCard(
                             .offset(x = place.x, y = place.y)
                             .width(place.width)
                             .height(place.height)
-                            .padding(horizontal = BLOCK_OUTER_INSET),
+                            .padding(horizontal = 1.dp),
                     )
                 }
             }
@@ -883,83 +863,59 @@ private fun EventBlock(
     val timeLineHeight = with(density) {
         MaterialTheme.typography.labelSmall.lineHeight.toDp()
     }
-    val available = height - BLOCK_TEXT_INSET * 2
+    // What's left for text once the 2.dp top/bottom padding is paid for.
+    val available = height - 4.dp
     // Only full-width (non-overlapping) blocks that are tall enough show the
     // time. On narrow overlapping columns we drop it so the title can wrap to
     // fill the whole block, mirroring Google Calendar — and a block that cannot
-    // afford both lines spends its space on the title. Height decides that on
-    // its own: a duration threshold would keep hiding the time on a half-hour
-    // block the user has pinched open to three times the room it needs.
-    val showTime = block.laneCount == 1 &&
+    // afford both lines spends its space on the title.
+    val showTime = block.endMin - block.startMin >= 45 &&
+        block.laneCount == 1 &&
         available >= titleLineHeight + timeLineHeight
-    val textWidth = width - (BLOCK_OUTER_INSET + BLOCK_TEXT_PADDING) * 2
     // A short block drops the title rather than serving a horizontally sliced
     // one: half a letter reads as a rendering fault, while a bare colour chip
     // reads as what it is — an event too brief to label. Tap still opens it, and
     // the semantics description carries the full title either way.
     val showTitle = available >= titleLineHeight
-    // The title is served first, out of everything the block has left once the
-    // time is down to one line — but only takes the lines it will actually use,
-    // and only wraps at all once a line is wide enough to hold more than a
-    // syllable. Below that the extra lines just stack fragments of the word.
+    // Wrap the title across as many lines as the block can fit — but only once a
+    // line is wide enough to hold more than a syllable. Below that the extra
+    // lines just stack fragments of the word, and one ellipsised line reads
+    // better.
     val contentHeight = available - if (showTime) timeLineHeight else 0.dp
-    val titleBudget = (contentHeight / titleLineHeight).toInt().coerceAtLeast(1)
-    val paint = eventPaint(block.event, dark)
     val titleMaxLines = if (width < MIN_TITLE_WRAP_WIDTH) {
         1
     } else {
-        blockTextLines(
-            text = title,
-            // At the weight BlockTitle will set it in, or an invited block —
-            // drawn a weight lighter — is budgeted a line it never fills (#230).
-            style = MaterialTheme.typography.labelMedium.withTitleWeight(paint),
-            textWidth = textWidth,
-            max = titleBudget,
-        )
+        (contentHeight / titleLineHeight).toInt().coerceAtLeast(1)
     }
-    val spare = available - titleLineHeight * titleMaxLines -
-        if (showTime) timeLineHeight else 0.dp
-    val timeMaxLines = if (showTime) blockTimeLines(timeLabel, textWidth, spare) else 1
     val dimCutoff = LocalDimCutoff.current
     val dimmed = dimCutoff != null && block.event.hasEnded(dimCutoff)
+    val soften = LocalSoftenColors.current
+    val fill = eventFill(block.event.color, dark, soften)
     val zone = remember { TimeZone.currentSystemDefault() }
     val moveAction = eventMoveAction(block.event)
-    val draggable = eventDragAllowed(block.event)
-    // The drop takes this offset back off, so a tail clipped at midnight lands
-    // where the event's own start belongs (#253).
-    val clipOffset = remember(block, date, zone) { block.clipOffsetMinutes(date, zone) }
-    val cuts = remember(block, date, zone) {
-        timedBlockCuts(block.continuesBefore(date, zone), block.continuesAfter(date, zone))
-    }
-    val shape = remember(cuts) { timedBlockShape(cuts.top, cuts.bottom) }
+    // A block clipped at the top continues from the previous day: its top edge
+    // is midnight, not the event's start, so dragging it would invent a time.
+    val draggable = moveAction != null && block.beginsOn(date, zone)
     val dragModifier = rememberEventDragSource(
         enabled = draggable,
         key = block.event.instanceId,
-        onPickUp = { pointer, blockRoot, _ ->
-            dragController.begin(
-                block = block,
-                clipOffsetMin = clipOffset,
-                titleLines = if (showTitle) titleMaxLines else 0,
-                pointerInRoot = pointer,
-                blockInRoot = blockRoot,
-            )
-        },
+        onPickUp = { pointer, blockRoot, _ -> dragController.begin(block, pointer, blockRoot) },
         onMove = dragController::move,
         onDrop = { dragController.finish()?.let(onDrop) },
         onCancel = dragController::cancel,
     )
-    val lifted = draggable && dragController.ghosts(block)
+    val lifted = draggable && dragController.ghosts(block, date)
     val ghost = ghostAlpha(lifted)
     Box(
         modifier = (if (dimmed) modifier.alpha(EventDimAlpha) else modifier)
             // The source stays put as a ghost while its floating copy travels.
             .then(if (ghost < 1f) Modifier.alpha(ghost) else Modifier)
-            .eventSurface(paint, shape, cuts)
+            .background(fill, RoundedCornerShape(4.dp))
             .clickable(onClick = onClick)
             // After clickable, so it is the inner node and wins the main pass;
             // the tap still works, since a drag consumes the up.
             .then(dragModifier)
-            .padding(horizontal = BLOCK_TEXT_PADDING, vertical = BLOCK_TEXT_INSET)
+            .padding(horizontal = 4.dp, vertical = 2.dp)
             .semantics {
                 contentDescription = "$title, $timeLabel"
                 if (moveAction != null) customActions = listOf(moveAction)
@@ -967,20 +923,18 @@ private fun EventBlock(
     ) {
         Column {
             if (showTitle) {
-                BlockTitle(
-                    title = title,
+                Text(
+                    text = title,
+                    style = MaterialTheme.typography.labelMedium,
                     maxLines = titleMaxLines,
-                    textWidth = textWidth,
-                    color = paint.titleInk,
-                    textDecoration = paint.decoration,
-                    fontWeight = paint.titleWeight,
+                    overflow = TextOverflow.Ellipsis,
+                    color = eventInk(fill, alpha = 0.85f),
                 )
             }
             if (showTime) {
                 BlockTimeLabel(
                     label = timeLabel,
-                    color = paint.secondaryInk,
-                    maxLines = timeMaxLines,
+                    color = eventInk(fill, alpha = SECONDARY_INK_ALPHA),
                 )
             }
         }
@@ -1012,12 +966,7 @@ private fun WeekLoading() {
             // Same scale resolution as the loaded timeline, so the skeleton's
             // columns don't resize the moment the real week arrives.
             val totalHeight = scale.hourHeight(maxHeight) * 24
-            Row(
-                modifier = Modifier
-                    .fillMaxSize()
-                    .padding(end = TIMELINE_CONTENT_END_INSET)
-                    .verticalScroll(scrollState),
-            ) {
+            Row(modifier = Modifier.fillMaxSize().verticalScroll(scrollState)) {
                 Spacer(Modifier.width(GUTTER_WIDTH))
                 repeat(7) {
                     Box(
@@ -1052,18 +1001,13 @@ 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(
-    weekStart: LocalDate,
-    locale: Locale,
-    currentYear: Int,
-    abbreviated: Boolean = false,
-): String {
+private fun formatWeekTitle(weekStart: LocalDate, locale: Locale, currentYear: Int): String {
     val weekEnd = weekStart.plus(6, kotlinx.datetime.DateTimeUnit.DAY)
     return formatCalendarTitle(
         date = java.time.LocalDate.of(weekStart.year, weekStart.month.ordinal + 1, 1),
         locale = locale,
         currentYear = currentYear,
-        skeleton = if (abbreviated) "LLL" else "LLLL",
+        skeleton = "LLLL",
         forceYear = weekEnd.year != weekStart.year,
     )
 }

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

@@ -10,7 +10,6 @@ import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
-import de.jeanlucmakiola.calendula.domain.isDeclined
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -145,7 +144,7 @@ class WeekViewModel @Inject constructor(
 /**
  * Lay out all-day events as connected horizontal spans across the visible week.
  * Each event becomes one [AllDaySpan] from its first to its last covered column;
- * overlapping spans are stacked on separate lanes (greedy first-fit).
+ * overlapping spans are stacked on separate lanes (greedy first-fit by start).
  */
 internal fun layoutAllDay(
     events: List<EventInstance>,
@@ -159,35 +158,21 @@ internal fun layoutAllDay(
             val covered = days.indices.filter { ev.coversDay(days[it], zone) }
             if (covered.isEmpty()) null else Raw(ev, covered.first(), covered.last())
         }
-        // Declined bars are packed after every other one, so on any day they
-        // cover they land in a lane below it (#230).
-        .sortedWith(compareBy({ it.event.isDeclined }, { it.startCol }, { it.endCol }))
+        .sortedWith(compareBy({ it.startCol }, { it.endCol }))
 
-    // What each lane already holds, rather than just how far right it reaches.
-    // A single "last occupied column" only answers correctly while spans arrive
-    // in non-decreasing start order, which the declined-last rule above breaks:
-    // a Monday bar seated after a Wednesday one would be refused a lane it is
-    // nowhere near, and each wasted lane costs the all-day strip a whole row and
-    // pushes a bar closer to the month grid's MAX_EVENT_ROWS cap. Seven columns
-    // and a handful of bars, so the scan is cheaper than the sort above it.
-    val laneCols = ArrayList<MutableList<IntRange>>()
+    val laneEnd = ArrayList<Int>() // last occupied column per lane
     return raw.map { r ->
-        val cols = r.startCol..r.endCol
-        var lane = laneCols.indexOfFirst { seated -> seated.none { it overlaps cols } }
+        var lane = laneEnd.indexOfFirst { it < r.startCol }
         if (lane == -1) {
-            laneCols.add(mutableListOf(cols))
-            lane = laneCols.size - 1
+            laneEnd.add(r.endCol)
+            lane = laneEnd.size - 1
         } else {
-            laneCols[lane].add(cols)
+            laneEnd[lane] = r.endCol
         }
         AllDaySpan(r.event, r.startCol, r.endCol, lane)
     }
 }
 
-/** Whether two column ranges share a column, so they cannot share a lane. */
-private infix fun IntRange.overlaps(other: IntRange): Boolean =
-    first <= other.last && other.first <= last
-
 /** Beginning of the week (at [weekStart]) that contains this date. */
 internal fun LocalDate.startOfWeek(weekStart: DayOfWeek): LocalDate {
     // DayOfWeek.ordinal: MONDAY=0..SUNDAY=6 → identical to ISO ordering.
@@ -221,17 +206,6 @@ internal fun EventInstance.coversDay(day: LocalDate, zone: TimeZone): Boolean {
     return start < dayEnd && end > dayStart
 }
 
-/**
- * True if this event touches more than one calendar day in [zone] — an all-day
- * event covering a range, or a timed one crossing midnight. Occurrences are
- * contiguous, so covering the day after the first is the whole question.
- */
-internal fun EventInstance.spansMultipleDays(zone: TimeZone): Boolean {
-    val anchor = if (isAllDay) TimeZone.UTC else zone
-    val secondDay = start.toLocalDateTime(anchor).date.plus(1, DateTimeUnit.DAY)
-    return coversDay(secondDay, zone)
-}
-
 /**
  * Clip [events] to a single [day] and assign lanes so overlapping events render
  * side-by-side. Lane count is computed per overlap-cluster (a maximal run of

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

@@ -1,76 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.week
-
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.snapshotFlow
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.Dp
-import de.jeanlucmakiola.calendula.ui.common.ScaledViewPreview
-import de.jeanlucmakiola.calendula.ui.common.rememberTimelineDragController
-import de.jeanlucmakiola.calendula.ui.common.sampleTimelineEvents
-import kotlinx.datetime.DateTimeUnit
-import kotlinx.datetime.DayOfWeek
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.TimeZone
-import kotlinx.coroutines.flow.first
-import kotlinx.datetime.plus
-import kotlinx.datetime.toLocalDateTime
-import kotlin.time.Clock
-
-/**
- * A live, scaled-down Week view for the onboarding view chooser. The week and
- * today's column are real; only the events are stand-ins.
- *
- * The timeline is scrolled to the working day rather than to midnight — the
- * live view centres on noon once it knows its own scroll range, which a preview
- * that is never interacted with would otherwise never do.
- */
-@Composable
-internal fun WeekViewPreview(
-    weekStart: DayOfWeek,
-    height: Dp,
-    modifier: Modifier = Modifier,
-) {
-    val zone = remember { TimeZone.currentSystemDefault() }
-    val today = remember(zone) { Clock.System.now().toLocalDateTime(zone).date }
-    val state = remember(today, weekStart, zone) { sampleWeekState(today, weekStart, zone) }
-    val scrollState = rememberScrollState()
-    LaunchedEffect(Unit) {
-        snapshotFlow { scrollState.maxValue }.first { it > 0 }
-        // Half the scroll range is noon — the same centring the live view does.
-        scrollState.scrollTo(scrollState.maxValue / 2)
-    }
-
-    ScaledViewPreview(height = height, modifier = modifier) {
-        WeekSuccess(
-            state = state,
-            scrollState = scrollState,
-            allDayHeight = state.allDayStripHeight(),
-            dragController = rememberTimelineDragController(),
-            onEventClick = {},
-            onOpenDay = {},
-            onCreateAt = { _, _ -> },
-            onDrop = {},
-        )
-    }
-}
-
-/** Sample week state, laid out through the same helpers the live view uses. */
-private fun sampleWeekState(
-    today: LocalDate,
-    weekStart: DayOfWeek,
-    zone: TimeZone,
-): WeekUiState.Success {
-    val start = today.startOfWeek(weekStart)
-    val days = (0 until 7).map { start.plus(it, DateTimeUnit.DAY) }
-    val events = sampleTimelineEvents(days, today, zone)
-    return WeekUiState.Success(
-        weekStart = start,
-        today = today,
-        days = days,
-        allDaySpans = layoutAllDay(events.filter { it.isAllDay }, days, zone),
-        timedByDay = days.associateWith { layoutDay(events, it, zone) },
-    )
-}

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

@@ -1,115 +0,0 @@
-package de.jeanlucmakiola.calendula.widget
-
-import android.app.AlarmManager
-import android.app.PendingIntent
-import android.appwidget.AppWidgetManager
-import android.content.ComponentName
-import android.content.Context
-import android.content.Intent
-import androidx.core.content.getSystemService
-import de.jeanlucmakiola.calendula.widget.agenda.AgendaWidgetReceiver
-import de.jeanlucmakiola.calendula.widget.month.MonthWidgetReceiver
-import kotlinx.datetime.DateTimeUnit
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.atStartOfDayIn
-import kotlinx.datetime.plus
-import kotlinx.datetime.toLocalDateTime
-import kotlin.time.Clock
-import kotlin.time.Duration.Companion.hours
-import kotlin.time.Duration.Companion.seconds
-import kotlin.time.Instant
-
-/**
- * Holds the app's own wake-up for the next local midnight, so the home-screen
- * widgets roll "today" over on the day boundary (#228).
- *
- * The widgets used to lean on `ACTION_DATE_CHANGED`, which is not an exempted
- * implicit broadcast — a manifest-declared receiver has not been given it since
- * Android 8, leaving only the throttled `updatePeriodMillis`.
- *
- * Exactly one alarm exists at a time and every firing re-arms the next, the same
- * shape as [de.jeanlucmakiola.calendula.data.reminders.ReminderAlarmScheduler].
- * Deliberately **inexact**: `setAndAllowWhileIdle` needs no permission and
- * survives doze (plain `set` does not), a rollover a few minutes late is
- * invisible on a sleeping screen, and exact alarms stay reserved for snooze.
- */
-object WidgetRolloverScheduler {
-
-    /**
-     * Fire just *after* midnight: an alarm delivered a few milliseconds early
-     * would still read the old date and re-arm for an instant later.
-     */
-    internal val ROLLOVER_SLACK = 5.seconds
-
-    /**
-     * Arm the next rollover, or cancel a pending one when no widget is placed.
-     * Idempotent, so every trigger (boot, app start, widget added/removed, the
-     * rollover itself, a clock or timezone change) can just call it.
-     */
-    fun sync(context: Context) {
-        val appContext = context.applicationContext
-        val alarmManager = appContext.getSystemService<AlarmManager>() ?: return
-        val pendingIntent = rolloverPendingIntent(appContext)
-        if (!hasPlacedWidgets(appContext)) {
-            alarmManager.cancel(pendingIntent)
-            return
-        }
-        val triggerAt = nextRolloverAt(Clock.System.now(), TimeZone.currentSystemDefault())
-        alarmManager.setAndAllowWhileIdle(
-            AlarmManager.RTC_WAKEUP, triggerAt.toEpochMilliseconds(), pendingIntent,
-        )
-    }
-
-    /**
-     * The instant just after the next local midnight following [now] in [zone].
-     *
-     * The *actual* start of day, not 00:00, so it holds where a DST jump means
-     * midnight never happens (Havana) and where a date-line move skips a whole
-     * local date (Apia, December 2011) — the loop walks on to the next real day.
-     *
-     * The mirror case — a zone rewinding *across* midnight, so the day starts
-     * twice — resolves to the earlier start and runs an hour ahead of the clock.
-     * No live tz entry does that (Brazil dropped DST in 2019) and
-     * `updatePeriodMillis` covers it, so it isn't worth state to detect.
-     */
-    fun nextRolloverAt(now: Instant, zone: TimeZone): Instant {
-        val date = now.toLocalDateTime(zone).date
-        var days = 1
-        while (days <= MAX_LOOKAHEAD_DAYS) {
-            val candidate = date.plus(days, DateTimeUnit.DAY).atStartOfDayIn(zone) + ROLLOVER_SLACK
-            if (candidate > now) return candidate
-            days++
-        }
-        // Unreachable for any zone in the tz database. Deliberately an hour and
-        // not the slack: a 5-second retry would just hit this branch again and
-        // wake the device in a loop.
-        return now + 1.hours
-    }
-
-    private fun hasPlacedWidgets(context: Context): Boolean {
-        val manager = AppWidgetManager.getInstance(context) ?: return false
-        return PROVIDERS.any {
-            manager.getAppWidgetIds(ComponentName(context, it)).isNotEmpty()
-        }
-    }
-
-    private fun rolloverPendingIntent(context: Context): PendingIntent =
-        PendingIntent.getBroadcast(
-            context,
-            ROLLOVER_REQUEST_CODE,
-            Intent(context, WidgetUpdateReceiver::class.java)
-                .setAction(WidgetUpdateReceiver.ACTION_ROLLOVER),
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
-        )
-
-    private val PROVIDERS = listOf(
-        MonthWidgetReceiver::class.java,
-        AgendaWidgetReceiver::class.java,
-    )
-
-    /** Fixed: there is only ever one rollover alarm, and re-arming must replace it. */
-    private const val ROLLOVER_REQUEST_CODE = 0x0DA1
-
-    /** A gap of more than a couple of days does not exist in any tz database entry. */
-    private const val MAX_LOOKAHEAD_DAYS = 3
-}

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

@@ -4,7 +4,6 @@ import android.os.Build
 import androidx.compose.runtime.Composable
 import androidx.glance.GlanceTheme
 import androidx.glance.material3.ColorProviders
-import androidx.glance.text.TextDecoration
 import de.jeanlucmakiola.calendula.ui.theme.CalendulaDarkFallback
 import de.jeanlucmakiola.calendula.ui.theme.CalendulaLightFallback
 
@@ -35,10 +34,3 @@ fun CalendulaGlanceTheme(content: @Composable () -> Unit) {
     }
     GlanceTheme(colors = colors, content = content)
 }
-
-/**
- * Glance's counterpart to the app's `declinedDecoration`: a declined invitation
- * reads the same on the home screen as it does inside the app (#180).
- */
-fun glanceDeclinedDecoration(isDeclined: Boolean): TextDecoration =
-    if (isDeclined) TextDecoration.LineThrough else TextDecoration.None