chore(deps): update agp to v9.3.1

2026-08-24 05:02:19 +00:00
56 changed files with 288 additions and 5122 deletions
--- a/.gitattributes
+++ b/.gitattributes
@@ -5,4 +5,3 @@
 *.jpg binary
 *.gif binary
 *.webp binary
-app/src/test/resources/ics/*.ics -text
--- a/.gitea/workflows/release.yaml
+++ b/.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.
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,64 +7,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]

-### 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]).
-
-### 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]).
-
 ## [2.19.3] — 2026-08-22

 ### Added
@@ -1529,7 +1471,3 @@ automatically, with zero telemetry and no internet permission.
 [#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
-[#248]: https://codeberg.org/jlmakiola/calendula/issues/248
--- a/README.md
+++ b/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

--- a/app/proguard-rules.pro
+++ b/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
--- a/app/src/main/AndroidManifest.xml
+++ b/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>

--- a/app/src/main/java/de/jeanlucmakiola/calendula/CalendulaApp.kt
+++ b/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)
-        }
    }

    /**
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/AllDayReminderEncoding.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/AllDayReminderEncoding.kt
@@ -70,34 +70,6 @@ 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
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarDataSource.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarDataSource.kt
@@ -35,7 +35,6 @@ 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
@@ -85,25 +84,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 +101,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,15 +232,10 @@ 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]).
-     * [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,
@@ -747,10 +721,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,
@@ -768,13 +739,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
@@ -809,7 +778,6 @@ class AndroidCalendarDataSource @Inject constructor(
                reader.toIcsEvent(
                    reminderMinutes = queryReminders(eventId).map { it.minutes },
                    calendarName = names[calendarId],
-                    allDayReminderTimeMinutes = allDayReminderTimeMinutes,
                )
            }
        } ?: emptyList()
@@ -818,64 +786,55 @@ 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)
            }
            if (resolver.insert(CalendarContract.Reminders.CONTENT_URI, reminder) == null) {
@@ -885,6 +844,18 @@ class AndroidCalendarDataSource @Inject constructor(
        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),
@@ -1005,12 +976,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()) {
@@ -1225,13 +1194,6 @@ class AndroidCalendarDataSource @Inject constructor(
        form: EventForm,
        allDayReminderTimeMinutes: Int,
    ): Long {
-        val row = querySeriesRow(eventId)
-        // Stricter than deleteOccurrence's bare _sync_id check: EXDATE only means
-        // something on a row that recurs, so a non-recurring one keeps the
-        // exception path rather than getting a recurrence set written onto it.
-        if (row.syncId == null && !row.rrule.isNullOrBlank()) {
-            return detachOccurrence(eventId, beginMillis, row, form, allDayReminderTimeMinutes)
-        }
        // The provider clones the series row and applies these values on top.
        val values = buildOccurrenceExceptionValues(
            form = form,
@@ -1250,89 +1212,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, isAllDay = row.allDay != 0)) {
-            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,
-            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,
@@ -1349,66 +1228,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),
-            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
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImpl.kt
+++ b/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
@@ -27,7 +26,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
@@ -212,43 +210,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
        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: 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)
+        IcsImportSummary(imported = imported, skippedDuplicate = skipped)
    }

    override suspend fun createEvent(form: EventForm): Long = withContext(io) {
@@ -307,10 +288,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 {
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapper.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapper.kt
@@ -3,20 +3,13 @@ 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.format.DateTimeFormatter
-import java.time.format.ResolverStyle
-import java.time.LocalDate as JavaLocalDate
 import java.time.LocalDateTime as JavaLocalDateTime

 /** Provider-ready DTSTART / DTEND / EVENT_TIMEZONE for an event write. */
@@ -141,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()) {
@@ -195,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)
@@ -220,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) }
    }
 }

@@ -265,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`
@@ -457,7 +420,11 @@ internal fun buildOccurrenceExdateValues(
    allDay: Int,
 ): Map<String, Any?> {
    val stamp = formatExdateStamp(occurrenceMillis, isAllDay = allDay != 0)
-    val merged = (exdateStamps(existingExdate) + stamp).distinct().joinToString(",")
+    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,
@@ -468,139 +435,22 @@ internal fun buildOccurrenceExdateValues(
    )
 }

-/**
- * 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,
-): Boolean {
-    val stamp = formatExdateStamp(occurrenceMillis, isAllDay)
-    return existingExdate?.split(',')?.any { it.trim() == stamp } == true
-}
-
-/**
- * [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.
- *
- * Null when there is nothing to carry: no stamps, or a stamp in a form Calendula
- * never writes (a `TZID=`-parameterised or floating one from a sync adapter). 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 wallClockShift = Duration.between(original.anchorLocal(), updated.anchorLocal())
-    return stamps
-        .map { stamp ->
-            val local = parseExdateStamp(stamp, original.isAllDay, fromZone) ?: 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.
- *
- * Null when nothing qualifies, or when a stamp can't be read (see [shiftedExdate]).
- */
-internal fun exdateAfter(existingExdate: String?, beginMillis: Long, isAllDay: Boolean): String? {
-    val stamps = exdateStamps(existingExdate)
-    if (stamps.isEmpty()) return null
-    return stamps
-        .filter { stamp ->
-            val utc = parseExdateStamp(stamp, isAllDay, ZoneOffset.UTC) ?: return null
-            utc.toInstant(ZoneOffset.UTC).toEpochMilli() > beginMillis
-        }
-        .takeIf { it.isNotEmpty() }
-        ?.joinToString(",")
-}
-
-/** The individual stamps of an EXDATE column value; it is a comma-separated list. */
-private fun exdateStamps(exdate: String?): List<String> = exdate
-    ?.split(',')
-    ?.map { it.trim() }
-    ?.filter { it.isNotEmpty() }
-    .orEmpty()
-
 /**
 * 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 but the two forms Calendula writes, so a
- * caller can tell "not ours, leave it alone" from a value it may safely re-time.
- */
-private fun parseExdateStamp(stamp: String, isAllDay: Boolean, zone: ZoneId): JavaLocalDateTime? =
-    runCatching {
-        if (isAllDay) {
-            JavaLocalDate.parse(stamp, ALL_DAY_EXDATE).atStartOfDay()
-        } else {
-            JavaLocalDateTime.parse(stamp, TIMED_EXDATE)
-                .atZone(ZoneOffset.UTC).withZoneSameInstant(zone).toLocalDateTime()
-        }
-    }.getOrNull()
-
-/** `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 `EVENT_COLOR` / `EVENT_COLOR_KEY` columns for a colour selection. A
@@ -649,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
-}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/IcsExportMapper.kt
+++ b/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,44 +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)
-        },
        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.
- */
-internal fun exportExDates(exdate: String?, isAllDay: Boolean): List<String> = exdate
-    ?.split(',')
-    ?.map { it.trim() }
-    ?.filter { it.isNotEmpty() }
-    ?.map { if (isAllDay) it.substringBefore('T') else it }
-    ?.distinct()
-    .orEmpty()
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/Projections.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/Projections.kt
@@ -121,12 +121,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 +137,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 +153,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
 }

 /**
--- a/app/src/main/java/de/jeanlucmakiola/calendula/domain/EventColorPalette.kt
+++ b/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) }
-}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsColor.kt
+++ b/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"
--- a/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsEvent.kt
+++ b/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). */
--- a/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsParser.kt
+++ b/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,16 +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.
- */
-data class IcsImportSummary(
-    val imported: Int,
-    val skippedDuplicate: Int,
-    val failed: Int = 0,
-)
+/** 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
@@ -124,9 +62,6 @@ data class IcsImportSummary(
 * (`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()) {

@@ -134,55 +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 rather than in document order: an X-WR-CALNAME after
-        // the first VEVENT still names the calendar every event came from.
-        val calendarName = lines.asSequence()
-            .mapNotNull(::parseContentLine)
-            .firstOrNull { it.name == "X-WR-CALNAME" }
-            ?.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
@@ -190,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
@@ -211,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)
@@ -226,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++
        }
@@ -247,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) }
@@ -374,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? {
@@ -402,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
--- a/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsRecurrence.kt
+++ b/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)
-}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/IcsWriter.kt
+++ b/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")
--- a/app/src/main/java/de/jeanlucmakiola/calendula/domain/ics/ParsedIcsForm.kt
+++ b/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() },
    )
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditScreen.kt
+++ b/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
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditViewModel.kt
+++ b/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
@@ -754,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
            }
        }
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/imports/ImportScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/imports/ImportScreen.kt
@@ -93,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(
@@ -248,15 +252,6 @@ private fun DoneContent(state: ImportUiState.Done, onClose: () -> Unit) {
            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(
@@ -295,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(
@@ -319,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,
@@ -361,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,
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/imports/ImportViewModel.kt
+++ b/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
-}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/widget/WidgetRolloverScheduler.kt
+++ b/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
-}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/widget/WidgetUpdateReceiver.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/widget/WidgetUpdateReceiver.kt
@@ -12,40 +12,19 @@ import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch

 /**
- * Redraws both home-screen widgets when their data goes stale, and keeps the
- * midnight rollover alarm armed. Triggered by:
+ * Redraws both home-screen widgets when their data goes stale. Triggered by:
 *  - `PROVIDER_CHANGED` from the calendar provider — fires on any data change,
 *    so it covers both the app's own writes and external sync.
- *  - [ACTION_ROLLOVER], the app's own alarm from [WidgetRolloverScheduler] —
- *    the day boundary, so "today" highlighting and the agenda's past-event
- *    dimming move on (#228).
- *  - `TIME_SET` / `TIMEZONE_CHANGED` — the day boundary moved, so redraw *and*
- *    re-arm.
- *  - `BOOT_COMPLETED` / `MY_PACKAGE_REPLACED` — both wipe pending alarms; the
- *    latter is also what arms installs upgrading into the fix.
+ *  - `DATE_CHANGED` / `TIME_SET` / `TIMEZONE_CHANGED` — so "today" highlighting
+ *    and the upcoming window roll over at midnight / on a clock change.
 *
- * `DATE_CHANGED` is a free extra in the filter that nothing depends on — see
- * [WidgetRolloverScheduler]. The backstops are `updatePeriodMillis` in the
- * provider XML and the month widget's refresh button.
- *
- * Exported for the system broadcasts; an extra redraw from another app is
- * harmless.
+ * Both widgets also carry an `updatePeriodMillis` backstop in their provider
+ * XML, and the month widget's refresh button forces an immediate redraw.
 */
 class WidgetUpdateReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
-        // Exported, so anything can reach it with an explicit intent. Nothing
-        // here crosses a trust boundary, but narrowing to the actions we asked
-        // for keeps a stray broadcast from costing two wide provider reads.
-        if (intent.action !in HANDLED_ACTIONS) return
-        val appContext = context.applicationContext
-        // Re-arm first, so the next day boundary is covered whatever the redraw
-        // does. Every handled action either dropped, consumed or invalidated it.
-        WidgetRolloverScheduler.sync(appContext)
-        // The host sends APPWIDGET_UPDATE after both of these anyway, so
-        // redrawing here would only repeat the work in a cold process, at the
-        // moment the device is most contended.
-        if (intent.action in REARM_ONLY_ACTIONS) return
        val pending = goAsync()
+        val appContext = context.applicationContext
        // Calendar data may have changed (sync / our own write) — drop the cached
        // month window so the widgets reload fresh. Month paging does NOT call
        // this, so arrow taps stay instant.
@@ -59,23 +38,4 @@ class WidgetUpdateReceiver : BroadcastReceiver() {
            }
        }
    }
-
-    companion object {
-        /** The app's own midnight wake-up; see [WidgetRolloverScheduler]. */
-        const val ACTION_ROLLOVER = "de.jeanlucmakiola.calendula.widget.ROLLOVER"
-
-        /** Both wipe pending alarms, and the host redraws the widgets itself after them. */
-        private val REARM_ONLY_ACTIONS = setOf(
-            Intent.ACTION_BOOT_COMPLETED,
-            Intent.ACTION_MY_PACKAGE_REPLACED,
-        )
-
-        internal val HANDLED_ACTIONS = REARM_ONLY_ACTIONS + setOf(
-            ACTION_ROLLOVER,
-            Intent.ACTION_PROVIDER_CHANGED,
-            Intent.ACTION_DATE_CHANGED,
-            Intent.ACTION_TIME_CHANGED,
-            Intent.ACTION_TIMEZONE_CHANGED,
-        )
-    }
 }
--- a/app/src/main/java/de/jeanlucmakiola/calendula/widget/agenda/AgendaWidgetReceiver.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/widget/agenda/AgendaWidgetReceiver.kt
@@ -1,10 +1,7 @@
 package de.jeanlucmakiola.calendula.widget.agenda

-import android.appwidget.AppWidgetManager
-import android.content.Context
 import androidx.glance.appwidget.GlanceAppWidget
 import androidx.glance.appwidget.GlanceAppWidgetReceiver
-import de.jeanlucmakiola.calendula.widget.WidgetRolloverScheduler

 /**
 * Host-facing receiver for the agenda widget. Declared in the manifest with the
@@ -13,32 +10,4 @@ import de.jeanlucmakiola.calendula.widget.WidgetRolloverScheduler
 */
 class AgendaWidgetReceiver : GlanceAppWidgetReceiver() {
    override val glanceAppWidget: GlanceAppWidget = AgendaWidget()
-
-    /** First agenda widget placed — start rolling "today" over at midnight (#228). */
-    override fun onEnabled(context: Context) {
-        super.onEnabled(context)
-        WidgetRolloverScheduler.sync(context)
-    }
-
-    /**
-     * Last agenda widget removed. [WidgetRolloverScheduler.sync] cancels only if
-     * no month widget is left either.
-     */
-    override fun onDisabled(context: Context) {
-        super.onDisabled(context)
-        WidgetRolloverScheduler.sync(context)
-    }
-
-    /**
-     * Self-heal on the system's own `updatePeriodMillis` wake-up — see
-     * [de.jeanlucmakiola.calendula.widget.month.MonthWidgetReceiver.onUpdate].
-     */
-    override fun onUpdate(
-        context: Context,
-        appWidgetManager: AppWidgetManager,
-        appWidgetIds: IntArray,
-    ) {
-        super.onUpdate(context, appWidgetManager, appWidgetIds)
-        WidgetRolloverScheduler.sync(context)
-    }
 }
--- a/app/src/main/java/de/jeanlucmakiola/calendula/widget/month/MonthWidget.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/widget/month/MonthWidget.kt
@@ -152,17 +152,7 @@ class ShiftMonthAction : ActionCallback {
        val delta = parameters[deltaKey] ?: 0
        updateAppWidgetState(context, glanceId) { prefs ->
            val cur = prefs[MONTH_INDEX_KEY] ?: currentMonthIndex(systemZone())
-            val next = cur + delta
-            // Landing back on the current month clears the key, so the widget
-            // goes back to *following* the date rather than being pinned to
-            // whichever month was current at the tap. Paging out and back is the
-            // workaround #228's reporter used, and pinning it there would have
-            // stuck them on that month once it stopped being the current one.
-            if (next == currentMonthIndex(systemZone())) {
-                prefs.remove(MONTH_INDEX_KEY)
-            } else {
-                prefs[MONTH_INDEX_KEY] = next
-            }
+            prefs[MONTH_INDEX_KEY] = cur + delta
        }
        MonthWidget().update(context.applicationContext, glanceId)
    }
--- a/app/src/main/java/de/jeanlucmakiola/calendula/widget/month/MonthWidgetReceiver.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/widget/month/MonthWidgetReceiver.kt
@@ -1,10 +1,7 @@
 package de.jeanlucmakiola.calendula.widget.month

-import android.appwidget.AppWidgetManager
-import android.content.Context
 import androidx.glance.appwidget.GlanceAppWidget
 import androidx.glance.appwidget.GlanceAppWidgetReceiver
-import de.jeanlucmakiola.calendula.widget.WidgetRolloverScheduler

 /**
 * Host-facing receiver for the month widget. Declared in the manifest with the
@@ -12,35 +9,4 @@ import de.jeanlucmakiola.calendula.widget.WidgetRolloverScheduler
 */
 class MonthWidgetReceiver : GlanceAppWidgetReceiver() {
    override val glanceAppWidget: GlanceAppWidget = MonthWidget()
-
-    /** First month widget placed — start rolling "today" over at midnight (#228). */
-    override fun onEnabled(context: Context) {
-        super.onEnabled(context)
-        WidgetRolloverScheduler.sync(context)
-    }
-
-    /**
-     * Last month widget removed. [WidgetRolloverScheduler.sync] cancels only if
-     * no agenda widget is left either.
-     */
-    override fun onDisabled(context: Context) {
-        super.onDisabled(context)
-        WidgetRolloverScheduler.sync(context)
-    }
-
-    /**
-     * The `updatePeriodMillis` backstop is the one wake-up the *system* still
-     * owns, so it doubles as the alarm's self-heal: anything that drops a
-     * pending alarm without a broadcast (force-stop, battery restriction, an OEM
-     * freeze) is repaired here rather than on the next app open. Re-arming
-     * closer to midnight also narrows the inexact delivery window.
-     */
-    override fun onUpdate(
-        context: Context,
-        appWidgetManager: AppWidgetManager,
-        appWidgetIds: IntArray,
-    ) {
-        super.onUpdate(context, appWidgetManager, appWidgetIds)
-        WidgetRolloverScheduler.sync(context)
-    }
 }
--- a/app/src/main/res/values-ar/strings.xml
+++ b/app/src/main/res/values-ar/strings.xml
@@ -38,7 +38,7 @@
    <string name="settings_theme_system">النظام</string>
    <string name="settings_theme_light">فاتح</string>
    <string name="settings_theme_dark">داكن</string>
-    <string name="month_open_menu">فتح القائمة</string>
+    <string name="month_open_menu">افتح القائمة</string>
    <string name="month_more_actions">المزيد من الإجراءات</string>
    <string name="event_detail_edit">تعديل</string>
    <string name="event_detail_delete">حذف</string>
@@ -176,7 +176,7 @@
    <string name="reminder_at_time">في وقت الحدث</string>
    <string name="event_untitled">(بدون عنوان)</string>
    <string name="reminder_channel_name">تذكيرات الحدث</string>
-    <string name="reminder_channel_description">الإشعارات في أوقات التذكير بأحداثك</string>
+    <string name="reminder_channel_description">الإشعارات في أوقات التذكير الخاصه بأحداثك</string>
    <string name="reminder_onboarding_title">لا تفوّت أي حدث أبدًا</string>
    <string name="reminder_onboarding_body">أندرويد لا يعرض تذكيرات الأحداث من نفسه — بل يجب أن يقوم تطبيق تقويم بذلك. دع Calendula يتولى هذه المهمة.</string>
    <string name="reminder_benefit_delivery_body">كل تذكير لأحداثك يصِل كإشعار، في الوقت المحدد تمامًا.</string>
@@ -238,7 +238,7 @@
    <string name="settings_time_format_24h">٢٤-ساعة (١٤:٠٠)</string>
    <string name="agenda_range_day">اليوم</string>
    <string name="settings_agenda_show_today">إظهار اليوم دائمًا</string>
-    <string name="settings_agenda_show_today_hint">اترك اليوم في أعلى الجدول و أداته المصغرة، حتى بعد عدم وجود أي شيء اليوم.</string>
+    <string name="settings_agenda_show_today_hint">اترك اليوم في أعلى الجدول و ودجته، حتى بعد عدم وجود أي شيء اليوم.</string>
    <string name="agenda_range_this_month">هذا الشهر</string>
    <string name="agenda_range_this_week">هذا الأسبوع</string>
    <string name="settings_past_events_show">إظهار</string>
@@ -249,7 +249,7 @@
    <string name="event_edit_timezone_all">جميع المناطق الزمنية</string>
    <string name="event_edit_timezone_none">لا منطقة زمنية تطابق ”%1$s“</string>
    <string name="event_edit_timezone_local_time">%1$s توقيتك</string>
-    <string name="event_edit_timezone_recent">الأخيرة</string>
+    <string name="event_edit_timezone_recent">الأحدث</string>
    <string name="event_edit_recurrence_incomplete">أدخل رقمًا من ١ إلى ٩٩٩</string>
    <plurals name="duration_minutes">
        <item quantity="zero">(%d) لا دقائق</item>
@@ -286,7 +286,7 @@
    <string name="agenda_span_starts">يبدأ %1$s</string>
    <string name="agenda_span_ends">ينتهي %1$s</string>
    <string name="today_jump_action">الانتقال إلى اليوم</string>
-    <string name="widget_refresh">إعادة تحميل</string>
+    <string name="widget_refresh">تحديث</string>
    <string name="settings_app_name">اسم التطبيق</string>
    <string name="settings_dim_completed">تعتيم الأحداث المكتملة</string>
    <string name="settings_dim_completed_summary">تعتيم الأحداث التي انتهت بالفعل في عرض الشهر والأسبوع</string>
@@ -335,8 +335,8 @@
        <item quantity="many">%d يوم</item>
        <item quantity="other">%d يوم</item>
    </plurals>
-    <string name="settings_agenda_range_bar_hint">اعرض شريطًا في الجزء العلوي من الجدول يحدد التواريخ المعروضة، مع زر لتبديل المدى للجلسة</string>
-    <string name="settings_agenda_range_bar">شريط المدى</string>
+    <string name="settings_agenda_range_bar_hint">اعرض شريطًا في الجزء العلوي من الجدول يحدد التواريخ المعروضة، مع زر لتبديل النطاق للجلسة</string>
+    <string name="settings_agenda_range_bar">شريط النطاق</string>
    <string name="settings_month_header">عرض الشهر</string>
    <string name="month_style_continuous">تمرير الشهور</string>
    <string name="month_style_dense">أسابيع سلسة</string>
@@ -424,7 +424,7 @@
    <string name="settings_views_subtitle">العرض، التخطيط، الترتيب</string>
    <string name="settings_event_form_subtitle">الخانات الافتراضية و السلوك</string>
    <string name="settings_notifications_subtitle">التذكيرات و التسليم</string>
-    <string name="settings_special_dates_subtitle">أعياد ميلاد جهات الاتصال و الذكرات السنوية</string>
+    <string name="settings_special_dates_subtitle">أعياد ميلاد جهات الاتصال و احتفالات ذكرى</string>
    <string name="settings_special_dates_type_birthday">أعياد الميلاد</string>
    <string name="settings_special_dates_type_custom">تواريخ أخرى</string>
    <string name="settings_license">الترخيص</string>
@@ -432,7 +432,7 @@
    <string name="settings_special_dates_disable_confirm">إيقاف</string>
    <string name="settings_special_dates_sync_now">زامن الآن</string>
    <string name="settings_special_dates_never_synced">لم تتم المزامنة بعد</string>
-    <string name="settings_special_dates_paused_hint">لم يعد بإمكان Calendula قراءة جهات اتصالك، لذلك لا يتم تحديث هذه التقويمات.</string>
+    <string name="settings_special_dates_paused_hint">لم يعد بإمكان Calendula قراءة جهات الاتصال الخاصة بك، لذلك لا يتم تحديث هذه التقويمات.</string>
    <string name="calendars_manage_in_app">الإدارة في التطبيق</string>
    <string name="calendars_enable_all">تفعيل الكل</string>
    <string name="calendars_disable_all">تعطيل الكل</string>
@@ -500,11 +500,11 @@
    <string name="settings_qs_tile">إضافة مربع الإعدادات السريعة</string>
    <string name="import_button">استيراد</string>
    <string name="crash_dialog_dismiss">ليس الآن</string>
-    <string name="crash_report_copied">تم نسخ التقرير إلى حافظتك</string>
-    <string name="crash_report_open_failed">تعذّر فتح متتبع المشكلات. التقرير موجود في حافظتك.</string>
+    <string name="crash_report_copied">تم نسخ التقرير إلى الحافظة</string>
+    <string name="crash_report_open_failed">تعذّر فتح متتبع المشكلات. التقرير موجود في الحافظة الخاصة بك.</string>
    <string name="crash_report_issue_title">تقرير العطل</string>
    <string name="crash_report_clip_label">%1$s تقرير العطل</string>
-    <string name="crash_report_body_paste">_(كان التقرير طويلًا جدًا لهذا الرابط — الصقه من حافظتك هنا.)_</string>
+    <string name="crash_report_body_paste">_(كان التقرير طويلًا جدًا لهذا الرابط — الصقه من الحافظة هنا.)_</string>
    <string name="special_dates_calendar_birthday">أعياد الميلاد</string>
    <string name="special_dates_calendar_custom">التواريخ الخاصة</string>
    <string name="event_edit_recurrence_next_none">هذه القاعدة لا تتكرر أبدًا</string>
@@ -515,18 +515,18 @@
    <string name="month_split_expand">إظهار الشهر بأكمله</string>
    <string name="settings_week_day_header">الأسبوع و اليوم</string>
    <string name="settings_default_view_hint">طريقة العرض التي يفتحها Calendula عندما تقوم ببدءه.</string>
-    <string name="settings_week_start_hint">اليوم الذي يبدأ به كل أسبوع، في جميع طُرق العرض والأدوات المصغّرة.</string>
+    <string name="settings_week_start_hint">اليوم الذي يبدأ به كل أسبوع، في جميع طرق العرض والودجتز.</string>
    <string name="settings_time_format_hint">كيف الأوقات تُكتب في جميع أنحاء التطبيق. تلقائيًا يتبع إعداد نظامك.</string>
    <string name="settings_past_events_hint">ما الذي يفعله جدول بالأحداث التي انتهت بالفعل.</string>
    <string name="calendars_visibility_a11y">إظهار \"%1$s\"</string>
    <string name="calendars_visibility_notice_title">بعض التقويمات متوقفة</string>
    <string name="calendars_visibility_notice_message">Calendula يعرض التقويمات التي تم تشغيلها لهذا الجهاز، وبعض من خاصتك متوقفة. لرؤية أحداثهم، قم بتشغيلهم ضمن الإعدادات ← التقويمات.</string>
    <string name="calendar_picker_missing_title">تفتقد تقويمًا؟</string>
-    <string name="calendar_picker_missing_summary">قد يكون متوقفًا عن التشغيل، للقراءة فقط أو مملوءًا من جهات اتصالك — يمكنك إدارة تقويماتك هنا.</string>
+    <string name="calendar_picker_missing_summary">قد يكون متوقفًا عن التشغيل، للقراءة فقط أو مملوءًا من جهات الاتصال الخاصة بك — يمكنك إدارة تقويماتك هنا.</string>
    <string name="calendars_state_read_only">للقراءة فقط</string>
    <string name="calendars_state_not_synced">لم تتم المزامنة مع هذا الجهاز</string>
    <string name="calendars_state_managed">تم ملؤه من جهات اتصالك</string>
-    <string name="calendars_managed_delete_locked">تم ملء هذا التقويم من جهات اتصالك، لذلك سيقوم Calendula بإنشائه مرة أخرى في المزامنة التالية. قم بإيقاف تشغيل التواريخ الخاصة ضمن الإعدادات ← التواريخ الخاصة لحذفها.</string>
+    <string name="calendars_managed_delete_locked">تم ملء هذا التقويم من جهات الاتصال الخاصة بك، لذلك سيقوم Calendula بإنشائه مرة أخرى في المزامنة التالية. قم بإيقاف تشغيل التواريخ الخاصة ضمن الإعدادات ← التواريخ الخاصة لحذفها.</string>
    <string name="duration_custom_max">كحد أقصى %1$s</string>
    <string name="settings_calendar_duration_inherits">الافتراضي (%1$s)</string>
    <string name="settings_calendar_duration_use_default">استخدام المدة الافتراضية (%1$s)</string>
@@ -656,53 +656,26 @@
    <string name="settings_special_dates_calendar_hint">اضبط لون كل تقويم وإمكانية ظهوره في إعدادات التقويمات.</string>
    <string name="calendars_visibility_hint">قم بإيقاف تقويم لإخفائه على هذا الجهاز — تختفي أحداثه من التطبيق ويتوقف عن تذكيرك. هذا هو مفتاح التبديل نفسه الذي تستخدمه تطبيقات التقويم الأخرى خاصتك، لذلك تقوم بإخفائه أيضًا. لا شيء يتم حذفه، ولا يتأثر أي جهاز آخر، ويمكنك إعادة تشغيله من هنا في أي وقت.</string>
    <string name="settings_allday_reminder_fires_at">يتم الإشعار في %1$s</string>
-    <string name="settings_agenda_widget_range">مدى أداة الجدول</string>
-    <string name="settings_widget_size">حجم أداة الجدول</string>
-    <string name="settings_widgets_subtitle">أداة الجدول، عنصر الإعدادات السريعة</string>
+    <string name="settings_agenda_widget_range">نطاق ودجت الجدول</string>
+    <string name="settings_widget_size">حجم ودجت الجدول</string>
+    <string name="settings_widgets_subtitle">ودجت الجدول، عنصر الإعدادات السريعة</string>
    <string name="settings_drag_to_reschedule">السحب لتعديل الموعد</string>
    <string name="settings_drag_to_reschedule_summary">انقل حدثًا عن طريق سحبه إلى يوم أو وقت آخر</string>
    <string name="event_move_blocked_series_end">لا يمكن نقل حدث بعد نهاية سلسلته</string>
    <string name="crash_dialog_report">تقرير</string>
-    <string name="settings_quick_switch_hint">اختر أي طُرق العرض التي يتم التنقل بينها باستخدام الزر في أعلى اليمين، واسحب لإعادة ترتيبهم. تظل طُرق العرض التي تم إيقافها متاحة من قائمة التنقل.</string>
+    <string name="settings_quick_switch_hint">اختر أي طُرق العرض التي يتم التنقل بينها باستخدام الزر الموجود في أعلى اليمين، واسحب لإعادة ترتيبها. تظل طرق العرض التي تم إيقاف تشغيلها متاحة من قائمة التنقل.</string>
    <string name="calendars_account_from_source">%1$s (%2$s)</string>
    <string name="duration_hours_minutes">%1$s %2$s</string>
-    <string name="settings_widgets_hint">إعدادات لأدوات الشاشة الرئيسية وعنصر الإعدادات السريعة. أضف أداة عن طريق الضغط لفترة طويلة على شاشتك الرئيسية.</string>
+    <string name="settings_widgets_hint">إعدادات لوجدتز الشاشة الرئيسية وعنصر لوحة الإعدادات السريعة. أضف وجدت عن طريق الضغط لفترة طويلة على شاشتك الرئيسية.</string>
    <string name="import_warning_attendees">لم يتم استيراد قوائم الضيوف.</string>
    <string name="settings_reliable_delivery_exempt">معفى من تحسين البطارية — تصل التذكيرات في الوقت المحدد.</string>
    <string name="settings_reliable_delivery">توصيل موثوق</string>
    <string name="settings_allday_reminder_time_hint">تنطلق التذكيرات لأحداث التي تستمر طوال اليوم عند %1$s</string>
-    <string name="agenda_range_override_hint">فقط للآن — يعيد التعيين للمدى المحفوظ خاصتك عند إعادة فتح Calendula.</string>
+    <string name="agenda_range_override_hint">فقط للآن — يعيد التعيين إلى المدى المحفوظ الخاص بك عند إعادة فتح Calendula.</string>
    <string name="settings_past_events_sample_morning">مراجعة الفريق</string>
    <string name="settings_past_events_sample_midday">غداء مع روبن</string>
    <string name="settings_past_events_sample_evening">ممارسة الجوقة</string>
    <string name="settings_special_dates_last_synced">آخر مزامنة %1$s</string>
    <string name="settings_special_dates_disable_type_message">يؤدي هذا لحذف التقويم ”%1$s“ وأحداثه. سيتم فقدان أي تذكيرات أو ملاحظات أضفتها إليه.</string>
    <string name="special_dates_default_title_birthday">عيد ميلاد {name} ({year})</string>
-    <string name="event_move_action">نقل…</string>
-    <string name="settings_font_specimen_heading">الخميس، 14 مايو</string>
-    <string name="settings_font_specimen_body">مراجعة الفريق في 10:00، ثم الغداء مع روبن في المقهى في ماركتبلاتز.</string>
-    <string name="settings_section_widgets">الأدوات المصغّرة والعناصر</string>
-    <string name="settings_widget_size_hint">مدى حجم النص الذي يعرضه جدول أداة الشاشة الرئيسية. أداة الشهر ليس لديه إعداد — تتناسب شبكته دائمًا نفسه للمساحة التي تمنحها إيّاه.</string>
-    <string name="settings_agenda_widget_range_hint">كم مدى يعرض جدول أداة الشاشة الرئيسية الأحداث.</string>
-    <string name="settings_agenda_range_hint">كم مدى يعرض شاشة الجدول الأحداث.</string>
-    <string name="app_name">Calendula</string>
-    <string name="font_atkinson_hyperlegible">Atkinson Hyperlegible</string>
-    <string name="settings_special_dates_show_year">إظهار السنة</string>
-    <string name="settings_special_dates_show_year_hint">تضمين {year} في العناوين عندما يكون معروفًا</string>
-    <string name="special_dates_default_title_custom">{name}</string>
-    <string name="special_dates_default_title_anniversary">ذكرى {name} السنوية ({year})</string>
-    <string name="special_dates_calendar_anniversary">الذكرات السنوية</string>
-    <string name="crash_dialog_message">أُغلق %1$s بشكل غير متوقع في المرة الأخيرة. يمكنك المساعدة في إصلاحه عن طريق إرسال هذا التقرير كمشكلة. سيبقى على جهازك حتى تختار مشاركته، ولا يتضمن أي بيانات شخصية أو محتوى تقويم — فقط التفاصيل الفنية أدناه.</string>
-    <string name="font_lora">Lora</string>
-    <string name="font_jetbrains_mono">JetBrains Mono</string>
-    <string name="onboarding_backup_benefit_folder_title">مجلد تختاره</string>
-    <string name="import_warning_timezone">منطقة زمنية غير معروفة ترجع إلى الخاصة بجهازك.</string>
-    <string name="settings_calendar_reminders_managed_hint">تعيين في تواريخ جهات الاتصال الخاصة</string>
-    <string name="settings_special_dates_disable_all_message">يؤدي هذا إلى حذف تقويمات تواريخ جهات الاتصال وأحداثها. سيتم فقدان أي تذكيرات أو ملاحظات أضفتها إليها.</string>
-    <string name="settings_special_dates_type_anniversary">الذكرات السنوية</string>
-    <string name="settings_special_dates_template_hint">استخدم {name} لجهة الاتصال و{year} للسنة (سنة الميلاد، أو سنة بدء الذكرى السنوية؛ مخفية عندما تكون غير معروفة).</string>
-    <string name="settings_special_dates_template">صيغة العنوان</string>
-    <string name="settings_calendar_reminders_hint">تجاوز الافتراضي لكل تقويم — بشكل منفصل للمحدد بوقت وأحداث طوال اليوم. يمكن لتقويم الاحتفاظ بالافتراضي، إسقاطه أو تعيين خاصّته.</string>
-    <string name="event_move_occurrence_only">سيؤدي نقل السلسلة بأكملها لتغيير الأيام التي تقع فيها، لذلك يمكن نقل هذا الحدث فقط.</string>
-    <string name="agenda_empty_title">أنت على اطلاع</string>
 </resources>
--- a/app/src/main/res/values-be/strings.xml
+++ b/app/src/main/res/values-be/strings.xml
@@ -1,474 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string-array name="backup_interval_units">
-        <item>Minutes</item>
-        <item>Hours</item>
-        <item>Days</item>
-        <item>Weeks</item>
-    </string-array>
-    <string name="app_tagline">Сучасны каляндар.</string>
-    <string name="state_loading">Загрузка…</string>
-    <string name="state_retry">Паўтарыць спробу</string>
-    <string name="state_failure_unknown">Узнікла нейкая праблема.</string>
-    <string name="state_failure_permission">Патрабуецца доступ да календара.</string>
-    <string name="state_failure_permission_action">Дазволіць доступ</string>
-    <string name="state_failure_no_calendars">Календары не сканфігураваныя.</string>
-    <string name="state_failure_no_calendars_action">Адкрыць сыстэмныя налады календароў</string>
-    <string name="state_failure_provider">Немагчыма прачытаць каляндар.</string>
-    <string name="permission_rationale_title">Прагляд усіх падзеяў у прыгожым выглядзе</string>
-    <string name="permission_rationale_body">Для паказу і кіраваньня падзеямі Calendula патрабуецца доступ да вашага календара.</string>
-    <string name="permission_request_button">Дазволіць доступ да календара</string>
-    <string name="permission_denied_title">Няма доступу да календара</string>
-    <string name="permission_denied_body">Calendula ня можа паказваць падзеі бяз доступу да календара.</string>
-    <string name="permission_open_settings_button">Адкрыць сыстэмныя налады</string>
-    <string name="permission_retry_button">Паўтарыць спробу</string>
-    <string name="permission_benefit_private_title">Распрацавана з акцэнтам на прыватнасьць</string>
-    <string name="permission_benefit_private_body">Бяз доступу да Інтэрнэту, без тэлемэтрыі — нічога і ніколі не пакідае ваш тэлефон.</string>
-    <string name="permission_benefit_sync_title">Усе вашы календары разам</string>
-    <string name="permission_benefit_sync_body">Google, CalDAV, лякальныя — паказваюцца ўсе, сынхранізаваныя з прыладай.</string>
-    <string name="permission_benefit_privacy_title">Ніякага адсочваньня, ніколі</string>
-    <string name="permission_benefit_privacy_body">Без тэлемэтрыі, без аналітыкі, без рэклямы.</string>
-    <string name="permission_privacy_footnote">Усё застаецца на прыладзе, доступ да Інтэрнэту не патрабуецца</string>
-    <string name="month_prev">Папярэдні месяц</string>
-    <string name="month_next">Наступны месяц</string>
-    <string name="month_today_action">Сёньня</string>
-    <string name="month_more_actions">Іншыя дзеяньні</string>
-    <string name="month_open_menu">Адкрыць мэню</string>
-    <string name="month_action_settings">Налады</string>
-    <string name="month_a11y_today_prefix">Сёньня</string>
-    <string name="week_today_action">Гэты тыдзень</string>
-    <string name="week_number_label">Тдз.</string>
-    <string name="day_today_action">Сёньня</string>
-    <string name="event_detail_back">Назад</string>
-    <string name="event_detail_edit">Праўка</string>
-    <string name="event_detail_delete">Выдаліць</string>
-    <string name="event_detail_share">Падзяліцца</string>
-    <string name="event_detail_duplicate">Дублікат</string>
-    <string name="event_share_chooser_title">Падзяліцца падзеяй</string>
-    <string name="event_share_failed">Не атрымалася падзяліцца гэтай падзеяй.</string>
-    <string name="event_delete_title">Выдаліць падзею?</string>
-    <string name="event_delete_body">Падзея выдаленая з вашага календара і з усіх прыладаў, зь якімі адбываецца сынхранізацыя.</string>
-    <string name="event_delete_recurring_title">Выдаліць пэрыядычную падзею</string>
-    <string name="event_delete_option_occurrence">Толькі гэтую падзею</string>
-    <string name="event_delete_option_following">Гэтую і ўсе наступныя падзеі</string>
-    <string name="event_delete_option_series">Усе падзеі ў пасьлядоўнасьці</string>
-    <string name="event_edit_recurring_title">Рэдагаваць пэрыядычную падзею</string>
-    <string name="event_delete_failed">Не атрымалася выдаліць падзею</string>
-    <string name="event_delete_write_denied">Для выдаленьня падзеяў Calendula патрабуецца дазвол на запіс</string>
-    <string name="event_move_action">Перанесці…</string>
-    <string name="event_move_recurring_title">Перанесці пэрыядычную падзею</string>
-    <string name="event_move_occurrence_only">Перанос усёй пасьлядоўнасьці зьменіць дні, на якія яна прыпадае, таму перанесці можна толькі гэтую падзею.</string>
-    <string name="event_move_done">Перанесена на %1$s</string>
-    <string name="event_move_undo">АдрабІць</string>
-    <string name="event_move_undone">Перанос скасаваны</string>
-    <string name="event_move_failed">Не атрымалася перанесьці падзею</string>
-    <string name="event_move_write_denied">Для пераносу падзеяў Calendula патрабуецца дазвол на запіс</string>
-    <string name="event_move_gone">Гэтай падзеі больш не існуе</string>
-    <string name="event_move_blocked_series_end">Нельга перанесьці падзею на дату пасьля заканчэньня яе пасьлядоўнасьці</string>
-    <string name="dialog_cancel">Адмена</string>
-    <string name="dialog_ok">ОК</string>
-    <string name="event_edit_new_title">Новая падзея</string>
-    <string name="event_edit_close">Закрыць</string>
-    <string name="event_edit_save">Захаваць</string>
-    <string name="event_edit_title_hint">Дадаць загаловак</string>
-    <string name="event_edit_managed_hint">Кіруецца «%1$s» — загаловак, дата і паўтор сынхранізуюцца з вашымі кантактамі. Напаміны, месцазнаходжаньне і нататкі даступныя вам для рэдагаваньня.</string>
-    <string name="event_edit_starts">Пачатак</string>
-    <string name="event_edit_ends">Заканчэньне</string>
-    <string name="event_edit_error_end_before_start">Заканчваецца раней, чым пачынаецца</string>
-    <string name="event_edit_error_no_calendar">Няма календара, у які дазволены запіс</string>
-    <string name="event_edit_save_failed">Не атрымалася захаваць падзею</string>
-    <string name="event_edit_write_denied">Для стварэньня падзеяў Calendula патрабуецца дазвол на запіс</string>
-    <string name="event_edit_more_fields">Дадатковыя палі</string>
-    <string name="event_edit_add">Дадаць</string>
-    <string name="event_edit_add_reminder">Дадаць напамін</string>
-    <string name="event_edit_remove_reminder">Выдаліць напамін</string>
-    <string name="event_edit_attendees">Наведвальнікі</string>
-    <string name="event_edit_add_guest">Дадаць наведвальніка</string>
-    <string name="event_edit_add_guest_hint">Дадаць наведвальніка праз электронную пошту…</string>
-    <string name="event_edit_add_guest_from_contacts">Дадаць з кантактаў</string>
-    <string name="event_edit_location_from_contacts">Выбраць адрас з кантактаў</string>
-    <string name="event_edit_remove_guest">Выдаліць наведвальніка</string>
-    <string name="event_edit_attendee_required">Неабходны</string>
-    <string name="event_edit_attendee_optional">Неабавязковы</string>
-    <string name="event_edit_attendees_note_synced">Calendula не рассылае запрашэньні. Наведвальнікі могуць атрымаць электронныя лісты з вашага ўліковага запісу календара пры сынхранізацыі.</string>
-    <string name="event_edit_attendees_note_local">Захавана на гэтай прыладзе. Ніхто не атрымаў абвесткі.</string>
-    <string name="event_edit_reminder_custom">Карыстальніцкі</string>
-    <string name="reminder_unit_minutes">хв.</string>
-    <string name="reminder_unit_hours">гадз.</string>
-    <string name="reminder_unit_days">сут.</string>
-    <string name="reminder_unit_weeks">тыд.</string>
-    <string name="event_edit_availability">Даступнасьць</string>
-    <string name="event_edit_visibility">Бачнасьць</string>
-    <string name="event_edit_timezone_device">Часавы пояс прылады</string>
-    <string name="event_edit_timezone_device_summary">Сочыць за вашым месцазнаходжаньнем</string>
-    <string name="event_edit_timezone_search">Пошук часавых паясоў</string>
-    <string name="event_edit_timezone_recent">Апошнія</string>
-    <string name="event_edit_timezone_all">Усе часавыя паясы</string>
-    <string name="event_edit_timezone_none">Няма часавага поясу, які адпавядае «%1$s»</string>
-    <string name="event_edit_timezone_local_time">%1$s паводле вашага часу</string>
-    <string name="event_edit_color">Колер</string>
-    <string name="event_edit_color_default">Колер календара</string>
-    <string name="event_edit_color_custom">Карыстальніцкі колер</string>
-    <string name="event_edit_color_reset">Скід</string>
-    <string name="event_edit_color_unsupported">Недаступна для гэтага календара</string>
-    <string name="event_edit_color_unsupported_hint">Для гэтага календара не апублікаваны набор колераў. Для падобных календароў у наладах можна задаць карыстальніцкія колеры.</string>
-    <string name="event_edit_color_sync_warning">Пры наступнай сынхранізацыі гэты каляндар можа страціць або перазапісаць колер.</string>
-    <string name="event_edit_conflict_title">Падзея зьмянілася ў іншым месцы</string>
-    <string name="event_edit_conflict_body">Падчас рэдагаваньня вамі гэтая падзея была зьменена ў выніку сынхранізацыі або іншай праграмай. Што адбудзецца з вашымі зьменамі?</string>
-    <string name="event_edit_conflict_overwrite">Захаваць мае змены</string>
-    <string name="event_edit_conflict_overwrite_hint">Толькі адрэдагаваныя вамі палі перазапішуць зьнешнія зьмены</string>
-    <string name="event_edit_conflict_discard">Адкінуць мае зьмены</string>
-    <string name="event_edit_conflict_discard_hint">Падзея застаецца такой, якой яна ёсьць зараз</string>
-    <string name="event_edit_gone_title">Падзея выдалена</string>
-    <string name="event_edit_gone_body">Гэтая падзея ўжо выдаленая, напрыклад на іншай прыладзе. Вашыя зьмены болей немагчыма захаваць.</string>
-    <string name="import_reminder_prompt_title">Ужыць напамін па змаўчаньні?</string>
-    <string name="import_reminder_prompt_body_none">Гэтая падзея была імпартаваная без напаміну.</string>
-    <plurals name="import_reminder_prompt_body_existing">
-        <item quantity="one">"Гэтая падзея была імпартаваная з наст. колькасьцю напамінаў:  %1$d."</item>
-        <item quantity="few">"Гэтая падзея была імпартаваная з наст. колькасьцю напамінаў:  %1$d."</item>
-        <item quantity="many">"Гэтая падзея была імпартаваная з наст. колькасьцю напамінаў:  %1$d."</item>
-        <item quantity="other">"Гэтая падзея была імпартаваная з наст. колькасьцю напамінаў:  %1$d."</item>
-    </plurals>
-    <string name="import_reminder_prompt_apply">Ужыць змаўчаньні</string>
-    <string name="import_reminder_prompt_keep">Пакінуць як ёсьць</string>
-    <string name="event_edit_recurrence_none">Не паўтараецца</string>
-    <string name="event_edit_recurrence_custom">Карыстальніцкі варыянт</string>
-    <string name="event_edit_recurrence_every">Кожн.</string>
-    <string name="recurrence_unit_days">сут.</string>
-    <string name="recurrence_unit_weeks">тыд.</string>
-    <string name="recurrence_unit_months">мес.</string>
-    <string name="recurrence_unit_years">год/гады</string>
-    <string name="event_edit_recurrence_incomplete">Увядзеце лік ад 1 да 999</string>
-    <string name="event_edit_recurrence_next">Наступ.: %1$s</string>
-    <string name="event_edit_recurrence_next_none">Гэтае правіла ніколі не паўтараецца</string>
-    <string name="event_edit_recurrence_ends">Заканчэньне</string>
-    <string name="event_edit_recurrence_end_never">Ніколі</string>
-    <string name="event_edit_recurrence_end_until">На дату</string>
-    <string name="event_edit_recurrence_end_count">Пасьля некалькіх разоў</string>
-    <string name="event_edit_recurrence_times">разы(оў)</string>
-    <string name="app_name">Calendula</string>
-    <string name="event_edit_error_recurrence_ends_before_start">Паўторы заканчваюцца да пачатку падзеі</string>
-    <string name="event_availability_busy">Заняты</string>
-    <string name="event_access_default">Па змаўчаньні</string>
-    <string name="event_access_public">Публічны</string>
-    <string name="event_detail_all_day">Цэлы дзень</string>
-    <string name="event_detail_calendar">Каляндар</string>
-    <string name="event_detail_calendar_unknown">Невядомы каляндар</string>
-    <string name="event_detail_location">Месцазнаходжаньне</string>
-    <string name="event_detail_description">Апісаньне</string>
-    <string name="event_detail_attendees">Удзельнікі</string>
-    <string name="event_detail_recurrence">Паўтор</string>
-    <string name="event_detail_recurring">Паўтаральная падзея</string>
-    <string name="recurrence_daily">Кожны дзень</string>
-    <string name="recurrence_weekly">Кожны тыдзень</string>
-    <string name="recurrence_monthly">Кожны месяц</string>
-    <string name="recurrence_yearly">Кожны год</string>
-    <string name="recurrence_every_n_days">Кожныя %1$d сут.</string>
-    <string name="recurrence_every_n_weeks">Кожныя %1$d тыд.</string>
-    <string name="recurrence_every_n_months">Кожныя %1$d мес.</string>
-    <string name="recurrence_every_n_years">Кожныя %1$d гады(оў)</string>
-    <string name="recurrence_on_days">%1$s у %2$s</string>
-    <string name="recurrence_with_until">з %1$s да %2$s</string>
-    <string name="recurrence_with_count">%1$s, %2$d разы(оў)</string>
-    <string name="event_detail_not_found">Гэтай падзеі больш не існуе.</string>
-    <string name="event_attendee_accepted">Прынята</string>
-    <string name="event_attendee_declined">Адхілена</string>
-    <string name="event_attendee_tentative">Пад пытаньнем</string>
-    <string name="event_attendee_needs_action">Няма адказу</string>
-    <string name="event_attendee_unknown">—</string>
-    <string name="event_detail_reminders">Напаміны</string>
-    <string name="event_detail_timezone">Часавы пояс</string>
-    <string name="event_status_tentative">Пад пытаньнем</string>
-    <string name="event_status_cancelled">Скасавана</string>
-    <string name="event_availability_free">Свабодна</string>
-    <string name="event_access_private">Прыватна</string>
-    <string name="event_access_confidential">Канфідэнцыйна</string>
-    <string name="event_access_default_summary">Што звычайна робіць гэты каляндар</string>
-    <string name="event_access_public_summary">Поўныя зьвесткі могуць бачыць усе, хто мае доступ</string>
-    <string name="event_access_private_summary">Іншыя бачаць толькі тое, што вы занятыя</string>
-    <string name="event_access_confidential_summary">Пазначана як канфідэнцыйнае: што гэта значыць, залежыць ад уліковага запісу календара</string>
-    <string name="event_attendee_organizer">Арганізатар</string>
-    <string name="event_attendee_optional">Неабавязкова</string>
-    <string name="event_attendee_resource">Рэсурс</string>
-    <string name="event_detail_self_response">Ваш адказ: %1$s</string>
-    <string name="reminder_at_time">На момант падзеі</string>
-    <string name="reminder_default">Напамін па змаўчаньні</string>
-    <plurals name="reminder_minutes">
-        <item quantity="one">За %d хвіліну</item>
-        <item quantity="few">За %d хв.</item>
-        <item quantity="many">За %d хв.</item>
-        <item quantity="other">За %d хв.</item>
-    </plurals>
-    <plurals name="reminder_hours">
-        <item quantity="one">За %d гадзіну</item>
-        <item quantity="few">За %d гадз.</item>
-        <item quantity="many">За %d гадз.</item>
-        <item quantity="other">За %d гадз.</item>
-    </plurals>
-    <plurals name="reminder_days">
-        <item quantity="one">За %d суткі</item>
-        <item quantity="few">За %d сут.</item>
-        <item quantity="many">За %d сут.</item>
-        <item quantity="other">За %d сут.</item>
-    </plurals>
-    <plurals name="reminder_weeks">
-        <item quantity="one">За %d тыдзень</item>
-        <item quantity="few">За %d тыдз.</item>
-        <item quantity="many">За %d тыдз.</item>
-        <item quantity="other">За %d тыдз.</item>
-    </plurals>
-    <plurals name="duration_minutes">
-        <item quantity="one">%d хвіліна</item>
-        <item quantity="few">%d хв.</item>
-        <item quantity="many">%d хв.</item>
-        <item quantity="other">%d хв.</item>
-    </plurals>
-    <plurals name="duration_hours">
-        <item quantity="one">%d гадзіна</item>
-        <item quantity="few">%d гадз.</item>
-        <item quantity="many">%d гадз.</item>
-        <item quantity="other">%d гадз.</item>
-    </plurals>
-    <plurals name="duration_days">
-        <item quantity="one">%d суткі</item>
-        <item quantity="few">%d сут.</item>
-        <item quantity="many">%d сут.</item>
-        <item quantity="other">%d сут.</item>
-    </plurals>
-    <string name="duration_hours_minutes">%1$s гадз. %2$s хв.</string>
-    <string name="duration_custom_max">Макс. %1$s</string>
-    <plurals name="duration_weeks">
-        <item quantity="one">%d тыдзень</item>
-        <item quantity="few">%d тыдз.</item>
-        <item quantity="many">%d тыдз.</item>
-        <item quantity="other">%d тыдз.</item>
-    </plurals>
-    <string name="event_untitled">(без загалоўка)</string>
-    <string name="onboarding_step_counter">Крок %1$d з %2$d</string>
-    <string name="onboarding_backup_title">Вашы падзеі знаходзяцца толькі тут</string>
-    <string name="onboarding_backup_body">На гэтым тэлефоне не адбываецца сынхранізацыя зь якім-небудзь уліковым запісам, і страта азначае страту вашага календара. Calendula можа зрабіць рэзервую копію для вас.</string>
-    <string name="onboarding_backup_benefit_folder_title">Каталёг на ваш выбар</string>
-    <string name="onboarding_backup_benefit_folder_body">Рэзэрвовыя копіі — гэта звычайныя файлы .ics. Захоўвайце іх у месцы, дзе яны сынхранізуюцца, або на SD-карце.</string>
-    <string name="onboarding_backup_benefit_daily_title">Раз за суткі, аўтаматычна</string>
-    <string name="onboarding_backup_benefit_daily_body">Calendula робіць экспарт вашых лякальных календароў у фонавым рэжыме. Зьмяніць пэрыядычнасьць можна ў наладах.</string>
-    <string name="onboarding_backup_enable_button">Выбраць каталёг і зрабіць рэзэрвовую копію</string>
-    <string name="onboarding_backup_skip_button">Ня зараз</string>
-    <string name="onboarding_view_title">Што павінна адкрыцца першым?</string>
-    <string name="onboarding_month_style_title">Як мусіць выглядаць месяц?</string>
-    <string name="onboarding_view_continue_button">Далей</string>
-    <string name="onboarding_back">Назад</string>
-    <string name="onboarding_visibility_button">Зразумела</string>
-    <string name="onboarding_done_title">Усё зроблена</string>
-    <string name="onboarding_done_body">Вашы календары гатовыя. Любы выбар, зроблены зараз, можна пазьней зьмяніць у наладах.</string>
-    <string name="onboarding_done_button">Адкрыць мой каляндар</string>
-    <string name="reminder_channel_name">Напаміны пра падзеі</string>
-    <string name="reminder_channel_description">Абвесткі ў час напамінаў пра вашы падзеі</string>
-    <string name="reminder_onboarding_title">Не прапускаць ніводную падзею</string>
-    <string name="reminder_onboarding_body">Сыстэма Android сама не паказвае напаміны — гэта мусіць рабіць дадатак календара. Хай гэта робіць Calendula.</string>
-    <string name="reminder_benefit_delivery_title">Напаміны, дастаўленыя</string>
-    <string name="reminder_benefit_delivery_body">Кожны напамін пра вашы падзеі прыходзіць у выглядзе своечасовай абвесткі.</string>
-    <string name="reminder_benefit_duplicates_title">Карыстаецеся яшчэ адным дадаткам календара?</string>
-    <string name="reminder_benefit_duplicates_body">Калі іншы дадатак таксама выдае напаміны, вы будзеце бачыць іх двойчы — адключэце іх там або тут.</string>
-    <string name="reminder_benefit_reversible_title">Гэта можна зьмяніць у які заўгодна час</string>
-    <string name="reminder_benefit_reversible_body">Перамыкач знаходзіцца ў наладах, у разьдзеле «Абвесткі».</string>
-    <string name="reminder_onboarding_enable_button">Уключыць напаміны</string>
-    <string name="reminder_onboarding_skip_button">Ня зараз</string>
-    <string name="reminder_action_snooze">Адкласьці</string>
-    <string name="reminder_action_dismiss">Адхіліць</string>
-    <string name="reminder_day_tomorrow">Заўтра</string>
-    <string name="reminder_day_yesterday">Учора</string>
-    <string name="view_month">Месяц</string>
-    <string name="view_week">Тыдзень</string>
-    <string name="view_day">Дзень</string>
-    <string name="view_agenda">Расклад</string>
-    <string name="view_section">Выгляд</string>
-    <string name="drawer_jump_to_date">Пераход да даты</string>
-    <string name="agenda_today_action">Сёньня</string>
-    <string name="agenda_header_today">Сёньня</string>
-    <string name="agenda_header_tomorrow">Заўтра</string>
-    <string name="agenda_empty_title">Усё завершана</string>
-    <string name="agenda_no_more_today">Сёньня больш няма падзеяў</string>
-    <string name="agenda_span_starts">Пачатак: %1$s</string>
-    <string name="agenda_span_ends">Заканчэньне: %1$s</string>
-    <string name="today_jump_action">Перайсці на сёньня</string>
-    <string name="search_action">Пошук</string>
-    <string name="search_hint">Пошук падзеяў</string>
-    <string name="search_back">Назад</string>
-    <string name="search_clear">Ачысьціць</string>
-    <string name="search_idle_hint">Пошук падзеяў па загалоўках, месцазнаходжаньні або зацемках.</string>
-    <string name="search_empty">Няма падзей, якія адпавядаюць «%1$s».</string>
-    <plurals name="search_selected_count">
-        <item quantity="one">Вылучана: %d</item>
-        <item quantity="few">Вылучана: %d</item>
-        <item quantity="many">Вылучана: %d</item>
-        <item quantity="other">Вылучана: %d</item>
-    </plurals>
-    <string name="search_in_descriptions">Знойдзена ў апісаньнях</string>
-    <string name="search_selection_close">Зьняць вылучэньне</string>
-    <string name="search_select_all">Вылучыць усё</string>
-    <string name="search_delete_selected">Выдаліць вылучанае</string>
-    <plurals name="search_delete_title">
-        <item quantity="one">Выдаліць падзеі (%d)?</item>
-        <item quantity="few">Выдаліць падзеі (%d)?</item>
-        <item quantity="many">Выдаліць падзеі (%d)?</item>
-        <item quantity="other">Выдаліць падзеі (%d)?</item>
-    </plurals>
-    <plurals name="search_delete_done">
-        <item quantity="one">Выдаленая %d падзея</item>
-        <item quantity="few">Выдалена падзеяў: %d</item>
-        <item quantity="many">Выдалена падзеяў: %d</item>
-        <item quantity="other">Выдалена падзеяў: %d</item>
-    </plurals>
-    <string name="search_delete_partial">Выдалена %1$d, не атрымалася выдаліць %2$d</string>
-    <string name="search_delete_denied_partial">Выдалена %1$d, затым быў скасаваны дазвол на запіс</string>
-    <string name="widget_agenda_title">Наступнае</string>
-    <string name="widget_agenda_label">Расклад Calendula</string>
-    <string name="widget_month_label">Месяц Calendula</string>
-    <string name="widget_refresh">Абнавіць</string>
-    <string name="widget_new_event">Новая падзея</string>
-    <string name="widget_needs_permission">Адкрыйце Calendula, каб дазволіць доступ да календара</string>
-    <string name="widget_prev_month">Папярэдні месяц</string>
-    <string name="widget_next_month">Наступны месяц</string>
-    <string name="widget_today">Сёньня</string>
-    <string name="filter_title">Календары</string>
-    <string name="settings_title">Налады</string>
-    <string name="settings_back">Назад</string>
-    <string name="back">Назад</string>
-    <string name="settings_section_appearance">Афармленьне</string>
-    <string name="settings_theme">Тэма</string>
-    <string name="settings_theme_system">Сыстэмная</string>
-    <string name="settings_theme_light">Сьветлая</string>
-    <string name="settings_theme_dark">Цёмная</string>
-    <string name="settings_theme_hint">Сьветлы або цёмны выгляд дадатку. Выбар будзе ўжыты адразу ж.</string>
-    <string name="settings_theme_system_summary">Зараз: %1$s</string>
-    <string name="settings_default_view">Выгляд па змаўчаньні</string>
-    <string name="settings_dynamic_color">Дынамічны колер</string>
-    <string name="settings_dynamic_color_unavailable">Патрабуецца сыстэма Android вэрсіі 12 або навейшай</string>
-    <string name="settings_soften_colors">Гарманізацыя колераў календара</string>
-    <string name="settings_soften_colors_summary">Вытрымліваць адценьне і яркасьць кожнага календара, каб кожная падзея заставалася чытэльнай, а колеры спалучаліся. Адключыць, каб паказваць зыходныя колеры з крыніцы календара.</string>
-    <string name="settings_font_headings">Шрыфт загалоўкаў</string>
-    <string name="settings_font_body">Шрыфт тэксту</string>
-    <string name="settings_font_system">Сыстэмны</string>
-    <string name="font_atkinson_hyperlegible">Atkinson Hyperlegible</string>
-    <string name="font_lora">Lora</string>
-    <string name="font_jetbrains_mono">JetBrains Mono</string>
-    <string name="settings_font_choose_file">Выбраць файл…</string>
-    <string name="settings_font_custom_selected">Карыстальніцкі</string>
-    <string name="settings_font_import_failed">Не атрымалася прачытаць файлы шрыфту</string>
-    <string name="settings_font_specimen_heading">Чацьвер, 14 траўня</string>
-    <string name="settings_font_specimen_body">Камандны разгляд а 10:00, затым абед з Робінам у кавярні на Марктпляц.</string>
-    <string name="settings_week_start">Тыдзень пачынаецца з</string>
-    <string name="settings_week_start_auto">Аўтаматычна</string>
-    <string name="settings_week_start_auto_summary">Зараз: %1$s</string>
-    <string name="settings_week_numbers">Нумары тыдняў</string>
-    <string name="settings_week_numbers_summary">Паказваць нумары тыдняў календара ў рэжыме прагляду месяца</string>
-    <string name="settings_today_toolbar">Кнопка «Сёньня» на панэлі</string>
-    <string name="settings_today_toolbar_summary">Паказваць кнопку пераходу да сёньняшняга дня на панэлі прыладаў замест плаваючай кнопкі</string>
-    <string name="settings_app_name">Назва дадатку</string>
-    <string name="settings_app_name_summary">Паказаць Calendula як «Каляндар» на панэлі запуску. На панэлі запуску зьменіцца толькі назва. Пасьля пераключэньня можа зьмяніцца месцазнаходжаньне абразка.</string>
-    <string name="settings_time_format">Фармат часу</string>
-    <string name="settings_time_format_auto">Аўта</string>
-    <string name="settings_time_format_12h">12-гадз. (2:00 пасьля абеду)</string>
-    <string name="settings_time_format_24h">24-гадз. (14:00)</string>
-    <string name="settings_time_format_auto_summary">Сыстэмная налада: %1$s</string>
-    <string name="settings_hour_lines">Лініі гадзінаў</string>
-    <string name="settings_hour_lines_summary">Паказваць раздзяляльную лінію для кожнай гадзіны ў рэжыме прагляду тыдня і дня</string>
-    <string name="settings_timeline_scale">Вышыня гадзіны</string>
-    <string name="settings_timeline_scale_hint">Колькі прасторы па вэртыкалі даецца на гадзіну ў рэжыме прагляду тыдня і дня. Гэтая налада агульная для абодвух рэжымаў прагляду. Таксама можна двума пальцамі перамяшчаць лінію, каб задаць нейкую іншую вышыню для гадзінаў.</string>
-    <string name="timeline_scale_fit_day">Цэлыя суткі</string>
-    <string name="timeline_scale_fit_day_summary">На экране ўсе 24 гадзіны, прагортваць ня трэба</string>
-    <string name="timeline_scale_compact">Кампактна</string>
-    <string name="timeline_scale_compact_summary">На экране больш гадзінаў, блёкі меншыя</string>
-    <string name="timeline_scale_regular">Звычайна</string>
-    <string name="timeline_scale_regular_summary">Стандартны інтэрвал</string>
-    <string name="timeline_scale_comfortable">Камфортна</string>
-    <string name="timeline_scale_comfortable_summary">Большыя блёкі, больш прагорткі</string>
-    <string name="timeline_scale_custom">Карыстальніцкі варыянт</string>
-    <string name="timeline_scale_custom_summary">Вышыня ў выніку перамяшчэньня лініі пальцамі</string>
-    <string name="settings_dim_completed">Зацямняць завершаныя падзеі</string>
-    <string name="settings_dim_completed_summary">Зацямняць завершаныя падзеі ў рэжыме прагляду месяца і тыдня</string>
-    <string name="settings_drag_to_reschedule">Перацягваць, каб пераплянаваць</string>
-    <string name="settings_drag_to_reschedule_summary">Перанесьці падзею, перацягнуўшы яе на іншы дзень або час</string>
-    <string name="settings_past_events">Мінулыя падзеі</string>
-    <string name="settings_past_events_show">Паказваць</string>
-    <string name="settings_past_events_dim">Зацямняць</string>
-    <string name="settings_past_events_hide">Хаваць</string>
-    <string name="settings_past_events_sample_morning">Камандны разгляд</string>
-    <string name="settings_past_events_sample_midday">Абед з Робінам</string>
-    <string name="settings_past_events_sample_evening">Рэпетыцыя ў хоры</string>
-    <string name="settings_agenda_header">Расклад</string>
-    <string name="settings_agenda_range">Дыяпазон раскладу</string>
-    <string name="settings_agenda_range_hint">Наколькі далёка наперад паказваюцца падзеі на экране раскладу.</string>
-    <string name="settings_agenda_widget_range">Дыяпазон віджэта раскладу</string>
-    <string name="settings_agenda_widget_range_hint">Наколькі далёка наперад паказваюцца падзеі раскладу на галоўным экране віджэта.</string>
-    <string name="settings_widget_size">Памер віджэта раскладу</string>
-    <string name="settings_widget_size_hint">Наколькі вялікім выглядае галоўны экран, на які выводзіцца тэкст раскладу. Віджэт у рэжыме прагляду месяца ня мае падобнага парамэтра, ягоная сетка займае ўсю выдзеленую прастору.</string>
-    <string name="settings_widget_size_small">Дробны</string>
-    <string name="settings_widget_size_medium">Сярэдні</string>
-    <string name="settings_widget_size_large">Буйны</string>
-    <string name="settings_widget_size_extra_large">Вельмі буйны</string>
-    <string name="settings_widget_size_summary">Тэкст падзеі %1$d%%</string>
-    <string name="settings_agenda_show_today">Заўсёды паказваць сёньняшні дзень</string>
-    <string name="settings_agenda_show_today_hint">Сёньняшні дзень застаецца ў верхняй частцы раскладу і віджэта, нават калі падзеяў больш няма.</string>
-    <string name="settings_agenda_range_bar">Панэль дыяпазона</string>
-    <string name="settings_agenda_range_bar_hint">Паказваць уверсе панэль раскладу зь пералікам паказаных дат і кнопку для пераключэньня дыяпазону для сэсіі</string>
-    <string name="agenda_range_day">Сёньня</string>
-    <string name="agenda_range_this_week">Гэты тыдзень</string>
-    <string name="agenda_range_this_month">Гэты месяц</string>
-    <string name="agenda_range_week">Наступныя 7 сутак</string>
-    <string name="agenda_range_month">Наступныя 30 сутак</string>
-    <string name="agenda_range_custom">Свой варыянт…</string>
-    <string name="agenda_range_custom_hint">Суткі</string>
-    <string name="agenda_range_override_hint">Толькі цяпер. Пры паўторным адкрыцьці Calendula дыяпазон скінецца да захаванага значэньня.</string>
-    <string name="agenda_range_showing_label">Паказаныя ўсе будучыя падзеі для</string>
-    <plurals name="agenda_range_days">
-        <item quantity="one">%d суткі</item>
-        <item quantity="few">%d сут.</item>
-        <item quantity="many">%d сут.</item>
-        <item quantity="other">%d сут.</item>
-    </plurals>
-    <string name="settings_section_views">Рэжымы прагляду</string>
-    <string name="settings_special_dates_type_birthday">Дні нараджэньня</string>
-    <string name="settings_special_dates_type_anniversary">Юбілейныя даты</string>
-    <string name="settings_special_dates_type_custom">Іншыя даты</string>
-    <string name="settings_special_dates_template">Фармат загалоўка</string>
-    <string name="settings_special_dates_template_hint">Ужываць {name} для імя кантакту і {year} для года (год нараджэньня або год пачатку юбілейнай падзеі; схаваны, калі невядомы).</string>
-    <string name="settings_special_dates_reminders">Напаміны</string>
-    <string name="settings_special_dates_show_year">Паказаць год</string>
-    <string name="settings_special_dates_show_year_hint">Пазначаць {year} (год) у загалоўках, калі вядомы</string>
-    <string name="settings_special_dates_sync_now">Сынхранізаваць зараз</string>
-    <string name="settings_special_dates_never_synced">Пакуль не сынхранізавана</string>
-    <string name="settings_special_dates_last_synced">Апошняя сынхранізацыя %1$s</string>
-    <string name="settings_special_dates_calendar_hint">Задаць у наладах колер і бачнасьць кожнага календара.</string>
-    <string name="settings_calendar_reminders_managed_hint">Задаць асаблівыя даты кантактаў</string>
-    <string name="settings_special_dates_paused_title">Прыпынена</string>
-    <string name="settings_special_dates_paused_hint">Calendula больш ня можа чытаць вашы кантакты, таму гэтыя календары не абнаўляюцца.</string>
-    <string name="settings_special_dates_grant">Дазволіць доступ</string>
-    <string name="settings_special_dates_disable_title">Адключыць даты кантактаў?</string>
-    <string name="settings_special_dates_disable_all_message">Пры гэты выдаляцца календары з датамі кантактаў і адпаведныя падзеі. Даданыя да іх напаміны або заўвагі зьнікнуць.</string>
-    <string name="settings_special_dates_disable_type_message">Пры гэтым выдаліцца каляндар «%1$s» зь ягонымі падзеямі. Даданыя да іх напаміны або зацемкі зьнікнуць.</string>
-    <string name="settings_special_dates_disable_confirm">Адключыць</string>
-    <string name="dialog_save">Захаваць</string>
-    <string name="settings_section_about">Аб дадатку</string>
-    <string name="settings_license">Ліцэнзія</string>
-    <string name="settings_license_value">MIT</string>
-    <string name="settings_about_author">аўтар: Жан-Люк Макіёла</string>
-    <string name="settings_about_source">Зыходны код</string>
-    <string name="settings_about_privacy">Палітыка канфідэнцыйнасьці</string>
-    <string name="settings_about_support">Падтрымка распрацоўкі</string>
-    <string name="settings_about_version">Вэрсія %1$s</string>
-    <string name="settings_about_logo_desc">Абразок дадатку Calendula</string>
-    <string name="settings_report_problem">Паведаміць пра праблему</string>
-    <string name="settings_report_problem_hint">Адправіць справаздачу аб краху або адкрыць сыстэму адсочваньня праблемаў</string>
-    <string name="calendars_title">Календары</string>
-    <string name="calendars_local_header">Вашыя календары</string>
-    <string name="calendars_local_empty">Пакуль няма лякальных календароў. Стварыць, каб захоўваць падзеі толькі на гэтай прыладзе.</string>
-    <string name="calendars_add">Дадаць каляндар</string>
-    <string name="calendars_visibility_hint">Адключыць каляндар, каб схаваць яго на гэтай прыладзе — падзеі і напаміны зь яго зьнікнуць з дадатку. Гэты перамыкач выкарыстоўваюць іншыя дадаткі календара, таму яны таксама яго схаваюць. Нічога не выдаляецца, гэта не ўплывае на іншыя прылады, і вы можаце ўключыць яго зноў тут у які заўгодна час.</string>
-    <string name="calendars_visibility_a11y">Паказаць «%1$s»</string>
-    <string name="calendars_visibility_notice_title">Некаторыя календары адключаныя</string>
-    <string name="calendars_visibility_notice_message">Calendula паказвае календары, уключаныя на гэтай прыладзе, а некаторыя з вашых адключаны. Каб убачыць падзеі ў іх, уключэце іх у разьдзеле «Налады» → «Календары».</string>
-    <string name="calendar_picker_missing_title">Не хапае календара?</string>
-    <string name="calendar_picker_missing_summary">Магчыма ён адключаны, у рэжыме толькі чытаньня, або запоўнены з вашых кантактаў — кіруйце календарамі тут.</string>
-    <string name="calendars_state_read_only">Толькі чытаньне</string>
-</resources>
--- a/app/src/main/res/values-cs/strings.xml
+++ b/app/src/main/res/values-cs/strings.xml
@@ -43,25 +43,25 @@
    <string name="day_today_action">Dnes</string>
    <string name="event_detail_back">Zpět</string>
    <string name="event_detail_edit">Upravit</string>
-    <string name="event_detail_delete">Odstranit</string>
+    <string name="event_detail_delete">Vymazat</string>
    <string name="event_detail_share">Sdílet</string>
    <string name="event_detail_duplicate">Kopírovat</string>
    <string name="event_share_chooser_title">Sdílet událost</string>
    <string name="event_share_failed">Tuto událost nelze sdílet.</string>
    <string name="event_delete_title">Odstranit událost?</string>
    <string name="event_delete_body">Událost je odstraněna z kalendáře i ze všech synchronizovaných zařízení.</string>
-    <string name="event_delete_recurring_title">Odstranit opakující se událost</string>
+    <string name="event_delete_recurring_title">Smazat opakující se událost</string>
    <string name="event_delete_option_occurrence">Pouze tuto událost</string>
    <string name="event_delete_option_following">Tuto a všechny následující události</string>
    <string name="event_delete_option_series">Všechny události v sérii</string>
    <string name="event_edit_recurring_title">Upravit opakující se událost</string>
    <string name="event_delete_failed">Tuto událost nelze odstranit</string>
-    <string name="event_delete_write_denied">Calendula potřebuje oprávnění k zápisu, aby mohla odstraňovat události</string>
+    <string name="event_delete_write_denied">Calendula potřebuje oprávnění k zápisu, aby mohla mazat události</string>
    <string name="event_move_action">Přesunout…</string>
    <string name="event_move_recurring_title">Přesunout opakující se událost</string>
    <string name="event_move_occurrence_only">Přesunutí celé série by rozhodilo pořadí dnů, na které série připadá, přesunout lze tedy pouze tuto událost.</string>
    <string name="event_move_done">Přesunuto do %1$s</string>
-    <string name="event_move_undo">Vrátit</string>
+    <string name="event_move_undo">Zpět</string>
    <string name="event_move_undone">Vráceno zpět</string>
    <string name="event_move_failed">Událost nelze přesunout</string>
    <string name="event_move_write_denied">Calendula k přesouvání události vyžaduje oprávnění k zápisu</string>
@@ -111,7 +111,7 @@
    <string name="event_edit_color">Barva</string>
    <string name="event_edit_color_default">Barva kalendáře</string>
    <string name="event_edit_color_custom">Vlastní barva</string>
-    <string name="event_edit_color_reset">Znovu nastavit</string>
+    <string name="event_edit_color_reset">Obnovit</string>
    <string name="event_edit_color_unsupported">Pro tento kalendář není k dispozici</string>
    <string name="event_edit_color_unsupported_hint">Tento kalendář nemá žádnou sadu barev. Vlastní barvy kalendářů můžete povolit v nastavení.</string>
    <string name="event_edit_color_sync_warning">Tato barva může být během příští synchronizace kalendáře ztracena nebo přepsána.</string>
@@ -121,8 +121,8 @@
    <string name="event_edit_conflict_overwrite_hint">Pouze u upravených polí dojde k přepsání vnějšího zdroje</string>
    <string name="event_edit_conflict_discard">Zrušit změny</string>
    <string name="event_edit_conflict_discard_hint">Událost zůstává beze změny</string>
-    <string name="event_edit_gone_title">Událost byla odstraněna</string>
-    <string name="event_edit_gone_body">Během úpravy došlo k odstranění události, například pomocí jiného zařízení. Vaše změny již nelze uložit.</string>
+    <string name="event_edit_gone_title">Událost byla smazána</string>
+    <string name="event_edit_gone_body">Během úpravy došlo ke smazání události, například pomocí jiného zařízení. Vaše změny již nelze uložit.</string>
    <string name="import_reminder_prompt_title">Chcete použít výchozí upomínku?</string>
    <string name="import_reminder_prompt_body_none">Tato událost byla importována bez nastavené upomínky.</string>
    <plurals name="import_reminder_prompt_body_existing">
@@ -250,86 +250,4 @@
    <string name="onboarding_backup_benefit_folder_title">Složka, kterou si vyberete</string>
    <string name="onboarding_backup_benefit_folder_body">Zálohy jsou obyčejné soubory v .ics formátu — uložte je někam, kde se synchronizují, nebo na SD kartu.</string>
    <string name="onboarding_backup_benefit_daily_title">Jednou denně, automaticky</string>
-    <string name="onboarding_backup_benefit_daily_body">Calendula exportuje vaše místní kalendáře na pozadí. Frekvenci lze změnit v nastavení.</string>
-    <string name="onboarding_backup_enable_button">Vyberte složku a proveďte zálohu</string>
-    <string name="onboarding_backup_skip_button">Teď ne</string>
-    <string name="onboarding_view_title">Co by se mělo otevřít nejdříve?</string>
-    <string name="onboarding_month_style_title">Jak by mělo vypadat měsíční rozvržení?</string>
-    <string name="onboarding_view_continue_button">Pokračovat</string>
-    <string name="onboarding_back">Zpět</string>
-    <string name="onboarding_visibility_button">Jasně</string>
-    <string name="onboarding_done_title">Vše je připraveno</string>
-    <string name="onboarding_done_body">Vaše kalendáře jsou připraveny. Veškeré volby lze později změnit v nastavení.</string>
-    <string name="onboarding_done_button">Otevřít můj kalendář</string>
-    <string name="reminder_channel_name">Upomínky událostí</string>
-    <string name="reminder_channel_description">Oznámení v časech upomínek vašich událostí</string>
-    <string name="reminder_onboarding_title">Ať vám neunikne žádná událost</string>
-    <string name="reminder_onboarding_body">Android sám o sobě nezobrazuje upomínky událostí — to musí zajistit aplikace kalendáře. Nechte tuto práci na Calendule.</string>
-    <string name="reminder_benefit_delivery_title">Upomínky, doručené</string>
-    <string name="reminder_benefit_delivery_body">Upomínky k vašim událostem vám přijdou v danou dobu jako oznámení.</string>
-    <string name="reminder_benefit_duplicates_title">Používáte ještě nějakou jinou aplikaci s kalendářem?</string>
-    <string name="reminder_benefit_duplicates_body">Pokud i jiná aplikace odesílá upomínky, uvidíte je dvakrát — v jedné z aplikací je musíte vypnout.</string>
-    <string name="reminder_benefit_reversible_title">Lze kdykoliv změnit</string>
-    <string name="reminder_benefit_reversible_body">Tento přepínač naleznete v Nastavení, v části Oznámení.</string>
-    <string name="reminder_onboarding_enable_button">Zapnout upomínky</string>
-    <string name="reminder_onboarding_skip_button">Později</string>
-    <string name="reminder_action_snooze">Odložit</string>
-    <string name="reminder_action_dismiss">Zrušit</string>
-    <string name="reminder_day_tomorrow">Zítra</string>
-    <string name="reminder_day_yesterday">Včera</string>
-    <string name="view_month">Měsíc</string>
-    <string name="view_week">Týden</string>
-    <string name="view_day">Den</string>
-    <string name="view_agenda">Program</string>
-    <string name="view_section">Zobrazení</string>
-    <string name="drawer_jump_to_date">Přejít na datum</string>
-    <string name="agenda_today_action">Dnes</string>
-    <string name="agenda_header_today">Dnes</string>
-    <string name="agenda_header_tomorrow">Zítra</string>
-    <string name="agenda_empty_title">Teď už jsi v obraze</string>
-    <string name="agenda_no_more_today">Dnes bez dalších událostí</string>
-    <string name="agenda_span_starts">Začátek %1$s</string>
-    <string name="agenda_span_ends">Konec %1$s</string>
-    <string name="today_jump_action">Přejít na dnešek</string>
-    <string name="search_action">Hledat</string>
-    <string name="search_hint">Vyhledat události</string>
-    <string name="search_back">Zpět</string>
-    <string name="search_clear">Vymazat</string>
-    <string name="search_idle_hint">Prohledávejte své události podle názvu, místa konání nebo poznámek.</string>
-    <string name="search_empty">Žádná událost neodpovídá “%1$s”.</string>
-    <plurals name="search_selected_count">
-        <item quantity="one">%d označený</item>
-        <item quantity="few">%d označené</item>
-        <item quantity="many">%d označených</item>
-        <item quantity="other">%d označených</item>
-    </plurals>
-    <string name="search_in_descriptions">Nalezeno v popisech</string>
-    <string name="search_selection_close">Zrušit výběr</string>
-    <string name="search_select_all">Vybrat vše</string>
-    <string name="search_delete_selected">Odstranit vybrané</string>
-    <plurals name="search_delete_title">
-        <item quantity="one">Odstranit %d událost?</item>
-        <item quantity="few">Odstranit %d události?</item>
-        <item quantity="many">Odstranit %d událostí?</item>
-        <item quantity="other">Odstranit %d událostí?</item>
-    </plurals>
-    <plurals name="search_delete_done">
-        <item quantity="one">%d událost odstraněna</item>
-        <item quantity="few">%d události odstraněny</item>
-        <item quantity="many">%d událostí odstraněno</item>
-        <item quantity="other">%d událostí odstraněno</item>
-    </plurals>
-    <string name="search_delete_partial">%1$d odstraněno, u %2$d se nepodařilo</string>
-    <string name="search_delete_denied_partial">%1$d odstraněno, poté byl odepřen přístup pro zápis</string>
-    <string name="settings_special_dates_disable_all_message">Tímto se smažou kalendáře spojené s určitým kontaktem a všechny události v nich obsažené. Veškerá upomínky a poznámky, které jste do nich přidali, budou ztraceny.</string>
-    <string name="widget_agenda_title">Nadcházející</string>
-    <string name="widget_agenda_label">Události Calendula</string>
-    <string name="widget_month_label">Měsíc Calendula</string>
-    <string name="widget_refresh">Obnovit</string>
-    <string name="widget_new_event">Nová událost</string>
-    <string name="widget_needs_permission">Otevřete Calendulu a povolte přístup ke kalendáři</string>
-    <string name="widget_prev_month">Předchozí měsíc</string>
-    <string name="widget_next_month">Následující měsíc</string>
-    <string name="widget_today">Dnes</string>
-    <string name="filter_title">Kalendáře</string>
 </resources>
--- a/app/src/main/res/values-pl/strings.xml
+++ b/app/src/main/res/values-pl/strings.xml
@@ -16,14 +16,14 @@
    <string name="state_failure_no_calendars_action">Otwórz systemowe ustawienia kalendarza</string>
    <string name="state_failure_provider">Nie udało się kalendarza.</string>
    <string name="permission_rationale_title">Zobacz wszystkie swoje wydarzenia w pięknej oprawie</string>
-    <string name="permission_rationale_body">Calendula potrzebuje dostępu do Twojego kalendarza, aby wyświetlać wydarzenia i nimi zarządzać.</string>
+    <string name="permission_rationale_body">Calendula potrzebuje dostępu do Twojego kalendarza, aby wyświetlać wydarzenia i nimi zarządzać. To jedyne, o co prosi na wstępie — i żadne dane nigdy nie opuszczają Twojego urządzenia.</string>
    <string name="permission_request_button">Przyznaj dostęp do kalendarza</string>
    <string name="permission_denied_title">Brak dostępu do kalendarza</string>
    <string name="permission_denied_body">Calendula nie może wyświetlać wydarzeń bez dostępu do kalendarza. Możesz go ponownie przyznać w ustawieniach systemowych.</string>
    <string name="permission_open_settings_button">Otwórz ustawienia systemowe</string>
    <string name="permission_retry_button">Spróbuj ponownie</string>
-    <string name="permission_benefit_private_title">Prywatność z założenia</string>
-    <string name="permission_benefit_private_body">Brak uprawnień do internetu, brak telemetrii — nic nigdy nie opuszcza Twojego telefonu.</string>
+    <string name="permission_benefit_private_title">Pozostaje na Twoim urządzeniu</string>
+    <string name="permission_benefit_private_body">Twoje kalendarze są odczytywane lokalnie i nigdy nie opuszczają telefonu.</string>
    <string name="permission_benefit_sync_title">Wszystkie Twoje kalendarze w jednym miejscu</string>
    <string name="permission_benefit_sync_body">Google, CalDAV, lokalne — wszystko, co jest zsynchronizowane z urządzeniem, po prostu się pojawia.</string>
    <string name="permission_benefit_privacy_title">Nigdy żadnego śledzenia</string>
@@ -333,7 +333,7 @@
    <string name="settings_default_reminder">Domyślne przypomnienie</string>
    <string name="settings_default_reminder_allday">Wydarzenia całodniowe</string>
    <string name="settings_allday_reminder_time">Godzina przypomnienia o wydarzeniach całodniowych</string>
-    <string name="settings_allday_reminder_time_hint">Przypomnienia o wydarzeniach całodniowych pojawiają się o %1$s</string>
+    <string name="settings_allday_reminder_time_hint">Przypomnienia o wydarzeniach całodniowych zostaną pojawiają się o %1$s</string>
    <string name="reminder_none">Brak</string>
    <string name="reminder_use_default">Użyj domyślnego przypomnienia</string>
    <string name="reminder_custom_amount">jednostek</string>
@@ -353,10 +353,10 @@
    <string name="settings_language_auto">Domyślny systemu</string>
    <string name="settings_translate">Pomóż w tłumaczeniu</string>
    <string name="settings_translate_hint">Dodaj lub ulepsz tłumaczenie w Weblate</string>
-    <string name="settings_appearance_subtitle">Motyw, kolory, czcionki</string>
-    <string name="settings_views_subtitle">Domyślny widok, układ, kolejność</string>
-    <string name="settings_event_form_subtitle">Domyślne pola i zachowanie</string>
-    <string name="settings_notifications_subtitle">Przypomnienia i dostarczanie</string>
+    <string name="settings_appearance_subtitle">Motyw, domyślny widok, pierwszy dzień tygodnia</string>
+    <string name="settings_views_subtitle">Układ widoku miesiąca, przycisk szybkiego przełączania, kolejność menu</string>
+    <string name="settings_event_form_subtitle">Domyślne pola dla nowych wydarzeń</string>
+    <string name="settings_notifications_subtitle">Przypomnienia o wydarzeniach</string>
    <string name="settings_special_dates_subtitle">Urodziny i rocznice kontaktów</string>
    <string name="settings_section_special_dates">Szczególne daty kontaktów</string>
    <string name="settings_special_dates_enable">Pokaż daty kontaktów</string>
@@ -509,8 +509,8 @@
    <string name="reminder_day_tomorrow">Jutro</string>
    <string name="reminder_day_yesterday">Wczoraj</string>
    <string name="agenda_no_more_today">Brak zaplanowanych wydarzeń</string>
-    <string name="settings_soften_colors">Harmonizuj kolory kalendarza</string>
-    <string name="settings_soften_colors_summary">Zachowaj odcień każdego kalendarza, ale wyrównaj jego jasność, tak aby każde wydarzenie pozostało czytelne, a kolory współgrały ze sobą. Wyłącz tę opcję, aby wyświetlać oryginalne kolory ze źródła kalendarza.</string>
+    <string name="settings_soften_colors">Zredukuj intensywność kolorów kalendarza</string>
+    <string name="settings_soften_colors_summary">Dopasuj intensywność kolorów kalendarza i wydarzeń do motywu. Wyłącz tę opcję, aby wyświetlać oryginalne kolory ze źródła kalendarza.</string>
    <string name="settings_agenda_show_today">Zawsze pokazuj dzisiejszy dzień</string>
    <string name="settings_agenda_show_today_hint">Zachowaj dzisiejszy dzień na górze agendy i widżetu, nawet gdy nie ma już na dziś żadnych zadań.</string>
    <string name="special_dates_calendar_birthday">Urodziny</string>
@@ -543,128 +543,4 @@
    <string name="month_split_no_events">Brak planów</string>
    <string name="month_split_expand">Pokaż cały miesiąc</string>
    <string name="month_split_collapse">Pokaż wydarzenia dnia</string>
-    <string name="event_move_gone">To wydarzenie już nie istnieje</string>
-    <string name="event_move_action">Przenieś…</string>
-    <string name="event_move_recurring_title">Przenieś wydarzenie cykliczne</string>
-    <string name="event_move_occurrence_only">Przeniesienie całej serii zmieniłoby dni, w których wypadają wydarzenia, więc można przenieść tylko to wystąpienie.</string>
-    <string name="event_move_done">Przeniesiono na %1$s</string>
-    <string name="event_move_undo">Cofnij</string>
-    <string name="event_move_undone">Cofnięto przeniesienie</string>
-    <string name="event_move_failed">Nie udało się przenieść wydarzenia</string>
-    <string name="event_move_write_denied">Calendula wymaga uprawnień do zapisu, aby móc przenosić wydarzenia</string>
-    <string name="event_move_blocked_series_end">Nie można przenieść wydarzenia poza datę zakończenia jego serii</string>
-    <string name="event_edit_recurrence_next">Następne: %1$s</string>
-    <string name="event_edit_recurrence_next_none">Ta reguła nie ma powtórzeń</string>
-    <string name="event_access_default_summary">Standardowe ustawienie tego kalendarza</string>
-    <string name="event_access_public_summary">Każdy, kto ma dostęp, widzi pełne szczegóły</string>
-    <string name="event_access_private_summary">Inni widzą tylko to, że jesteś zajęty</string>
-    <string name="event_access_confidential_summary">Oznaczone jako poufne; co to oznacza, zależy od konta kalendarza</string>
-    <string name="duration_hours_minutes">%1$s %2$s</string>
-    <string name="duration_custom_max">Maksymalnie %1$s</string>
-    <string name="onboarding_step_counter">Krok %1$d z %2$d</string>
-    <string name="onboarding_backup_title">Twoje wydarzenia istnieją tylko tutaj</string>
-    <string name="onboarding_backup_body">Nic z tego telefonu nie synchronizuje się z kontem, więc jego utrata oznaczałaby utratę kalendarza. Calendula może utworzyć dla Ciebie kopię zapasową.</string>
-    <string name="onboarding_backup_benefit_folder_title">Wybrany przez Ciebie folder</string>
-    <string name="onboarding_backup_benefit_folder_body">Kopie zapasowe to zwykłe pliki .ics — umieść je w miejscu, które się synchronizuje, albo na karcie SD.</string>
-    <string name="onboarding_backup_benefit_daily_title">Raz dziennie, automatycznie</string>
-    <string name="onboarding_backup_benefit_daily_body">Calendula eksportuje Twoje lokalne kalendarze w tle. Możesz zmienić częstotliwość w Ustawieniach.</string>
-    <string name="onboarding_backup_enable_button">Wybierz folder i utwórz kopię zapasową</string>
-    <string name="onboarding_view_title">Co powinno się otworzyć jako pierwsze?</string>
-    <string name="onboarding_month_style_title">Jak powinien wyglądać miesiąc?</string>
-    <string name="onboarding_view_continue_button">Kontynuuj</string>
-    <string name="onboarding_back">Wstecz</string>
-    <string name="onboarding_visibility_button">Rozumiem</string>
-    <string name="onboarding_done_title">Wszystko gotowe</string>
-    <string name="onboarding_done_body">Twoje kalendarze są gotowe. Wszystko co właśnie wybrałeś możesz później zmienić w Ustawieniach.</string>
-    <string name="onboarding_done_button">Otwórz mój kalendarz</string>
-    <plurals name="search_selected_count">
-        <item quantity="one">%d wybrane</item>
-        <item quantity="few">%d wybrane</item>
-        <item quantity="many">%d wybranych</item>
-        <item quantity="other">%d wybranych</item>
-    </plurals>
-    <string name="search_in_descriptions">Znaleziono w opisach</string>
-    <string name="search_selection_close">Anuluj wybór</string>
-    <string name="search_select_all">Wybierz wszystkie</string>
-    <string name="search_delete_selected">Usuń wybrane</string>
-    <plurals name="search_delete_title">
-        <item quantity="one">Usunąć %d wydarzenie?</item>
-        <item quantity="few">Usunąć %d wydarzenia?</item>
-        <item quantity="many">Usunąć %d wydarzeń?</item>
-        <item quantity="other">Usunąć %d wydarzeń?</item>
-    </plurals>
-    <plurals name="search_delete_done">
-        <item quantity="one">Usunięto %d wydarzenie</item>
-        <item quantity="few">Usunięto %d wydarzenia</item>
-        <item quantity="many">Usunięto %d wydarzeń</item>
-        <item quantity="other">Usunięto %d wydarzeń</item>
-    </plurals>
-    <string name="search_delete_partial">%1$d usunięto, %2$d nie udało się</string>
-    <string name="search_delete_denied_partial">%1$d usunięto, następnie utracono uprawnienia do zapisu</string>
-    <string name="settings_theme_hint">Czy aplikacja ma być jasna, czy ciemna. Wybór zostanie zastosowany natychmiast.</string>
-    <string name="settings_theme_system_summary">Obecnie %1$s</string>
-    <string name="settings_font_specimen_heading">czwartek, 14 maja</string>
-    <string name="settings_font_specimen_body">Przegląd zespołu o 10:00, a potem lunch z Robinem w kawiarni na rynku.</string>
-    <string name="settings_week_start_auto_summary">Obecnie %1$s</string>
-    <string name="settings_time_format_auto_summary">Zgodnie z systemem: %1$s</string>
-    <string name="settings_timeline_scale">Wysokość godzin</string>
-    <string name="settings_timeline_scale_hint">Ile miejsca w pionie zajmuje jedna godzina w widoku tygodnia i dnia. Oba widoki korzystają z tego ustawienia. Możesz również rozciągnąć lub ścisnąć oś czasu dwoma palcami, aby ustawić dowolną wysokość pomiędzy.</string>
-    <string name="timeline_scale_fit_day">Cały dzień na ekranie</string>
-    <string name="timeline_scale_fit_day_summary">Cała doba na jednym ekranie, bez przewijania</string>
-    <string name="timeline_scale_compact">Kompaktowa</string>
-    <string name="timeline_scale_compact_summary">Więcej godzin na ekranie, mniejsze bloki</string>
-    <string name="timeline_scale_regular">Standardowa</string>
-    <string name="timeline_scale_regular_summary">Standardowy rozmiar</string>
-    <string name="timeline_scale_comfortable">Wygodna</string>
-    <string name="timeline_scale_comfortable_summary">Większe bloki, więcej przewijania</string>
-    <string name="timeline_scale_custom">Własna</string>
-    <string name="timeline_scale_custom_summary">Wysokość, którą wybrałeś gestem „uszczypnięcia” osi czasu</string>
-    <string name="settings_drag_to_reschedule">Przeciągnij, aby zmienić termin</string>
-    <string name="settings_drag_to_reschedule_summary">Przenieś wydarzenie, przeciągając je na inny dzień lub godzinę</string>
-    <string name="settings_past_events_sample_morning">Przegląd zespołu</string>
-    <string name="settings_past_events_sample_midday">Lunch z Robin</string>
-    <string name="settings_past_events_sample_evening">Próba chóru</string>
-    <string name="settings_widget_size">Rozmiar widżetu agendy</string>
-    <string name="settings_widget_size_hint">Rozmiar tekstu wyświetlanego przez widżet agendy na ekranie domowym. Widżet miesiąca nie posiada tego ustawienia — jego siatka zawsze dopasowuje się do przydzielonego miejsca.</string>
-    <string name="settings_widget_size_small">Mały</string>
-    <string name="settings_widget_size_medium">Średni</string>
-    <string name="settings_widget_size_large">Duży</string>
-    <string name="settings_widget_size_extra_large">Bardzo duży</string>
-    <string name="settings_widget_size_summary">Tekst wydarzenia %1$d%%</string>
-    <string name="settings_event_duration">Domyślny czas trwania</string>
-    <string name="settings_event_duration_hint">Czas trwania nowego wydarzenia do momentu zmiany godziny jego zakończenia. Nie dotyczy to wydarzeń całodniowych.</string>
-    <string name="settings_calendar_durations_title">Czas trwania dla poszczególnych kalendarzy</string>
-    <string name="settings_calendar_durations_hint">Przypisz kalendarzowi własną domyślną długość — np. 8 godzin dla zmian w pracy.</string>
-    <string name="settings_calendar_duration_inherits">Domyślny (%1$s)</string>
-    <string name="settings_calendar_duration_use_default">Używaj domyślnego czasu trwania (%1$s)</string>
-    <string name="settings_allday_reminder_fires_at">Powiadamia o %1$s</string>
-    <string name="settings_group_look">Wygląd i zachowanie</string>
-    <string name="settings_group_data">Dane</string>
-    <string name="settings_group_app">Aplikacja</string>
-    <string name="settings_group_about">O aplikacji</string>
-    <string name="settings_widgets_subtitle">Widżet agendy, kafelek Szybkich ustawień</string>
-    <string name="settings_backup_subtitle">Eksport, import, automatyczna kopia zapasowa</string>
-    <string name="settings_section_widgets">Widżety i kafelki</string>
-    <string name="settings_widgets_hint">Ustawienia widżetów ekranu głównego i kafelka Szybkich ustawień. Aby dodać widżet, naciśnij i przytrzymaj na ekranie domowym.</string>
-    <string name="settings_section_backup">Kopia zapasowa i przywracanie</string>
-    <string name="settings_views_all_header">Wszystkie widoki</string>
-    <string name="settings_week_day_header">Tydzień i dzień</string>
-    <string name="settings_default_view_hint">Widok, który pojawia się po uruchomieniu aplikacji Calendula.</string>
-    <string name="settings_week_start_hint">Dzień, od którego zaczyna się każdy tydzień we wszystkich widokach i widżetach.</string>
-    <string name="settings_time_format_hint">Format godziny w aplikacji. Opcja automatyczna dostosowuje się do ustawień systemowych.</string>
-    <string name="settings_past_events_hint">Co agenda robi z wydarzeniami, które już się zakończyły.</string>
-    <string name="settings_dynamic_color_summary">Dopasuj kolory aplikacji do swojej tapety.</string>
-    <string name="settings_about_privacy">Polityka prywatności</string>
-    <string name="calendars_visibility_hint">Wyłącz kalendarz, aby ukryć go na tym urządzeniu — jego wydarzenia znikną z aplikacji i przestaniesz otrzymywać powiadomienia. To ten sam przełącznik, którego używają inne aplikacje kalendarza, więc one również go ukryją. Nic nie zostanie usunięte, nie wpłynie to na inne urządzenia, a kalendarz możesz tu włączyć ponownie w dowolnym momencie.</string>
-    <string name="calendars_visibility_a11y">Pokaż \"%1$s\"</string>
-    <string name="calendars_visibility_notice_title">Niektóre kalendarze są wyłączone</string>
-    <string name="calendars_visibility_notice_message">Calendula wyświetla kalendarze włączone na tym urządzeniu, a niektóre z Twoich są wyłączone. Aby zobaczyć ich wydarzenia, włącz je w sekcji Ustawienia → Kalendarze.</string>
-    <string name="calendar_picker_missing_title">Brakuje jakiegoś kalendarza?</string>
-    <string name="calendar_picker_missing_summary">Może być wyłączony, tylko do odczytu lub wypełniony na podstawie Twoich kontaktów — zarządzaj swoimi kalendarzami tutaj.</string>
-    <string name="calendars_state_read_only">Tylko do odczytu</string>
-    <string name="calendars_state_not_synced">Niezsynchronizowany z tym urządzeniem</string>
-    <string name="calendars_state_managed">Wypełniony na podstawie Twoich kontaktów</string>
-    <string name="calendars_managed_delete_locked">Ten kalendarz jest uzupełniany na podstawie Twoich kontaktów, więc Calendula utworzy go ponownie przy następnej synchronizacji. Aby go usunąć, wyłącz daty szczególne w menu Ustawienia → Szczególne daty kontaktów.</string>
-    <string name="calendars_account_from_source">%1$s (%2$s)</string>
-    <string name="onboarding_backup_skip_button">Nie teraz</string>
 </resources>
--- a/app/src/main/res/values-ru/strings.xml
+++ b/app/src/main/res/values-ru/strings.xml
@@ -133,47 +133,4 @@
    <string name="import_reminder_prompt_apply">Применить стандартное</string>
    <string name="import_reminder_prompt_keep">Оставить как есть</string>
    <string name="event_edit_recurrence_none">Не повторяется</string>
-    <string name="event_edit_recurrence_custom">Свой</string>
-    <string name="event_edit_recurrence_every">Каждый</string>
-    <string name="recurrence_unit_days">дни</string>
-    <string name="recurrence_unit_weeks">недели</string>
-    <string name="recurrence_unit_months">месяцы</string>
-    <string name="recurrence_unit_years">года</string>
-    <string name="event_edit_recurrence_incomplete">Введите число от 1 до 999</string>
-    <string name="event_edit_recurrence_next_none">Это правило никогда не повторяется</string>
-    <string name="event_edit_recurrence_ends">Заканчивается</string>
-    <string name="event_edit_recurrence_end_never">Никогда</string>
-    <string name="event_edit_recurrence_end_until">До</string>
-    <string name="event_edit_recurrence_end_count">После определённого количества</string>
-    <string name="event_availability_busy">Занят</string>
-    <string name="event_access_default">Стандартный</string>
-    <string name="event_access_public">Публичный</string>
-    <string name="event_detail_all_day">Весь день</string>
-    <string name="event_detail_calendar">Календарь</string>
-    <string name="event_detail_calendar_unknown">Неизвестный календарь</string>
-    <string name="event_detail_location">Местоположение</string>
-    <string name="event_detail_description">Описание</string>
-    <string name="event_detail_recurring">Повторяющееся событие</string>
-    <string name="recurrence_daily">Каждый день</string>
-    <string name="recurrence_weekly">Каждую неделю</string>
-    <string name="recurrence_monthly">Каждый месяц</string>
-    <string name="recurrence_yearly">Каждый год</string>
-    <string name="recurrence_every_n_days">Каждые %1$d дней</string>
-    <string name="recurrence_every_n_weeks">Каждые %1$d недель</string>
-    <string name="recurrence_every_n_months">Каждые %1$d месяцев</string>
-    <string name="recurrence_every_n_years">Каждые %1$d лет</string>
-    <string name="event_detail_not_found">Это событие больше не существует.</string>
-    <string name="event_attendee_accepted">Принято</string>
-    <string name="event_attendee_declined">Отклонено</string>
-    <string name="event_attendee_needs_action">Без ответа</string>
-    <string name="event_detail_reminders">Напоминания</string>
-    <string name="event_detail_timezone">Временная зона</string>
-    <string name="event_status_cancelled">Отменён</string>
-    <string name="event_availability_free">Бесплатно</string>
-    <string name="event_access_private">Приватно</string>
-    <string name="event_access_confidential">Конфиденциально</string>
-    <string name="event_access_public_summary">Любой с доступом может видеть все детали</string>
-    <string name="event_access_private_summary">Другие видят только, что вы заняты</string>
-    <string name="event_detail_self_response">Ваш ответ: %1$s</string>
-    <string name="reminder_at_time">Во время начала события</string>
 </resources>
--- a/app/src/main/res/values-sk/strings.xml
+++ b/app/src/main/res/values-sk/strings.xml
@@ -1,190 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string-array name="backup_interval_units">
-        <item>Minutes</item>
-        <item>Hours</item>
-        <item>Days</item>
-        <item>Weeks</item>
-    </string-array>
-    <string name="app_name">Calendula</string>
-    <string name="app_tagline">Moderný kalendár.</string>
-    <string name="state_loading">Načítava sa…</string>
-    <string name="state_retry">Opakovať</string>
-    <string name="state_failure_unknown">Niečo sa pokazilo.</string>
-    <string name="state_failure_permission">Je potrebný prístup ku kalendáru.</string>
-    <string name="state_failure_permission_action">Udeliť prístup</string>
-    <string name="state_failure_no_calendars">Nie sú nakonfigurované žiadne kalendáre.</string>
-    <string name="state_failure_no_calendars_action">Otvoriť systémové nastavenie kalendára</string>
-    <string name="state_failure_provider">Nepodarilo sa načítať kalendár.</string>
-    <string name="permission_rationale_title">Prehľadávajte všetky svoje udalosti v krásnom prevedení</string>
-    <string name="permission_rationale_body">Calendula potrebuje prístup k vášmu kalendáru, aby mohla zobraziť a spravovať vaše udalosti.</string>
-    <string name="permission_request_button">Udeliť prístup k kalendáru</string>
-    <string name="permission_denied_title">Prístup ku kalendáru bol zamietnutý</string>
-    <string name="permission_denied_body">Calendula nemôže zobraziť udalosti bez prístupu ku kalendáru. Môžete ho znova udeliť v nastavení systému.</string>
-    <string name="permission_open_settings_button">Otvoriť systémové nastavenia</string>
-    <string name="permission_retry_button">Skúsiť znova</string>
-    <string name="permission_benefit_private_title">Súkromné už od začiatku</string>
-    <string name="permission_benefit_private_body">Žiadny prístup k internetu, žiadna telemetria - nikdy nič z vášho telefónu neunikne.</string>
-    <string name="permission_benefit_sync_title">Všetky vaše kalendáre pohromade</string>
-    <string name="permission_benefit_sync_body">Google, CalDAV, lokálne kalendáre - čokoľvek synchronizované zo zariadením sa proste objaví.</string>
-    <string name="permission_benefit_privacy_title">Nikdy žiadne sledovanie</string>
-    <string name="permission_benefit_privacy_body">Žiadna telemetria, žiadne analytické nástroje, bez reklám.</string>
-    <string name="permission_privacy_footnote">Ostáva na vašom zariadení · bez prístupu k internetu</string>
-    <string name="month_prev">Predchádzajúci mesiac</string>
-    <string name="month_next">Nasledujúci mesiac</string>
-    <string name="month_today_action">Dnes</string>
-    <string name="month_more_actions">Ďalšie možnosti</string>
-    <string name="month_open_menu">Otvoriť menu</string>
-    <string name="month_action_settings">Nastavenia</string>
-    <string name="month_a11y_today_prefix">Dnes</string>
-    <string name="week_today_action">Tento víkend</string>
-    <string name="week_number_label">týžd.</string>
-    <string name="day_today_action">Dnes</string>
-    <string name="event_detail_back">Späť</string>
-    <string name="event_detail_edit">Upraviť</string>
-    <string name="event_detail_delete">Vymazať</string>
-    <string name="event_detail_share">Zdielať</string>
-    <string name="event_detail_duplicate">Duplikovať</string>
-    <string name="event_share_chooser_title">Zdielať udalosť</string>
-    <string name="event_share_failed">Túto udalosť nieje možné zdieľať.</string>
-    <string name="event_delete_title">Odstrániť udalosť?</string>
-    <string name="event_delete_body">Udalosť je odstránená z vášho kalendára aj zo všetkých synchronizovaných zariadení.</string>
-    <string name="event_delete_recurring_title">Odstrániť opakujúcu sa udalosť</string>
-    <string name="event_delete_option_occurrence">Iba túto udalosť</string>
-    <string name="event_delete_option_following">Túto aj všetky nasledujúce udalosti</string>
-    <string name="event_delete_option_series">Všetky udalosti v sérii</string>
-    <string name="event_edit_recurring_title">Upraviť opakujúcu sa udalosť</string>
-    <string name="event_delete_failed">Túto udalosť nebolo možné odstrániť</string>
-    <string name="event_delete_write_denied">Calendula potrebuje povolenie k zápisu, aby mohla odstrániť udalosti</string>
-    <string name="event_move_action">Presunúť…</string>
-    <string name="event_move_recurring_title">Presunúť opakujúcu sa udalosť</string>
-    <string name="event_move_occurrence_only">Presunútie celej série by sa zmenilo poradie dňou, na ktorú séria pripadá, takže presunúť je možné iba túto udalosť.</string>
-    <string name="event_move_done">Presunuté na %1$s</string>
-    <string name="event_move_undo">Vrátiť späť</string>
-    <string name="event_move_undone">Navrátené naspäť</string>
-    <string name="event_move_failed">Nemožno presunúť udalosť</string>
-    <string name="event_move_write_denied">Calendula potrebuje povolenie k zápisu, aby mohla presúvať udalosti</string>
-    <string name="event_move_gone">Táto udalosť už neexistuje</string>
-    <string name="event_move_blocked_series_end">Nie je možné presunúť udalosť za koniec danej série</string>
-    <string name="dialog_cancel">Zrušiť</string>
-    <string name="dialog_ok">OK</string>
-    <string name="event_edit_new_title">Nová udalosť</string>
-    <string name="event_edit_close">Zavrieť</string>
-    <string name="event_edit_save">Uložiť</string>
-    <string name="event_edit_title_hint">Pridať názov</string>
-    <string name="event_edit_managed_hint">Spravové kalendárom “%1$s” — názov, dátum a opakovanie je synchronizované z vašich kontaktov. Pripomienky, poloha a poznámky môžte upraviť.</string>
-    <string name="event_edit_starts">Začiatok</string>
-    <string name="event_edit_ends">Koniec</string>
-    <string name="event_edit_error_end_before_start">Končí pred začiatkom</string>
-    <string name="event_edit_error_no_calendar">Není dostupný kalendár, ktorý je možno upravovať</string>
-    <string name="event_edit_save_failed">Nemožno udalosť uložiť</string>
-    <string name="event_edit_write_denied">Calendula potrebuje povolenie k zápisu, aby mohla vytvárať udalosti</string>
-    <string name="event_edit_more_fields">Viac poli</string>
-    <string name="event_edit_add">Pridať</string>
-    <string name="event_edit_add_reminder">Pridať pripomienku</string>
-    <string name="event_edit_remove_reminder">Odstrániť pripomienku</string>
-    <string name="event_edit_attendees">Hostia</string>
-    <string name="event_edit_add_guest">Pridať hosťa</string>
-    <string name="event_edit_add_guest_hint">Pridať hosťa e-mailom…</string>
-    <string name="event_edit_add_guest_from_contacts">Pridať z kontaktov</string>
-    <string name="event_edit_location_from_contacts">Vybrať adresu z kontaktov</string>
-    <string name="event_edit_remove_guest">Odstrániť hosťa</string>
-    <string name="event_edit_attendee_required">Nutné</string>
-    <string name="event_edit_attendee_optional">Voliteľné</string>
-    <string name="event_edit_attendees_note_synced">Calendula neposiela pozvánky. Váš kalendárny účet ich môže poslať keď sa synchronizuje.</string>
-    <string name="event_edit_attendees_note_local">Uložené na tomto zariadení. Nikomu nebude poslaná notifikácia.</string>
-    <string name="event_edit_reminder_custom">Vlastné</string>
-    <string name="reminder_unit_minutes">minúty</string>
-    <string name="reminder_unit_hours">hodiny</string>
-    <string name="reminder_unit_days">dni</string>
-    <string name="reminder_unit_weeks">týždne</string>
-    <string name="event_edit_availability">Dostupnosť</string>
-    <string name="event_edit_visibility">Viditeľnosť</string>
-    <string name="event_edit_timezone_device">Časové pásmo zariadenia</string>
-    <string name="event_edit_timezone_device_summary">Sleduje vás, nech ste kdekoľvek</string>
-    <string name="event_edit_timezone_search">Vyhľadať časové pásmo</string>
-    <string name="event_edit_timezone_recent">Nedávne</string>
-    <string name="event_edit_timezone_all">Všetky časové pásma</string>
-    <string name="event_edit_timezone_none">Žiadne časové pásmo nezodpovedá “%1$s”</string>
-    <string name="event_edit_timezone_local_time">%1$s vášho času</string>
-    <string name="event_edit_color">Farba</string>
-    <string name="event_edit_color_default">Farba kalendáru</string>
-    <string name="event_edit_color_custom">Vlastná farba</string>
-    <string name="event_edit_color_reset">Obnoviť</string>
-    <string name="event_edit_color_unsupported">Není k dispozícii pre tento kalendár</string>
-    <string name="event_edit_color_unsupported_hint">Tento kalendár nemá vlastnú sadu farieb. Pre takýto kalendár môžte povoliť vlastné farby v nastaveniach.</string>
-    <string name="event_edit_color_sync_warning">Tento kalendár môže vymazať alebo prepísať farbu pri ďalšej synchronizácii.</string>
-    <string name="event_edit_conflict_title">Udalosť bola zmenená niekde inde</string>
-    <string name="event_edit_conflict_body">Počas úprav sa táto udalosť zmenila — synchronizáciou alebo inou aplikáciou. Čo sa má stať s vašimi zmenami?</string>
-    <string name="event_edit_conflict_overwrite">Uložiť zmeny</string>
-    <string name="event_edit_conflict_overwrite_hint">Iba u upravených polí sa prepíše zmena z iného zdroja</string>
-    <string name="event_edit_conflict_discard">Zrušiť zmeny</string>
-    <string name="event_edit_conflict_discard_hint">Udalosť ostáva bez zmeny</string>
-    <string name="event_edit_gone_title">Udalosť odstránená</string>
-    <string name="event_edit_gone_body">Počas úprav bola táto udalosť odstránená, napríklad na inom zariadení. Vaše zmeny už nie je možné uložiť.</string>
-    <string name="import_reminder_prompt_title">Chcete použiť predvolenú pripomienku?</string>
-    <string name="import_reminder_prompt_body_none">Táto udalosť bola importovaná bez pripomienky.</string>
-    <plurals name="import_reminder_prompt_body_existing">
-        <item quantity="one">Táto udalosť bola importovaná s %1$d pripomienkou.</item>
-        <item quantity="few">Táto udalosť bola importovaná s %1$d pripomienkami.</item>
-        <item quantity="many">Táto udalosť bola importovaná s %1$d pripomienkami.</item>
-        <item quantity="other">Táto udalosť bola importovaná s %1$d pripomienkami.</item>
-    </plurals>
-    <string name="import_reminder_prompt_apply">Nastaviť predvolené</string>
-    <string name="import_reminder_prompt_keep">Nechať bez zmeny</string>
-    <string name="event_edit_recurrence_none">Neopakuje sa</string>
-    <string name="event_edit_recurrence_custom">Vlastné</string>
-    <string name="event_edit_recurrence_every">Každý</string>
-    <string name="recurrence_unit_days">dni</string>
-    <string name="recurrence_unit_weeks">týždne</string>
-    <string name="recurrence_unit_months">mesiace</string>
-    <string name="recurrence_unit_years">roky</string>
-    <string name="event_edit_recurrence_incomplete">Zadajte číslo od 1 do 999</string>
-    <string name="event_edit_recurrence_next">Nasledujúce: %1$s</string>
-    <string name="event_edit_recurrence_next_none">Toto pravidlo sa nikdy neopakuje</string>
-    <string name="event_edit_recurrence_ends">Koniec</string>
-    <string name="event_edit_recurrence_end_never">Nikdy</string>
-    <string name="event_edit_recurrence_end_until">K určitému dátumu</string>
-    <string name="event_edit_recurrence_end_count">Po určitom počtu opakovaní</string>
-    <string name="event_edit_recurrence_times">opakovaní</string>
-    <string name="event_edit_error_recurrence_ends_before_start">Opakovanie končí pred začiatkom udalosti</string>
-    <string name="event_availability_busy">Zaneprázdnený</string>
-    <string name="event_access_default">Predvolený</string>
-    <string name="event_access_public">Verejný</string>
-    <string name="event_detail_all_day">Celý deň</string>
-    <string name="event_detail_calendar">Kalendár</string>
-    <string name="event_detail_calendar_unknown">Neznámy kalendár</string>
-    <string name="event_detail_location">Poloha</string>
-    <string name="event_detail_description">Popis</string>
-    <string name="event_detail_attendees">Účastníci</string>
-    <string name="event_detail_recurrence">Opakovanie</string>
-    <string name="event_detail_recurring">Opakovaná udalosť</string>
-    <string name="recurrence_daily">Každý deň</string>
-    <string name="recurrence_weekly">Každý týždeň</string>
-    <string name="recurrence_monthly">Každý mesiac</string>
-    <string name="recurrence_yearly">Každý rok</string>
-    <string name="recurrence_every_n_days">Každý %1$d. deň</string>
-    <string name="recurrence_every_n_weeks">Každý %1$d. týždeň</string>
-    <string name="recurrence_every_n_months">Každý %1$d. mesiac</string>
-    <string name="recurrence_every_n_years">Každý %1$d. rok</string>
-    <string name="recurrence_on_days">%1$s v %2$s</string>
-    <string name="recurrence_with_until">%1$s do%2$s</string>
-    <string name="recurrence_with_count">%1$s, %2$d opakovaní</string>
-    <string name="event_detail_not_found">Táto udalosť už neexistuje.</string>
-    <string name="event_attendee_accepted">Akceptované</string>
-    <string name="event_attendee_declined">Zamietnuté</string>
-    <string name="event_attendee_tentative">Predbežne</string>
-    <string name="event_attendee_needs_action">Bez odozvy</string>
-    <string name="event_attendee_unknown">—</string>
-    <string name="event_detail_reminders">Pripomienky</string>
-    <string name="event_detail_timezone">Časové pásmo</string>
-    <string name="event_status_tentative">Predbežne</string>
-    <string name="event_status_cancelled">Zrušené</string>
-    <string name="event_availability_free">Voľno</string>
-    <string name="event_access_private">Súkromné</string>
-    <string name="event_access_confidential">Tajné</string>
-    <string name="event_access_default_summary">Bežná činnosť kalendáru</string>
-    <string name="event_access_public_summary">Kdekoľvek s prístupom vidí všetky detaily</string>
-    <string name="event_access_private_summary">Ostatný vidia iba že ste zaneprázdnený</string>
-    <string name="event_access_confidential_summary">Označené ako utajené; záleží na kalendárnom účtu čo toto znamená</string>
-</resources>
--- a/app/src/main/res/values-zh-rCN/strings.xml
+++ b/app/src/main/res/values-zh-rCN/strings.xml
@@ -6,33 +6,34 @@
        <item>Days</item>
        <item>Weeks</item>
    </string-array>
-    <string name="app_tagline">现代化的日历应用</string>
+    <string name="app_name">Calendula</string>
+    <string name="app_tagline">一个现代化的日历应用</string>
    <string name="state_loading">加载中…</string>
-    <string name="state_retry">重试</string>
-    <string name="state_failure_unknown">出错了。</string>
-    <string name="state_failure_permission">需要日历访问权限。</string>
+    <string name="state_retry">推迟</string>
+    <string name="state_failure_unknown">错误!</string>
+    <string name="state_failure_permission">需要日历权限</string>
    <string name="state_failure_permission_action">授予访问权限</string>
-    <string name="state_failure_no_calendars">未配置任何日历。</string>
+    <string name="state_failure_no_calendars">无已设置的日历</string>
    <string name="state_failure_no_calendars_action">打开系统日历设置</string>
-    <string name="state_failure_provider">无法读取日历。</string>
-    <string name="permission_rationale_title">优雅地查看您所有的事件</string>
-    <string name="permission_rationale_body">Calendula 需要访问您的日历，以展示和管理您的事件。</string>
-    <string name="permission_request_button">授予日历访问权限</string>
-    <string name="permission_denied_title">日历访问被拒绝</string>
-    <string name="permission_denied_body">Calendula 无法在没有日历访问权限的情况下显示事件。您可以在系统设置中重新授予权限。</string>
+    <string name="state_failure_provider">无法读取日历</string>
+    <string name="permission_rationale_title">优雅地查看你的所有活动</string>
+    <string name="permission_rationale_body">Calendula需要获取权限来访问您的日历来展示和管理您的活动。所有权限均会在使用前申请——不必担心隐私泄露。</string>
+    <string name="permission_request_button">授予日历权限</string>
+    <string name="permission_denied_title">日历权限不可用</string>
+    <string name="permission_denied_body">Calendula 无法显示没有日历访问权限的事件。你可以在系统设置里再次授予它。</string>
    <string name="permission_open_settings_button">打开系统设置</string>
    <string name="permission_retry_button">重试</string>
-    <string name="permission_benefit_private_title">从设计上保护隐私</string>
-    <string name="permission_benefit_private_body">没有网络权限，没有遥测——任何数据都不会离开您的手机。</string>
-    <string name="permission_benefit_sync_title">所有日历汇聚一处</string>
-    <string name="permission_benefit_sync_body">Google、CalDAV、本地日历——只要同步到设备就会自动显示。</string>
-    <string name="permission_benefit_privacy_title">永无追踪</string>
-    <string name="permission_benefit_privacy_body">零遥测、零分析、无广告。</string>
-    <string name="permission_privacy_footnote">数据保留在您的设备 · 无网络权限</string>
-    <string name="month_prev">上月</string>
-    <string name="month_next">下月</string>
+    <string name="permission_benefit_private_title">保留在设备</string>
+    <string name="permission_benefit_private_body">您的日历数据将会在本地读取，而不会被上传。</string>
+    <string name="permission_benefit_sync_title">所有日历</string>
+    <string name="permission_benefit_sync_body">Google、CalDAV、本地设备——任何同步到设备的东西都会直接显示出来。</string>
+    <string name="permission_benefit_privacy_title">无追踪器</string>
+    <string name="permission_benefit_privacy_body">零遥测，零分析，没有广告。</string>
+    <string name="permission_privacy_footnote">数据仅保留在本地设备 ·无网络权限</string>
+    <string name="month_prev">上个月</string>
+    <string name="month_next">下个月</string>
    <string name="month_today_action">今天</string>
-    <string name="month_more_actions">更多操作</string>
+    <string name="month_more_actions">更多选项</string>
    <string name="month_open_menu">打开菜单</string>
    <string name="month_action_settings">设置</string>
    <string name="month_a11y_today_prefix">今天</string>
@@ -42,572 +43,80 @@
    <string name="event_detail_edit">编辑</string>
    <string name="event_detail_delete">删除</string>
    <string name="event_detail_share">分享</string>
-    <string name="event_share_chooser_title">分享事件</string>
-    <string name="event_share_failed">无法分享此事件。</string>
-    <string name="event_delete_title">删除事件？</string>
-    <string name="event_delete_body">该事件将从您的日历以及所有同步设备中移除。</string>
-    <string name="event_delete_recurring_title">删除重复事件</string>
-    <string name="event_delete_option_occurrence">仅此事件</string>
-    <string name="event_delete_option_following">此事件及其后的所有事件</string>
-    <string name="event_delete_option_series">整个系列的所有事件</string>
-    <string name="event_edit_recurring_title">编辑重复事件</string>
-    <string name="event_delete_failed">无法删除事件</string>
-    <string name="event_delete_write_denied">Calendula 需要写入权限才能删除事件</string>
+    <string name="event_share_chooser_title">分享活动</string>
+    <string name="event_share_failed">无法分享该活动。</string>
+    <string name="event_delete_title">删除活动？</string>
+    <string name="event_delete_body">该活动将从你的日历以及所有同步设备中移除。</string>
+    <string name="event_delete_recurring_title">删除重复活动</string>
+    <string name="event_delete_option_occurrence">仅该活动</string>
+    <string name="event_delete_option_following">当前及接下来的所有活动</string>
+    <string name="event_delete_option_series">系列中的所有活动</string>
+    <string name="event_edit_recurring_title">编辑重复活动</string>
+    <string name="event_delete_failed">无法删除该活动</string>
+    <string name="event_delete_write_denied">Calendula需要权限读取或删除活动</string>
    <string name="dialog_cancel">取消</string>
-    <string name="dialog_ok">确定</string>
-    <string name="event_edit_new_title">新事件</string>
+    <string name="dialog_ok">确认</string>
+    <string name="event_edit_new_title">新活动</string>
    <string name="event_edit_close">关闭</string>
    <string name="event_edit_save">保存</string>
-    <string name="event_edit_title_hint">添加标题</string>
-    <string name="event_edit_managed_hint">由“%1$s”管理——标题、日期和重复会从您的联系人同步。提醒、位置和备注由您编辑。</string>
+    <string name="event_edit_title_hint">增加标题</string>
+    <string name="event_edit_managed_hint">由“%1$s”管理——标题、日期和重复内容会与你的联系人保持同步。提醒、位置和笔记由你自行编辑。</string>
    <string name="event_edit_starts">开始</string>
    <string name="event_edit_ends">结束</string>
-    <string name="event_edit_error_end_before_start">结束时间早于开始时间</string>
-    <string name="event_edit_error_no_calendar">没有可写入的日历</string>
-    <string name="event_edit_save_failed">无法保存事件</string>
-    <string name="event_edit_write_denied">Calendula 需要写入权限才能创建事件</string>
-    <string name="event_edit_more_fields">更多字段</string>
-    <string name="event_edit_add">添加</string>
-    <string name="event_edit_add_reminder">添加提醒</string>
+    <string name="event_edit_error_end_before_start">报错：结束时间早于起始时间</string>
+    <string name="event_edit_error_no_calendar">无可写入的日历</string>
+    <string name="event_edit_save_failed">无法保存该活动</string>
+    <string name="event_edit_write_denied">Calendula需要写入权限来创建活动</string>
+    <string name="event_edit_more_fields">其他领域</string>
+    <string name="event_edit_add">新增</string>
+    <string name="event_edit_add_reminder">新建提醒</string>
    <string name="event_edit_remove_reminder">移除提醒</string>
-    <string name="event_edit_attendees">参与者</string>
-    <string name="event_edit_add_guest">添加参与者</string>
-    <string name="event_edit_add_guest_hint">通过电子邮件添加参与者…</string>
-    <string name="event_edit_add_guest_from_contacts">从联系人添加</string>
-    <string name="event_edit_location_from_contacts">从联系人选取地址</string>
-    <string name="event_edit_remove_guest">移除参与者</string>
-    <string name="event_edit_attendee_required">必需</string>
-    <string name="event_edit_attendee_optional">可选</string>
-    <string name="event_edit_attendees_note_synced">Calendula 不发送邀请。您的日历帐户同步时可能会通过邮件通知参与者。</string>
-    <string name="event_edit_attendees_note_local">存储于本设备，不会通知任何人。</string>
+    <string name="event_edit_attendees">访问者</string>
+    <string name="event_edit_add_guest">新增访问者</string>
+    <string name="event_edit_add_guest_hint">通过 Email 新增一个访问者…</string>
+    <string name="event_edit_add_guest_from_contacts">从联系人中添加访问者</string>
+    <string name="event_edit_location_from_contacts">从联系人中添加地址</string>
+    <string name="event_edit_remove_guest">移除访问者</string>
+    <string name="event_edit_attendee_required">必填</string>
+    <string name="event_edit_attendee_optional">可选项</string>
+    <string name="event_edit_attendees_note_synced">Calendula 不发送邀请函。你的日历账户同步时可能会给访客发邮件。</string>
+    <string name="event_edit_attendees_note_local">保存在本设备，其他访客不会被提醒。</string>
    <string name="event_edit_reminder_custom">自定义</string>
    <string name="reminder_unit_minutes">分钟</string>
    <string name="reminder_unit_hours">小时</string>
    <string name="reminder_unit_days">天</string>
    <string name="reminder_unit_weeks">周</string>
-    <string name="event_edit_availability">忙闲状态</string>
-    <string name="event_edit_visibility">可见性</string>
-    <string name="event_edit_color">颜色</string>
+    <string name="event_edit_availability">空闲</string>
+    <string name="event_edit_visibility">隐私设置</string>
+    <string name="event_edit_color">色彩</string>
    <string name="event_edit_color_default">日历颜色</string>
    <string name="event_edit_color_custom">自定义颜色</string>
    <string name="event_edit_color_reset">重置</string>
-    <string name="event_edit_color_unsupported">此日历不支持</string>
-    <string name="event_edit_color_unsupported_hint">此日历未提供颜色集。您可以在“设置”中为此类日历允许自定义颜色。</string>
-    <string name="event_edit_color_sync_warning">此日历下次同步时可能会丢弃或覆盖该颜色。</string>
-    <string name="event_edit_conflict_title">事件已在别处更改</string>
-    <string name="event_edit_conflict_body">您编辑时，此事件已通过同步或其他应用被修改。您的更改应如何处理？</string>
+    <string name="event_edit_color_unsupported">该日历不可用</string>
+    <string name="event_edit_color_unsupported_hint">此日历未设置任何颜色集。您可以在“设置”中为此类日历启用自定义颜色。</string>
+    <string name="event_edit_color_sync_warning">该日历在下一次同步时可能会删除或覆盖该颜色。</string>
+    <string name="event_edit_conflict_title">其他设备的活动已更改</string>
+    <string name="event_edit_conflict_body">您在编辑时，该事件已被同步或其他应用修改。您的修改要怎么处理？</string>
    <string name="event_edit_conflict_overwrite">保存我的更改</string>
-    <string name="event_edit_conflict_overwrite_hint">仅覆盖您编辑过的字段</string>
+    <string name="event_edit_conflict_overwrite_hint">仅您编辑的字段会覆盖外部更改</string>
    <string name="event_edit_conflict_discard">丢弃我的更改</string>
-    <string name="event_edit_conflict_discard_hint">事件保持当前状态</string>
-    <string name="event_edit_gone_title">事件已被删除</string>
-    <string name="event_edit_gone_body">该事件在您编辑期间已被删除（例如在另一设备上）。您的更改无法再保存。</string>
-    <string name="event_edit_recurrence_none">不重复</string>
+    <string name="event_edit_conflict_discard_hint">该活动保持现状</string>
+    <string name="event_edit_gone_title">活动被删除</string>
+    <string name="event_edit_gone_body">这个事件在您编辑期间已被删除了（比如在另一台设备上）。您的修改现在无法保存。</string>
+    <string name="event_edit_recurrence_none">确认无需重复</string>
    <string name="event_edit_recurrence_custom">自定义</string>
    <string name="event_edit_recurrence_every">每</string>
    <string name="recurrence_unit_days">天</string>
    <string name="recurrence_unit_weeks">周</string>
    <string name="recurrence_unit_months">月</string>
    <string name="recurrence_unit_years">年</string>
-    <string name="event_edit_recurrence_ends">结束</string>
-    <string name="event_edit_recurrence_end_never">永不</string>
+    <string name="event_edit_recurrence_ends">结束时间</string>
+    <string name="event_edit_recurrence_end_never">从不</string>
    <string name="event_edit_recurrence_end_until">于指定日期</string>
-    <string name="event_edit_recurrence_end_count">在指定次数后</string>
+    <string name="event_edit_recurrence_end_count">重复几次后</string>
    <string name="event_edit_recurrence_times">次</string>
-    <string name="event_edit_error_recurrence_ends_before_start">重复结束日期早于事件开始时间</string>
-    <string name="event_availability_busy">忙碌</string>
+    <string name="event_edit_error_recurrence_ends_before_start">报错：结束日期早于开始日期</string>
+    <string name="event_availability_busy">占用中</string>
    <string name="event_access_default">默认</string>
    <string name="event_access_public">公开</string>
-    <string name="event_detail_duplicate">复制</string>
-    <string name="event_move_action">移动…</string>
-    <string name="event_move_recurring_title">删除重复活动</string>
-    <string name="event_move_occurrence_only">移动整个系列会改变其发生日期，因此只能移动此事件。</string>
-    <string name="event_move_done">已移动到 %1$s</string>
-    <string name="event_move_undo">撤销</string>
-    <string name="event_move_undone">已撤销移动</string>
-    <string name="event_move_failed">无法保存该活动</string>
-    <string name="event_move_write_denied">Calendula需要权限读取或删除活动</string>
-    <string name="event_move_gone">该事件已不存在</string>
-    <string name="event_move_blocked_series_end">无法将事件移至其系列结束日期之后</string>
-    <string name="event_edit_timezone_device">设备时区</string>
-    <string name="event_edit_timezone_device_summary">跟随您所在位置</string>
-    <string name="event_edit_timezone_search">搜索时区</string>
-    <string name="event_edit_timezone_recent">最近使用</string>
-    <string name="event_edit_timezone_all">所有时区</string>
-    <string name="event_edit_timezone_none">没有与“%1$s”匹配的时区</string>
-    <string name="event_edit_timezone_local_time">%1$s 您的本地时间</string>
-    <string name="import_reminder_prompt_title">应用默认提醒？</string>
-    <string name="import_reminder_prompt_body_none">此事件导入时没有提醒。</string>
-    <plurals name="import_reminder_prompt_body_existing">
-        <item quantity="other">此事件导入时包含 %1$d 个提醒。</item>
-    </plurals>
-    <string name="app_name">Calendula</string>
-    <string name="week_number_label">第</string>
-    <string name="import_reminder_prompt_apply">应用默认</string>
-    <string name="import_reminder_prompt_keep">保留原样</string>
-    <string name="event_edit_recurrence_incomplete">请输入 1 到 999 之间的数字</string>
-    <string name="event_edit_recurrence_next">下一次：%1$s</string>
-    <string name="event_edit_recurrence_next_none">此规则永不重复</string>
-    <string name="event_detail_all_day">全天</string>
-    <string name="event_detail_calendar">Calendula</string>
-    <string name="event_detail_calendar_unknown">未知日历</string>
-    <string name="event_detail_location">地点</string>
-    <string name="event_detail_description">描述</string>
-    <string name="event_detail_attendees">参与者</string>
-    <string name="event_detail_recurrence">重复</string>
-    <string name="event_detail_recurring">重复事件</string>
-    <string name="recurrence_daily">每天</string>
-    <string name="recurrence_weekly">每周</string>
-    <string name="recurrence_monthly">每月</string>
-    <string name="recurrence_yearly">每年</string>
-    <string name="recurrence_every_n_days">每 %1$d 天</string>
-    <string name="recurrence_every_n_weeks">每 %1$d 周</string>
-    <string name="recurrence_every_n_months">每 %1$d 月</string>
-    <string name="recurrence_every_n_years">每 %1$d 年</string>
-    <string name="recurrence_on_days">%1$s（%2$s）</string>
-    <string name="recurrence_with_until">%1$s，直到 %2$s</string>
-    <string name="recurrence_with_count">%1$s，共 %2$d 次</string>
-    <string name="event_detail_not_found">此事件已不存在。</string>
-    <string name="event_attendee_accepted">已接受</string>
-    <string name="event_attendee_declined">已拒绝</string>
-    <string name="event_attendee_tentative">待定</string>
-    <string name="event_attendee_needs_action">未回复</string>
-    <string name="event_attendee_unknown">—</string>
-    <string name="event_detail_reminders">提醒</string>
-    <string name="event_detail_timezone">时区</string>
-    <string name="event_status_tentative">待定</string>
-    <string name="event_status_cancelled">取消</string>
-    <string name="event_availability_free">空闲</string>
-    <string name="event_access_private">私密</string>
-    <string name="event_access_confidential">机密</string>
-    <string name="event_access_default_summary">按日历默认设置</string>
-    <string name="event_access_public_summary">有权限者可见全部详情</string>
-    <string name="event_access_private_summary">他人仅看到您忙碌</string>
-    <string name="event_access_confidential_summary">标记为机密，具体含义由日历帐户决定</string>
-    <string name="event_attendee_organizer">组织者</string>
-    <string name="event_attendee_optional">可选项</string>
-    <string name="event_attendee_resource">资源</string>
-    <string name="event_detail_self_response">您的回复：%1$s</string>
-    <string name="reminder_at_time">事件开始时</string>
-    <string name="reminder_default">默认提醒</string>
-    <plurals name="reminder_minutes">
-        <item quantity="other">提前 %d 分钟</item>
-    </plurals>
-    <plurals name="reminder_hours">
-        <item quantity="other">提前 %d 小时</item>
-    </plurals>
-    <plurals name="reminder_days">
-        <item quantity="other">提前 %d 天</item>
-    </plurals>
-    <plurals name="reminder_weeks">
-        <item quantity="other">提前 %d 周</item>
-    </plurals>
-    <plurals name="duration_minutes">
-        <item quantity="other">%d分钟</item>
-    </plurals>
-    <plurals name="duration_hours">
-        <item quantity="other">%d 小时</item>
-    </plurals>
-    <plurals name="duration_days">
-        <item quantity="other">%d 天</item>
-    </plurals>
-    <string name="duration_hours_minutes">%1$s %2$s</string>
-    <string name="duration_custom_max">最多 %1$s</string>
-    <plurals name="duration_weeks">
-        <item quantity="other">%d 周</item>
-    </plurals>
-    <string name="event_untitled">（无标题）</string>
-    <string name="onboarding_step_counter">第 %1$d 步，共 %2$d 步</string>
-    <string name="onboarding_backup_title">您的事件仅保存在这里</string>
-    <string name="onboarding_backup_body">本手机上的事件不会同步到任何帐户，丢失手机将丢失日历。Calendula 可以为您创建备份。</string>
-    <string name="onboarding_backup_benefit_folder_title">您选择的文件夹</string>
-    <string name="onboarding_backup_benefit_folder_body">备份为纯 .ics 文件——可存放在同步文件夹或 SD 卡中。</string>
-    <string name="onboarding_backup_benefit_daily_title">每天自动备份</string>
-    <string name="onboarding_backup_benefit_daily_body">Calendula 会在后台导出您的本地日历。您可以在“设置”中更改频率。</string>
-    <string name="onboarding_backup_enable_button">选择文件夹并备份</string>
-    <string name="onboarding_backup_skip_button">暂不</string>
-    <string name="onboarding_view_title">默认打开哪个视图？</string>
-    <string name="onboarding_month_style_title">月视图样式？</string>
-    <string name="onboarding_view_continue_button">继续</string>
-    <string name="onboarding_back">返回</string>
-    <string name="onboarding_visibility_button">知道了</string>
-    <string name="onboarding_done_title">一切就绪</string>
-    <string name="onboarding_done_body">您的日历已就绪。所有选择均可在“设置”中更改。</string>
-    <string name="onboarding_done_button">打开我的日历</string>
-    <string name="reminder_channel_name">事件提醒</string>
-    <string name="reminder_channel_description">按事件提醒时间推送的通知</string>
-    <string name="reminder_onboarding_title">不错过任何事件</string>
-    <string name="reminder_onboarding_body">Android 本身不会显示事件提醒——需要日历应用来承担。让 Calendula 接管这项工作吧。</string>
-    <string name="reminder_benefit_delivery_title">准时送达提醒</string>
-    <string name="reminder_benefit_delivery_body">您事件中的每个提醒都会按时以通知形式送达。</string>
-    <string name="reminder_benefit_duplicates_title">使用第二个日历应用？</string>
-    <string name="reminder_benefit_duplicates_body">如果另一个应用也发送提醒，您会看到两次——请在其中一个中关闭。</string>
-    <string name="reminder_benefit_reversible_title">随时更改</string>
-    <string name="reminder_benefit_reversible_body">开关位于“设置”中的“通知”下。</string>
-    <string name="reminder_onboarding_enable_button">开启提醒</string>
-    <string name="reminder_onboarding_skip_button">暂不</string>
-    <string name="reminder_action_snooze">稍后提醒</string>
-    <string name="reminder_action_dismiss">关闭</string>
-    <string name="reminder_day_tomorrow">明天</string>
-    <string name="reminder_day_yesterday">昨天</string>
-    <string name="view_month">月</string>
-    <string name="view_week">周</string>
-    <string name="view_day">日</string>
-    <string name="view_agenda">日程</string>
-    <string name="view_section">视图</string>
-    <string name="drawer_jump_to_date">跳转到日期</string>
-    <string name="agenda_today_action">今天</string>
-    <string name="agenda_header_today">今天</string>
-    <string name="agenda_header_tomorrow">明天</string>
-    <string name="agenda_empty_title">暂无待办</string>
-    <string name="agenda_no_more_today">今天没有更多事件</string>
-    <string name="agenda_span_starts">开始 %1$s</string>
-    <string name="agenda_span_ends">结束 %1$s</string>
-    <string name="today_jump_action">去今天</string>
-    <string name="search_action">搜索</string>
-    <string name="search_hint">搜索事件</string>
-    <string name="search_back">返回</string>
-    <string name="search_clear">清除</string>
-    <string name="search_idle_hint">按标题、地点或备注搜索您的事件。</string>
-    <string name="search_empty">没有与“%1$s”匹配的事件。</string>
-    <plurals name="search_selected_count">
-        <item quantity="other">已选 %d 个</item>
-    </plurals>
-    <string name="search_in_descriptions">在描述中找到</string>
-    <string name="search_selection_close">取消选择</string>
-    <string name="search_select_all">全选</string>
-    <string name="search_delete_selected">删除所选</string>
-    <plurals name="search_delete_title">
-        <item quantity="other">删除 %d个活动？</item>
-    </plurals>
-    <plurals name="search_delete_done">
-        <item quantity="other">删除了%d个活动</item>
-    </plurals>
-    <string name="search_delete_partial">已删除 %1$d 个，%2$d 个无法删除</string>
-    <string name="search_delete_denied_partial">已删除 %1$d 个，之后写入权限被撤</string>
-    <string name="widget_agenda_title">即将开始</string>
-    <string name="widget_agenda_label">Calendula 日程</string>
-    <string name="widget_month_label">Calendula 月视图</string>
-    <string name="widget_refresh">刷新</string>
-    <string name="widget_new_event">新活动</string>
-    <string name="widget_needs_permission">打开 Calendula 授予日历访问权限</string>
-    <string name="widget_prev_month">上个月</string>
-    <string name="widget_next_month">下个月</string>
-    <string name="widget_today">今天</string>
-    <string name="filter_title">日历</string>
-    <string name="settings_title">设置</string>
-    <string name="settings_back">返回</string>
-    <string name="back">返回</string>
-    <string name="settings_section_appearance">外观</string>
-    <string name="settings_theme">主题</string>
-    <string name="settings_theme_system">跟随系统</string>
-    <string name="settings_theme_light">浅色</string>
-    <string name="settings_theme_dark">深色</string>
-    <string name="settings_theme_hint">应用使用浅色或深色主题。选择后立即生效。</string>
-    <string name="settings_theme_system_summary">当前为 %1$s</string>
-    <string name="settings_default_view">默认视图</string>
-    <string name="settings_dynamic_color">动态颜色</string>
-    <string name="settings_dynamic_color_unavailable">需要 Android 12 或更高版本</string>
-    <string name="settings_soften_colors">协调日历颜色</string>
-    <string name="settings_soften_colors_summary">保留每个日历的色调但均衡亮度，使所有事件清晰可读且色彩协调。关闭则显示日历源的原始颜色。</string>
-    <string name="settings_font_headings">标题字体</string>
-    <string name="settings_font_body">正文字体</string>
-    <string name="settings_font_system">系统默认</string>
-    <string name="font_atkinson_hyperlegible">Atkinson Hyperlegible</string>
-    <string name="font_lora">Lora</string>
-    <string name="font_jetbrains_mono">JetBrains Mono</string>
-    <string name="settings_font_choose_file">选择文件…</string>
-    <string name="settings_font_custom_selected">自定义字体</string>
-    <string name="settings_font_import_failed">无法将文件识别为字体</string>
-    <string name="settings_font_specimen_heading">2026年8月28日 星期四</string>
-    <string name="settings_font_specimen_body">团队评审 10:00，然后与 Robin 在集市广场咖啡馆共进午餐。</string>
-    <string name="settings_week_start">每周起始日</string>
-    <string name="settings_week_start_auto">自动</string>
-    <string name="settings_week_start_auto_summary">当前为 %1$s</string>
-    <string name="settings_week_numbers">周数</string>
-    <string name="settings_week_numbers_summary">在月视图中显示日历周数</string>
-    <string name="settings_today_toolbar">工具栏中的“今天”按钮</string>
-    <string name="settings_today_toolbar_summary">在工具栏中显示“跳至今天”按钮，而非浮动按钮</string>
-    <string name="settings_app_name">应用名称</string>
-    <string name="settings_app_name_summary">在启动器中显示为“日历”。仅启动器名称改变；切换后图标可能移动到新位置。</string>
-    <string name="settings_time_format">时间格式</string>
-    <string name="settings_time_format_auto">自动</string>
-    <string name="settings_time_format_12h">12 小时制（下午 2:00）</string>
-    <string name="settings_time_format_24h">24 小时制（14:00）</string>
-    <string name="settings_time_format_auto_summary">跟随系统：%1$s</string>
-    <string name="settings_hour_lines">整点分隔线</string>
-    <string name="settings_hour_lines_summary">在周视图和日视图中显示每个整点的分隔线</string>
-    <string name="settings_timeline_scale">小时高度</string>
-    <string name="settings_timeline_scale_hint">周视图和日视图中每小时占用的垂直空间。两者共享此设置。您也可以用双指捏合时间线设置任意高度。</string>
-    <string name="timeline_scale_fit_day">适应全天</string>
-    <string name="timeline_scale_fit_day_summary">24 小时一屏显示，无需滚动</string>
-    <string name="timeline_scale_compact">紧凑</string>
-    <string name="timeline_scale_compact_summary">每屏显示更多小时，区块更小</string>
-    <string name="timeline_scale_regular">常规</string>
-    <string name="timeline_scale_regular_summary">标准间距</string>
-    <string name="timeline_scale_comfortable">舒适</string>
-    <string name="timeline_scale_comfortable_summary">区块更宽敞，需更多滚动</string>
-    <string name="timeline_scale_custom">自定义</string>
-    <string name="timeline_scale_custom_summary">您捏合时间线所设定的高度</string>
-    <string name="settings_dim_completed">变暗已完成事件</string>
-    <string name="settings_dim_completed_summary">在月视图和周视图中淡化已结束的事件</string>
-    <string name="settings_drag_to_reschedule">拖拽重新安排</string>
-    <string name="settings_drag_to_reschedule_summary">通过拖拽事件到另一天或时间来移动它</string>
-    <string name="settings_past_events">过去事件</string>
-    <string name="settings_past_events_show">显示</string>
-    <string name="settings_past_events_dim">变暗</string>
-    <string name="settings_past_events_hide">隐藏</string>
-    <string name="settings_past_events_sample_morning">团队评审</string>
-    <string name="settings_past_events_sample_midday">与 Robin 午餐</string>
-    <string name="settings_past_events_sample_evening">合唱团练习</string>
-    <string name="settings_agenda_header">日程</string>
-    <string name="settings_agenda_range">日程范围</string>
-    <string name="settings_agenda_range_hint">“日程”视图列出未来事件的时间跨度。</string>
-    <string name="settings_agenda_widget_range">日程小部件范围</string>
-    <string name="settings_agenda_widget_range_hint">主屏幕日程小部件列出未来事件的时间跨度。</string>
-    <string name="settings_widget_size">日程小部件大小</string>
-    <string name="settings_widget_size_hint">主屏幕日程小部件绘制文字的大小。月视图小部件无此设置——它的网格始终适应您给定的空间。</string>
-    <string name="settings_widget_size_small">小</string>
-    <string name="settings_widget_size_medium">中</string>
-    <string name="settings_widget_size_large">大</string>
-    <string name="settings_widget_size_extra_large">特大</string>
-    <string name="settings_widget_size_summary">事件文字 %1$d%%</string>
-    <string name="settings_agenda_show_today">始终显示今天</string>
-    <string name="settings_agenda_show_today_hint">即使今天没有剩余事件，也将今天保持在日程及其小部件顶部。</string>
-    <string name="settings_agenda_range_bar">范围栏</string>
-    <string name="settings_agenda_range_bar_hint">在日程顶部显示一个条，标明显示的日期范围，并提供一个按钮用于临时切换范围</string>
-    <string name="agenda_range_day">今天</string>
-    <string name="agenda_range_this_week">本周</string>
-    <string name="agenda_range_this_month">本月</string>
-    <string name="agenda_range_week">未来 7 天</string>
-    <string name="agenda_range_month">未来 30 天</string>
-    <string name="agenda_range_custom">自定义…</string>
-    <string name="agenda_range_custom_hint">天数</string>
-    <string name="agenda_range_override_hint">仅本次生效——重新打开 Calendula 时恢复为已保存的范围。</string>
-    <string name="agenda_range_showing_label">显示所有未来事件</string>
-    <plurals name="agenda_range_days">
-        <item quantity="other">%d 天</item>
-    </plurals>
-    <string name="settings_section_views">视图</string>
-    <string name="settings_month_header">月视图</string>
-    <string name="settings_month_view_style">月视图样式</string>
-    <string name="month_style_paged">分页</string>
-    <string name="month_style_paged_summary">一屏显示一个月，左右滑动切换月份。</string>
-    <string name="month_style_continuous">滚动月份</string>
-    <string name="month_style_continuous_summary">每个月在其标题下，与下个月之间略有间距。</string>
-    <string name="month_style_dense">无缝周</string>
-    <string name="month_style_dense_summary">各周连续排列，月份之间无间隙。</string>
-    <string name="month_style_split">拆分</string>
-    <string name="month_style_split_summary">紧凑网格标记有事件的日子，点击的日期在下方列出。</string>
-    <string name="month_split_no_events">无安排</string>
-    <string name="month_split_expand">显示整月</string>
-    <string name="month_split_collapse">显示当天事件</string>
-    <string name="settings_quick_switch_header">快速切换按钮</string>
-    <string name="settings_quick_switch_hint">选择右上角按钮循环切换的视图，并拖动排序。关闭的视图仍可从导航菜单访问。</string>
-    <string name="settings_drawer_order_header">导航菜单</string>
-    <string name="settings_drawer_order_hint">拖动排序导航菜单中的视图。</string>
-    <string name="reorder_drag_handle">拖动以排序</string>
-    <string name="settings_section_event_form">新建事件表单</string>
-    <string name="settings_form_fields_hint">默认显示的字段——其他字段位于“更多字段”下</string>
-    <string name="settings_autofocus_title">新建事件时聚焦标题</string>
-    <string name="settings_autofocus_title_hint">创建新事件时，光标自动置于标题字段并弹出键盘。</string>
-    <string name="settings_event_duration">默认时长</string>
-    <string name="settings_event_duration_hint">新事件在您更改结束时间之前的默认时长。全天事件不受影响。</string>
-    <string name="settings_calendar_durations_title">按日历设置时长</string>
-    <string name="settings_calendar_durations_hint">为某个日历单独设置默认时长——例如工作班次设为 8 小时。</string>
-    <string name="settings_calendar_duration_inherits">默认（%1$s）</string>
-    <string name="settings_calendar_duration_use_default">使用默认时长（%1$s）</string>
-    <string name="settings_color_unsupported">允许在不支持的日历上使用颜色</string>
-    <string name="settings_color_unsupported_hint">某些日历（例如某些 CalDAV）未发布颜色集；自定义事件颜色可能会在下一次同步时被丢弃或覆盖。这是那些日历的限制，并非 Calendula 可修复的问题。</string>
-    <string name="settings_section_notifications">通知</string>
-    <string name="settings_reminders">事件提醒</string>
-    <string name="settings_reminders_hint">看到重复提醒？另一个日历应用也在发送——请关闭其中一个。</string>
-    <string name="settings_default_reminder">默认提醒</string>
-    <string name="settings_default_reminder_allday">全天事件</string>
-    <string name="settings_allday_reminder_time">全天事件提醒时间</string>
-    <string name="settings_allday_reminder_time_hint">全天事件的提醒在 %1$s 触发</string>
-    <string name="settings_allday_reminder_fires_at">在 %1$s 通知</string>
-    <string name="reminder_none">无</string>
-    <string name="reminder_use_default">使用默认提醒</string>
-    <string name="reminder_custom_amount">数量</string>
-    <string name="reminder_custom_set">设置</string>
-    <string name="settings_calendar_reminders_title">按日历设置提醒</string>
-    <string name="settings_calendar_reminders_hint">为每个日历覆盖默认提醒——分别针对定时事件和全天事件。日历可保持默认、不使用提醒，或设置自己的提醒。</string>
-    <string name="settings_calendar_reminder_inherits">默认（%1$s）</string>
-    <string name="settings_reliable_delivery">可靠送达</string>
-    <string name="settings_reliable_delivery_hint">Android 可能为省电延迟提醒。豁免 Calendula 以使其准时送达。</string>
-    <string name="settings_reliable_delivery_exempt">豁免电池优化——提醒准时送达。</string>
-    <string name="settings_snooze_duration">贪睡时长</string>
-    <string name="settings_section_calendars">日历</string>
-    <string name="settings_manage_calendars">管理日历</string>
-    <string name="settings_manage_calendars_hint">创建本地日历；管理同步日历</string>
-    <string name="settings_section_language">语言</string>
-    <string name="settings_language">应用语言</string>
-    <string name="settings_language_auto">系统默认</string>
-    <string name="settings_translate">帮助翻译</string>
-    <string name="settings_translate_hint">在 Weblate 上添加或改进语言</string>
-    <string name="settings_group_look">外观与行为</string>
-    <string name="settings_group_data">数据</string>
-    <string name="settings_group_app">应用</string>
-    <string name="settings_group_about">关于</string>
-    <string name="settings_appearance_subtitle">主题、颜色、字体</string>
-    <string name="settings_views_subtitle">默认视图、布局、顺序</string>
-    <string name="settings_event_form_subtitle">默认字段和行为</string>
-    <string name="settings_notifications_subtitle">提醒与送达</string>
-    <string name="settings_special_dates_subtitle">联系人生日和纪念日</string>
-    <string name="settings_widgets_subtitle">日程小部件、快速设置磁贴</string>
-    <string name="settings_backup_subtitle">导出、导入、自动备份</string>
-    <string name="settings_section_widgets">小部件与磁贴</string>
-    <string name="settings_widgets_hint">主屏幕小部件和快速设置磁贴的设置。长按主屏幕即可添加小部件。</string>
-    <string name="settings_section_backup">备份与恢复</string>
-    <string name="settings_views_all_header">所有视图</string>
-    <string name="settings_week_day_header">周与日</string>
-    <string name="settings_default_view_hint">启动 Calendula 时默认打开的视图。</string>
-    <string name="settings_week_start_hint">所有视图和小部件中每周开始的日子。</string>
-    <string name="settings_time_format_hint">整个应用的时间显示格式。自动跟随系统设置。</string>
-    <string name="settings_past_events_hint">日程对已结束事件的处理方式。</string>
-    <string name="settings_dynamic_color_summary">从壁纸中提取应用颜色。</string>
-    <string name="settings_section_special_dates">联系人特殊日期</string>
-    <string name="settings_special_dates_enable">显示联系人日期</string>
-    <string name="settings_special_dates_enable_hint">将联系人生日和其他日期镜像到本地日历。仅读取本设备上的联系人——不会上传任何内容，也不会修改您的联系人。</string>
-    <string name="settings_special_dates_type_birthday">生日</string>
-    <string name="settings_special_dates_type_anniversary">纪念日</string>
-    <string name="settings_special_dates_type_custom">其他日期</string>
-    <string name="settings_special_dates_template">标题格式</string>
-    <string name="settings_special_dates_template_hint">使用 {name} 表示联系人，{year} 表示年份（出生年份或纪念日开始年份；未知时隐藏）。</string>
-    <string name="settings_special_dates_reminders">提醒</string>
-    <string name="settings_special_dates_show_year">显示年份</string>
-    <string name="settings_special_dates_show_year_hint">在标题中包含 {year}（当已知时）</string>
-    <string name="settings_special_dates_sync_now">立即同步</string>
-    <string name="settings_special_dates_never_synced">尚未同步</string>
-    <string name="settings_special_dates_last_synced">上次同步：%1$s</string>
-    <string name="settings_special_dates_calendar_hint">在“日历”设置中分别设置每个日历的颜色和可见性。</string>
-    <string name="settings_calendar_reminders_managed_hint">在“联系人特殊日期”中设置</string>
-    <string name="settings_special_dates_paused_title">已暂停</string>
-    <string name="settings_special_dates_paused_hint">Calendula 无法读取您的联系人，因此这些日历未更新。</string>
-    <string name="settings_special_dates_grant">授予访问权限</string>
-    <string name="settings_special_dates_disable_title">关闭联系人日期？</string>
-    <string name="settings_special_dates_disable_all_message">这将删除联系人日期日历及其事件。您添加的任何提醒或备注将丢失。</string>
-    <string name="settings_special_dates_disable_type_message">这将删除“%1$s”日历及其事件。您添加的任何提醒或备注将丢失。</string>
-    <string name="settings_special_dates_disable_confirm">关闭</string>
-    <string name="dialog_save">保存</string>
-    <string name="settings_section_about">关于</string>
-    <string name="settings_license">许可协议</string>
-    <string name="settings_license_value">MIT</string>
-    <string name="settings_about_author">作者 Jean-Luc Makiola</string>
-    <string name="settings_about_source">源代码</string>
-    <string name="settings_about_privacy">隐私政策</string>
-    <string name="settings_about_support">支持开发</string>
-    <string name="settings_about_version">版本 %1$s</string>
-    <string name="settings_about_logo_desc">Calendula 应用图标</string>
-    <string name="settings_report_problem">报告问题</string>
-    <string name="settings_report_problem_hint">发送崩溃报告或打开问题追踪器</string>
-    <string name="calendars_title">日历</string>
-    <string name="calendars_local_header">您的日历</string>
-    <string name="calendars_local_empty">尚未创建本地日历。创建一个以仅在本设备保存事件。</string>
-    <string name="calendars_add">添加日历</string>
-    <string name="calendars_visibility_hint">关闭日历可隐藏其在设备上的显示——事件会从应用中消失，同时停止提醒。此开关与其他日历应用共用，因此它们也会隐藏。不会删除任何内容，不会影响其他设备，您随时可在此重新开启。</string>
-    <string name="calendars_visibility_a11y">显示“%1$s”</string>
-    <string name="calendars_visibility_notice_title">部分日历已关闭</string>
-    <string name="calendars_visibility_notice_message">Calendula 显示本设备已开启的日历，但您有一些是关闭的。要查看事件，请在“设置”→“日历”中将其开启。</string>
-    <string name="calendar_picker_missing_title">找不到日历？</string>
-    <string name="calendar_picker_missing_summary">可能已关闭、只读，或由联系人填充——在此管理您的日历。</string>
-    <string name="calendars_state_read_only">只读</string>
-    <string name="calendars_state_not_synced">未同步到本设备</string>
-    <string name="calendars_state_managed">由联系人填充</string>
-    <string name="calendars_managed_delete_locked">此日历由联系人填充，Calendula 下次同步时会重新创建。要删除它，请在“设置”→“特殊日期”中关闭相关功能。</string>
-    <string name="calendars_synced_header">同步日历</string>
-    <string name="calendars_synced_hint">来自设备上的帐户。请在对应的应用中创建和编辑。</string>
-    <string name="calendars_manage_in_app">在应用中管理</string>
-    <string name="calendars_account_from_source">%1$s（%2$s）</string>
-    <string name="calendars_account_menu_a11y">%1$s 的更多选项</string>
-    <string name="calendars_enable_all">启用全部</string>
-    <string name="calendars_disable_all">禁用全部</string>
-    <string name="calendars_add_account">添加帐户</string>
-    <string name="calendars_new_title">新建日历</string>
-    <string name="calendars_edit_title">编辑日历</string>
-    <string name="calendars_name_label">名称</string>
-    <string name="calendars_color_label">色彩</string>
-    <string name="calendars_description_hint">添加描述</string>
-    <string name="calendars_delete_confirm_title">删除日历？</string>
-    <string name="calendars_delete_confirm_message">“%1$s”及其所有事件将从本设备永久删除。</string>
-    <string name="calendars_write_error">无法保存更改。</string>
-    <string name="calendars_backup_header">返回</string>
-    <string name="calendars_backup_hint">本地日历不会同步到任何地方，请导出为 .ics 文件以保留副本。</string>
-    <string name="calendars_backup_action">导出为 .ics 文件</string>
-    <string name="calendars_export_title">导出日历</string>
-    <string name="calendars_export_hint">选择要包含在 .ics 文件中的日历。</string>
-    <string name="calendars_export_action">导出</string>
-    <string name="calendars_restore_header">恢复</string>
-    <string name="calendars_restore_action">从 .ics 文件恢复</string>
-    <string name="calendars_restore_hint">从备份或其他日历应用导入事件。</string>
-    <string name="calendars_auto_backup">自动备份</string>
-    <string name="calendars_auto_backup_hint">定期将本地日历导出为 .ics 文件保存到文件夹。</string>
-    <string name="calendars_auto_backup_folder">备份文件夹</string>
-    <string name="calendars_auto_backup_folder_unset">点击选择文件夹</string>
-    <string name="calendars_auto_backup_interval">间隔</string>
-    <string name="calendars_auto_backup_every">每 %1$s</string>
-    <string name="calendars_auto_backup_interval_min">最短 30 分钟。</string>
-    <string name="calendars_auto_backup_status_never">尚未自动备份</string>
-    <string name="calendars_auto_backup_status_ok">上次备份：%1$s</string>
-    <string name="calendars_auto_backup_status_failed">上次备份失败：%1$s</string>
-    <string name="backup_channel_name">备份</string>
-    <string name="backup_channel_description">自动备份反复失败时发出警告。</string>
-    <string name="backup_failed_title">自动备份失败</string>
-    <string name="backup_failed_text">Calendula 无法写入备份文件。请在“设置”中检查备份文件夹。</string>
-    <string name="calendars_backup_failed">无法导出备份。</string>
-    <plurals name="calendars_backup_done">
-        <item quantity="other">已导出 %d 个事件。</item>
-    </plurals>
-    <string name="import_title">导入事件</string>
-    <string name="import_target_header">添加至日历</string>
-    <string name="import_empty">此文件中未找到事件。</string>
-    <string name="import_failed">无法读取此文件。</string>
-    <string name="import_no_calendar">没有可写入的日历用于导入。请先创建本地日历。</string>
-    <string name="import_done_title">导入完成</string>
-    <string name="import_done_dedup_note">已跳过日历中已存在的事件。</string>
-    <string name="import_done_added_label">已添加</string>
-    <string name="import_done_skipped_label">重复项</string>
-    <string name="import_close">关闭</string>
-    <string name="import_warning_recurrence">已跳过重复事件中部分已修改的发生项。</string>
-    <string name="import_warning_no_start">已跳过无开始时间的事件。</string>
-    <string name="import_warning_attendees">未导入参与者列表。</string>
-    <string name="import_warning_timezone">未知时区已回退为设备时区。</string>
-    <string name="import_button">导入</string>
-    <plurals name="import_title_count">
-        <item quantity="other">正在导入 %d 个事件</item>
-    </plurals>
-    <plurals name="import_event_count">
-        <item quantity="other">此文件中包含 %d 个事件。</item>
-    </plurals>
-    <plurals name="import_action">
-        <item quantity="other">导入 %d 个事件</item>
-    </plurals>
-    <plurals name="import_done_imported">
-        <item quantity="other">已导入 %d 个事件。</item>
-    </plurals>
-    <plurals name="import_done_skipped">
-        <item quantity="other">已跳过 %d 个（已存在于该日历）。</item>
-    </plurals>
-    <string name="shortcut_new_event_short">新事件</string>
-    <string name="shortcut_new_event_long">创建新事件</string>
-    <string name="qs_tile_new_event_label">新事件</string>
-    <string name="settings_qs_tile">添加快速设置磁贴</string>
-    <string name="settings_qs_tile_hint">在快速设置面板中添加“新事件”磁贴。</string>
-    <string name="crash_dialog_title">%1$s 已崩溃</string>
-    <string name="crash_dialog_message">%1$s 上次意外关闭。您可以将此报告作为问题发送以帮助修复。报告在您选择共享之前仅保留在设备上，不含任何个人数据或日历内容——仅包含以下技术细节。</string>
-    <string name="crash_dialog_report">报告</string>
-    <string name="crash_dialog_dismiss">暂不</string>
-    <string name="crash_report_issue_title">崩溃报告</string>
-    <string name="crash_report_clip_label">%1$s 崩溃报告</string>
-    <string name="crash_report_copied">报告已复制到剪贴板</string>
-    <string name="crash_report_open_failed">无法打开问题追踪器。报告已在剪贴板中。</string>
-    <string name="crash_report_body_template">感谢您报告 %1$s 的崩溃。请补充您记得的操作内容，然后提交。\n\n### 发生了什么\n\n\n### 崩溃报告\n%2$s\n</string>
-    <string name="crash_report_body_paste">_（报告太长，无法通过此链接附带——请从剪贴板粘贴。）_</string>
-    <string name="special_dates_calendar_birthday">生日</string>
-    <string name="special_dates_calendar_anniversary">纪念日</string>
-    <string name="special_dates_calendar_custom">特殊日期</string>
-    <string name="special_dates_default_title_birthday">{name} 的生日（{year}）</string>
-    <string name="special_dates_default_title_anniversary">{name} 的纪念日（{year}）</string>
-    <string name="special_dates_default_title_custom">{name}</string>
 </resources>
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -693,15 +693,11 @@
    <string name="import_done_dedup_note">Events already in the calendar were skipped.</string>
    <string name="import_done_added_label">Added</string>
    <string name="import_done_skipped_label">Duplicates</string>
-    <string name="import_done_failed_label">Not added</string>
-    <string name="import_done_failed_note">Some events couldn\'t be added and were left out.</string>
    <string name="import_close">Close</string>
    <string name="import_warning_recurrence">Some changed occurrences of recurring events were skipped.</string>
    <string name="import_warning_no_start">An event without a start time was skipped.</string>
    <string name="import_warning_attendees">Guest lists weren\'t imported.</string>
    <string name="import_warning_timezone">An unknown time zone fell back to your device\'s.</string>
-    <string name="import_warning_tasks">Tasks in this file were added as events.</string>
-    <string name="import_warning_recurrence_repaired">A faulty repeat rule was repaired.</string>
    <string name="import_button">Import</string>
    <plurals name="import_title_count">
        <item quantity="one">Importing %d event</item>
@@ -723,10 +719,6 @@
        <item quantity="one">Skipped %d already in this calendar.</item>
        <item quantity="other">Skipped %d already in this calendar.</item>
    </plurals>
-    <plurals name="import_done_failed">
-        <item quantity="one">%d event couldn\'t be added.</item>
-        <item quantity="other">%d events couldn\'t be added.</item>
-    </plurals>
    <!-- Launcher long-press shortcuts -->
    <string name="shortcut_new_event_short">New event</string>
    <string name="shortcut_new_event_long">Create a new event</string>
--- a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/AllDayReminderEncodingTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/AllDayReminderEncodingTest.kt
@@ -143,47 +143,6 @@ class AllDayReminderEncodingTest {
        assertThat(fireFromNext).isEqualTo(LocalTime.of(9, 0)) // correct
    }

-    @Test
-    fun `an imported yearly series samples at its next occurrence, not its anchor`() {
-        // Fossify anchors a year-less contact birthday at 1970, when Berlin had
-        // no DST; sampling there fires a modern June occurrence at 10:00 instead
-        // of the 09:00 the user picked (Codeberg #225).
-        val anchor = LocalDate.of(1970, 6, 3)
-        val today = LocalDate.of(2026, 6, 1)
-
-        val sampled = importedAllDayReminderDate(anchor, "FREQ=YEARLY;BYMONTH=6", today)
-        assertThat(sampled).isEqualTo(LocalDate.of(2026, 6, 3))
-
-        val raw = toProviderAllDayMinutes(0, sampled, berlin, nineAm)
-        val fire = actualFire(raw, LocalDate.of(2027, 6, 3))
-            .let(java.time.Instant::ofEpochMilli).atZone(berlin).toLocalTime()
-        assertThat(fire).isEqualTo(LocalTime.of(9, 0))
-    }
-
-    @Test
-    fun `the lead time still reads back from the anchor's own date`() {
-        // The offset is sampled at the next occurrence but decoded against
-        // DTSTART, so the two must still agree on the whole-day lead time.
-        val anchor = LocalDate.of(1970, 6, 3)
-        val sampled = importedAllDayReminderDate(anchor, "FREQ=YEARLY", LocalDate.of(2026, 6, 1))
-
-        for (semantic in listOf(0, 1_440, 2_880)) {
-            val raw = toProviderAllDayMinutes(semantic, sampled, berlin, nineAm)
-            assertThat(fromProviderAllDayMinutes(raw, anchor, berlin, nineAm)).isEqualTo(semantic)
-        }
-    }
-
-    @Test
-    fun `a one-off import samples at its own date, a stale series at today`() {
-        val past = LocalDate.of(1970, 6, 3)
-        val today = LocalDate.of(2026, 6, 1)
-        val future = LocalDate.of(2027, 3, 4)
-
-        assertThat(importedAllDayReminderDate(past, null, today)).isEqualTo(past)
-        assertThat(importedAllDayReminderDate(past, "FREQ=WEEKLY;BYDAY=MO", today)).isEqualTo(today)
-        assertThat(importedAllDayReminderDate(future, "FREQ=WEEKLY", today)).isEqualTo(future)
-    }
-
    @Test
    fun `a winter-anchored offset drifts one hour on a summer occurrence`() {
        // Known limitation: one fixed MINUTES per series can't track DST. An
--- a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImplTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/CalendarRepositoryImplTest.kt
@@ -801,62 +801,6 @@ class CalendarRepositoryImplTest {
        assertThat(fake.importedEvents.map { it.second }).containsExactly(3L, 3L)
    }

-    @Test
-    fun `importEvents carries on past an event the provider rejects`(
-        @TempDir tempDir: Path,
-    ) = runTest {
-        // A foreign export can hold a row the provider throws on outright; that
-        // must cost the user one event, not the whole file (Codeberg #225).
-        val fake = FakeCalendarDataSource().apply { failingImportSummaries += "bad" }
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
-        val events = listOf(
-            parsedEvent("a@x", summary = "good"),
-            parsedEvent("b@x", summary = "bad"),
-            parsedEvent("c@x", summary = "good"),
-        )
-
-        val summary = repo.importEvents(targetCalendarId = 3L, events = events)
-
-        assertThat(summary.imported).isEqualTo(2)
-        assertThat(summary.failed).isEqualTo(1)
-        assertThat(fake.importedEvents.map { it.first.uid }).containsExactly("a@x", "c@x")
-    }
-
-    @Test
-    fun `importEvents looks the target palette up once, not per event`(
-        @TempDir tempDir: Path,
-    ) = runTest {
-        var lookups = 0
-        val fake = FakeCalendarDataSource().apply {
-            publishedEventColorsResult = { lookups++; emptyList() }
-        }
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
-
-        repo.importEvents(3L, List(5) { parsedEvent("e$it@x") })
-
-        assertThat(lookups).isEqualTo(1)
-    }
-
-    @Test
-    fun `importEvents matches colours against the uncurated palette`(
-        @TempDir tempDir: Path,
-    ) = runTest {
-        // Curation is a picker concession — it folds look-alikes and drops the
-        // neutrals from an oversized palette — but every published key is one
-        // the calendar accepts, so an imported colour matches against all of
-        // them (Codeberg #225).
-        val published = listOf(EventColorOption("1", 0xFF808080.toInt()))
-        val fake = FakeCalendarDataSource().apply {
-            publishedEventColorsResult = { published }
-            eventColorPaletteResult = { emptyList() }
-        }
-        val repo = CalendarRepositoryImpl(fake, newPrefs(tempDir), newSettings(tempDir), Dispatchers.Unconfined)
-
-        repo.importEvents(3L, listOf(parsedEvent("a@x")))
-
-        assertThat(fake.lastImportPalette).isEqualTo(published)
-    }
-
    @Test
    fun `exportEvents forwards the chosen calendar-id subset to the data source`(
        @TempDir tempDir: Path,
@@ -881,10 +825,9 @@ class CalendarRepositoryImplTest {
        assertThat(fake.lastExportableEventsCalendarIds).isNull()
    }

-    private fun parsedEvent(uid: String?, summary: String = "E") =
-        de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent(
+    private fun parsedEvent(uid: String?) = de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent(
        uid = uid,
-        summary = summary,
+        summary = "E",
        start = Instant.fromEpochMilliseconds(1_000_000_000L),
        end = Instant.fromEpochMilliseconds(1_000_003_600L),
        isAllDay = false,
--- a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapperTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/EventWriteMapperTest.kt
@@ -128,8 +128,7 @@ class EventWriteMapperTest {
        original: EventForm,
        updated: EventForm,
        series: Long = seriesStart,
-        exdate: String? = null,
-    ): Map<String, Any?> = buildEventUpdateValues(original, updated, series, exdate, berlin)
+    ): Map<String, Any?> = buildEventUpdateValues(original, updated, series, berlin)

    /** The instant [local] names in [zoneId], as the provider would store it. */
    private fun instantAt(local: String, zoneId: String): Long =
@@ -559,239 +558,6 @@ class EventWriteMapperTest {
        assertThat(values[CalendarContract.Events.ALL_DAY]).isEqualTo(1)
    }

-    // --- EXDATE follows the series when its times change (Codeberg #248) ---
-
-    /** A weekly series whose displayed occurrence runs 15 July 2026, 09:00–10:00. */
-    private fun julySeries(): EventForm = form(
-        start = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(9, 0)),
-        end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(10, 0)),
-    ).copy(rrule = "FREQ=WEEKLY")
-
-    /** [julySeries] pushed to [hour]:00, the shift an "all events" time edit makes. */
-    private fun EventForm.atHour(hour: Int): EventForm = copy(
-        start = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(hour, 0)),
-        end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(hour + 1, 0)),
-    )
-
-    @Test
-    fun `a series time edit moves its exclusions with the anchor`() {
-        // The bug: the stamp stayed at the old instant, which the moved series no
-        // longer generates, so the occurrence the user deleted came back.
-        val series = instantAt("2026-07-01T09:00", "Europe/Berlin")
-        val original = julySeries()
-        // 8 July 09:00 Berlin (CEST, +2) == 07:00Z; at 10:00 it must read 08:00Z.
-        val values = update(original, original.atHour(10), series, "20260708T070000Z")
-        assertThat(values[CalendarContract.Events.EXDATE]).isEqualTo("20260708T080000Z")
-    }
-
-    @Test
-    fun `an exclusion keeps its wall clock across a DST boundary`() {
-        // Anchor and edited occurrence are in July (CEST, +2); the excluded
-        // occurrence sits in January (CET, +1). Shifting by the millisecond delta
-        // measured at the edited occurrence would leave it an hour off.
-        val series = instantAt("2026-01-07T09:00", "Europe/Berlin")
-        val original = julySeries()
-        // 14 January 09:00 Berlin == 08:00Z; at 10:00 it must read 09:00Z.
-        val values = update(original, original.atHour(10), series, "20260114T080000Z")
-        assertThat(values[CalendarContract.Events.EXDATE]).isEqualTo("20260114T090000Z")
-    }
-
-    @Test
-    fun `pinning a series to another zone re-resolves its exclusions there`() {
-        val series = instantAt("2026-07-01T09:00", "Europe/Berlin")
-        val original = julySeries()
-        val values = update(
-            original,
-            original.copy(timezone = "Asia/Tokyo"),
-            series,
-            "20260716T070000Z",
-        )
-        // The exclusion still reads 09:00 — now 09:00 in Tokyo (+9) == 00:00Z.
-        assertThat(values[CalendarContract.Events.EXDATE]).isEqualTo("20260716T000000Z")
-    }
-
-    @Test
-    fun `an all-day series move shifts its exclusions by whole days`() {
-        val series = instantAt("2026-07-01T00:00", "UTC")
-        val original = form(
-            isAllDay = true,
-            start = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(0, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(0, 0)),
-        ).copy(rrule = "FREQ=WEEKLY")
-        val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(0, 0)),
-        )
-
-        assertThat(update(original, moved, series, "20260722")[CalendarContract.Events.EXDATE])
-            .isEqualTo("20260724")
-    }
-
-    @Test
-    fun `switching a series to all-day rewrites its exclusions as dates`() {
-        // The two forms aren't interchangeable: a date-time stamp on an all-day
-        // series matches no occurrence, so the exclusion would be lost.
-        val series = instantAt("2026-07-01T09:00", "Europe/Berlin")
-        val original = julySeries()
-        val values = update(original, original.copy(isAllDay = true), series, "20260722T070000Z")
-        assertThat(values[CalendarContract.Events.EXDATE]).isEqualTo("20260722")
-    }
-
-    @Test
-    fun `switching a series back to timed rewrites its exclusions as instants`() {
-        val series = instantAt("2026-07-01T00:00", "UTC")
-        val original = form(
-            isAllDay = true,
-            start = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(0, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(0, 0)),
-        ).copy(rrule = "FREQ=WEEKLY")
-        val timed = original.copy(
-            isAllDay = false,
-            start = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(9, 0)),
-            end = LocalDateTime(LocalDate(2026, 7, 15), LocalTime(10, 0)),
-        )
-        // The excluded day gains the new 09:00 Berlin time-of-day == 07:00Z.
-        assertThat(update(original, timed, series, "20260722")[CalendarContract.Events.EXDATE])
-            .isEqualTo("20260722T070000Z")
-    }
-
-    @Test
-    fun `a text-only edit leaves the exclusions alone`() {
-        val original = julySeries()
-        val values = update(original, original.copy(title = "Renamed"), exdate = "20260722T070000Z")
-        assertThat(values).doesNotContainKey(CalendarContract.Events.EXDATE)
-    }
-
-    @Test
-    fun `changing only the rule rewrites no exclusions`() {
-        // The times are untouched, so every surviving occurrence keeps its instant
-        // and the stamps still name the right ones.
-        val original = julySeries()
-        val values = update(original, original.copy(rrule = "FREQ=DAILY"), exdate = "20260722T070000Z")
-        assertThat(values[CalendarContract.Events.RRULE]).isEqualTo("FREQ=DAILY")
-        assertThat(values).doesNotContainKey(CalendarContract.Events.EXDATE)
-    }
-
-    @Test
-    fun `an exdate form we do not write is left untouched`() {
-        // A sync adapter may store a TZID-parameterised or floating stamp. A stale
-        // stamp excludes nothing; a mangled one could exclude the wrong occurrence.
-        val original = julySeries()
-        val values = update(
-            original,
-            original.atHour(10),
-            instantAt("2026-07-01T09:00", "Europe/Berlin"),
-            "TZID=Europe/Berlin;20260722T090000",
-        )
-        assertThat(values).doesNotContainKey(CalendarContract.Events.EXDATE)
-    }
-
-    @Test
-    fun `removing the recurrence clears the exclusions with it`() {
-        // Dormant, not harmless: adding a recurrence back later would punch the old
-        // holes into the new one.
-        val original = julySeries()
-        val values = update(original, original.copy(rrule = null), exdate = "20260722T070000Z")
-        assertThat(values).containsEntry(CalendarContract.Events.EXDATE, null)
-    }
-
-    @Test
-    fun `undoing a series move lands the exclusions back where they started`() {
-        val series = instantAt("2026-01-07T09:00", "Europe/Berlin")
-        val original = julySeries()
-        val moved = original.copy(
-            start = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(14, 30)),
-            end = LocalDateTime(LocalDate(2026, 7, 17), LocalTime(15, 30)),
-        )
-        val exdate = "20260722T070000Z"
-
-        val forward = update(original, moved, series, exdate)
-        val movedExdate = forward[CalendarContract.Events.EXDATE] as String
-        assertThat(movedExdate).isNotEqualTo(exdate)
-
-        val back = update(
-            moved,
-            original,
-            forward[CalendarContract.Events.DTSTART] as Long,
-            movedExdate,
-        )
-        assertThat(back[CalendarContract.Events.EXDATE]).isEqualTo(exdate)
-    }
-
-    @Test
-    fun `a series with no exclusions writes no exdate column`() {
-        val series = instantAt("2026-07-01T09:00", "Europe/Berlin")
-        val original = julySeries()
-        assertThat(update(original, original.atHour(10), series, exdate = null))
-            .doesNotContainKey(CalendarContract.Events.EXDATE)
-    }
-
-    // --- exdateAfter (the exclusions a "this and following" split inherits) ---
-
-    @Test
-    fun `a split carries only the exclusions past the split point`() {
-        // The occurrence at the split point is the one being edited, so it exists
-        // by definition — a stale exclusion for it would swallow the edit whole.
-        assertThat(
-            exdateAfter(
-                existingExdate = "20260708T080000Z,20260715T080000Z,20260722T080000Z",
-                beginMillis = instantAt("2026-07-15T08:00", "UTC"),
-                isAllDay = false,
-            ),
-        ).isEqualTo("20260722T080000Z")
-    }
-
-    @Test
-    fun `a split carries nothing when every exclusion is behind it`() {
-        assertThat(
-            exdateAfter("20260708T080000Z", instantAt("2026-07-15T08:00", "UTC"), isAllDay = false),
-        ).isNull()
-        assertThat(exdateAfter(null, 0L, isAllDay = false)).isNull()
-    }
-
-    @Test
-    fun `all-day exclusions split on their UTC date`() {
-        assertThat(
-            exdateAfter("20260708,20260722", instantAt("2026-07-15T00:00", "UTC"), isAllDay = true),
-        ).isEqualTo("20260722")
-    }
-
-    @Test
-    fun `an unreadable exclusion carries nothing across a split`() {
-        assertThat(
-            exdateAfter(
-                "20260722T080000Z,TZID=Europe/Berlin;20260729T100000",
-                instantAt("2026-07-15T08:00", "UTC"),
-                isAllDay = false,
-            ),
-        ).isNull()
-    }
-
-    @Test
-    fun `split exclusions move by the same shift as the new series start`() {
-        // What the split path composes: filter to the tail, then re-time it by the
-        // shift the user applied to the occurrence they split at.
-        val original = julySeries()
-        val carried = shiftedExdate(
-            existingExdate = exdateAfter(
-                "20260716T070000Z",
-                instantAt("2026-07-15T07:00", "UTC"),
-                isAllDay = false,
-            ),
-            original = original,
-            updated = original.atHour(11),
-            zone = berlin,
-        )
-        // 16 July 09:00 Berlin, pushed two hours, is 11:00 Berlin == 09:00Z.
-        assertThat(carried).isEqualTo("20260716T090000Z")
-    }
-
-    @Test
-    fun `nothing to shift yields no exdate`() {
-        assertThat(shiftedExdate(null, julySeries(), julySeries().atHour(10), berlin)).isNull()
-        assertThat(shiftedExdate("  ", julySeries(), julySeries().atHour(10), berlin)).isNull()
-    }
-
    // --- per-event colour ---

    @Test
@@ -980,168 +746,4 @@ class EventWriteMapperTest {
        val values = buildCopiedExceptionValues(exceptionSnapshot(duration = "P900S", dtEndMillis = null))
        assertThat(values[CalendarContract.Events.DURATION]).isEqualTo("P900S")
    }
-
-    @Test
-    fun `a detached all-day occurrence matches its date-only exdate stamp`() {
-        val parent = buildOccurrenceExdateValues(
-            existingExdate = null,
-            occurrenceMillis = 1_781_136_000_000L, // 2026-06-11T00:00:00Z
-            dtStartMillis = 1_749_600_000_000L,
-            rrule = "FREQ=YEARLY",
-            duration = "P1D",
-            timezone = "UTC",
-            allDay = 1,
-        )
-        val detached = form(
-            isAllDay = true,
-            start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(0, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(0, 0)),
-        ).copy(rrule = "FREQ=YEARLY").toDetachedOccurrence()
-        val inserted = buildEventInsertValues(
-            form = detached,
-            uid = "uid@calendula",
-            times = detached.toWriteTimes(berlin),
-        )
-        assertThat(parent[CalendarContract.Events.EXDATE]).isEqualTo("20260611")
-        assertThat(inserted[CalendarContract.Events.DTSTART]).isEqualTo(1_781_136_000_000L)
-    }
-
-    @Test
-    fun `a detached all-day occurrence stays on UTC midnights`() {
-        val edited = form(
-            isAllDay = true,
-            start = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(0, 0)),
-            end = LocalDateTime(LocalDate(2026, 6, 11), LocalTime(0, 0)),
-        ).copy(title = "Birthday", rrule = "FREQ=YEARLY")
-        val detached = edited.toDetachedOccurrence()
-
-        val values = buildEventInsertValues(
-            form = detached,
-            uid = "uid@calendula",
-            times = detached.toWriteTimes(berlin),
-        )
-        assertThat(values[CalendarContract.Events.ALL_DAY]).isEqualTo(1)
-        assertThat(values[CalendarContract.Events.EVENT_TIMEZONE]).isEqualTo("UTC")
-        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(1_781_136_000_000L)
-        // Exclusive DTEND — the next UTC midnight.
-        assertThat(values[CalendarContract.Events.DTEND]).isEqualTo(1_781_222_400_000L)
-        assertThat(values).doesNotContainKey(CalendarContract.Events.RRULE)
-    }
-
-    @Test
-    fun `a detached occurrence carries every edited field onto the new row`() {
-        // Built from the form, not cloned from the parent: a field dropped here
-        // is an edit silently lost.
-        val edited = form(timezone = "America/New_York").copy(
-            title = "  Standup  ",
-            location = "Room 2",
-            description = "notes",
-            reminders = listOf(10),
-            availability = Availability.Free,
-            accessLevel = AccessLevel.Private,
-            rrule = "FREQ=DAILY",
-        )
-        val detached = edited.toDetachedOccurrence()
-
-        val values = buildEventInsertValues(
-            form = detached,
-            uid = "uid@calendula",
-            times = detached.toWriteTimes(berlin),
-        )
-        assertThat(values[CalendarContract.Events.TITLE]).isEqualTo("Standup")
-        assertThat(values[CalendarContract.Events.EVENT_LOCATION]).isEqualTo("Room 2")
-        assertThat(values[CalendarContract.Events.DESCRIPTION]).isEqualTo("notes")
-        assertThat(values[CalendarContract.Events.AVAILABILITY])
-            .isEqualTo(CalendarContract.Events.AVAILABILITY_FREE)
-        assertThat(values[CalendarContract.Events.ACCESS_LEVEL])
-            .isEqualTo(CalendarContract.Events.ACCESS_PRIVATE)
-        // The pinned zone survives — never re-anchored to the device.
-        assertThat(values[CalendarContract.Events.EVENT_TIMEZONE]).isEqualTo("America/New_York")
-        assertThat(values[CalendarContract.Events.UID_2445]).isEqualTo("uid@calendula")
-        // Reminders aren't columns; the insert path seeds them from the form.
-        assertThat(detached.reminders).containsExactly(10)
-    }
-
-    @Test
-    fun `a detached occurrence drops the series rule and becomes a one-off row`() {
-        val edited = form().copy(title = "Moved", rrule = "FREQ=WEEKLY;BYDAY=TH")
-        val detached = edited.toDetachedOccurrence()
-
-        val values = buildEventInsertValues(
-            form = detached,
-            uid = "uid@calendula",
-            times = detached.toWriteTimes(berlin),
-        )
-        assertThat(values[CalendarContract.Events.TITLE]).isEqualTo("Moved")
-        // A surviving rule would insert a second *series* overlapping the first
-        // (Codeberg #234's stray duplicate).
-        assertThat(values).doesNotContainKey(CalendarContract.Events.RRULE)
-        assertThat(values).doesNotContainKey(CalendarContract.Events.DURATION)
-        // A one-off row carries DTEND rather than a duration.
-        assertThat(values[CalendarContract.Events.DTSTART]).isEqualTo(1_781_164_800_000L)
-        assertThat(values[CalendarContract.Events.DTEND]).isEqualTo(1_781_170_200_000L)
-        assertThat(values[CalendarContract.Events.EVENT_TIMEZONE]).isEqualTo("Europe/Berlin")
-    }
-
-    @Test
-    fun `an exclusion is found anywhere in a multi-entry exdate list`() {
-        // Whitespace after a comma is legal in the stored column.
-        assertThat(
-            exdateContains(
-                "20260604T080000Z, 20260611T080000Z,20260618T080000Z",
-                1_781_164_800_000L,
-                isAllDay = false,
-            ),
-        ).isTrue()
-    }
-
-    @Test
-    fun `an occurrence already excluded is recognised, timed and all-day`() {
-        // Detaching twice would leave a second standalone copy.
-        assertThat(
-            exdateContains("20260611T080000Z", 1_781_164_800_000L, isAllDay = false),
-        ).isTrue()
-        assertThat(
-            exdateContains("20260611", 1_781_136_000_000L, isAllDay = true),
-        ).isTrue()
-    }
-
-    @Test
-    fun `an occurrence not in the exdate list is not mistaken for an excluded one`() {
-        assertThat(exdateContains(null, 1_781_164_800_000L, isAllDay = false)).isFalse()
-        assertThat(exdateContains("", 1_781_164_800_000L, isAllDay = false)).isFalse()
-        // A neighbouring occurrence must not match — the guard is per-instant.
-        assertThat(
-            exdateContains("20260610T080000Z", 1_781_164_800_000L, isAllDay = false),
-        ).isFalse()
-    }
-
-    @Test
-    fun `the detached row lands exactly where the parent's exdate removes it`() {
-        // The two halves must agree on the instant, or the user sees the
-        // occurrence twice or not at all.
-        val edited = form().copy(title = "Renamed", rrule = "FREQ=WEEKLY")
-        val occurrenceMillis = 1_781_164_800_000L
-
-        val parent = buildOccurrenceExdateValues(
-            existingExdate = null,
-            occurrenceMillis = occurrenceMillis,
-            dtStartMillis = 1_780_560_000_000L,
-            rrule = "FREQ=WEEKLY",
-            duration = "P5400S",
-            timezone = "Europe/Berlin",
-            allDay = 0,
-        )
-        val detached = edited.toDetachedOccurrence()
-        val inserted = buildEventInsertValues(
-            form = detached,
-            uid = "uid@calendula",
-            times = detached.toWriteTimes(berlin),
-        )
-        assertThat(parent[CalendarContract.Events.EXDATE]).isEqualTo("20260611T080000Z")
-        assertThat(inserted[CalendarContract.Events.DTSTART]).isEqualTo(occurrenceMillis)
-        // The parent keeps its own anchor and rule — only this occurrence leaves.
-        assertThat(parent[CalendarContract.Events.DTSTART]).isEqualTo(1_780_560_000_000L)
-        assertThat(parent[CalendarContract.Events.RRULE]).isEqualTo("FREQ=WEEKLY")
-    }
 }
--- a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/FakeCalendarDataSource.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/FakeCalendarDataSource.kt
@@ -23,7 +23,6 @@ internal class FakeCalendarDataSource : CalendarDataSource {
    var searchResult: (String) -> List<SearchCandidate> = { _ -> emptyList() }
    var eventDetailResult: (Long) -> EventDetail? = { null }
    var eventColorPaletteResult: (Long) -> List<EventColorOption> = { emptyList() }
-    var publishedEventColorsResult: (Long) -> List<EventColorOption> = { emptyList() }
    var exportableEventsResult: List<IcsEvent> = emptyList()
    /** The [calendarIds] the last [exportableEvents] call received (null = all). */
    var lastExportableEventsCalendarIds: Set<Long>? = null
@@ -82,12 +81,7 @@ internal class FakeCalendarDataSource : CalendarDataSource {
        eventDetailResult(eventId)
    override fun eventColorPalette(calendarId: Long): List<EventColorOption> =
        eventColorPaletteResult(calendarId)
-    override fun publishedEventColors(calendarId: Long): List<EventColorOption> =
-        publishedEventColorsResult(calendarId)
-    override fun exportableEvents(
-        calendarIds: Set<Long>?,
-        allDayReminderTimeMinutes: Int,
-    ): List<IcsEvent> {
+    override fun exportableEvents(calendarIds: Set<Long>?): List<IcsEvent> {
        lastExportableEventsCalendarIds = calendarIds
        return exportableEventsResult
    }
@@ -97,21 +91,8 @@ internal class FakeCalendarDataSource : CalendarDataSource {
    /** (event, targetCalendarId) pairs passed to [insertImportedEvent]. */
    val importedEvents = mutableListOf<Pair<ParsedIcsEvent, Long>>()

-    /** Thrown instead of [writeError] for events whose summary is in this set. */
-    val failingImportSummaries = mutableSetOf<String>()
-
-    /** The [colorPalette] the last [insertImportedEvent] call received. */
-    var lastImportPalette: List<EventColorOption> = emptyList()
-
-    override fun insertImportedEvent(
-        event: ParsedIcsEvent,
-        calendarId: Long,
-        allDayReminderTimeMinutes: Int,
-        colorPalette: List<EventColorOption>,
-    ): Long {
-        lastImportPalette = colorPalette
+    override fun insertImportedEvent(event: ParsedIcsEvent, calendarId: Long): Long {
        writeError?.let { throw it }
-        if (event.summary in failingImportSummaries) error("rejected: ${event.summary}")
        importedEvents += event to calendarId
        return nextInsertId
    }
--- a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/IcsExportMapperTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/IcsExportMapperTest.kt
@@ -4,7 +4,6 @@ import android.provider.CalendarContract
 import com.google.common.truth.Truth.assertThat
 import de.jeanlucmakiola.calendula.domain.EventStatus
 import org.junit.jupiter.api.Test
-import java.time.ZoneId

 class IcsExportMapperTest {

@@ -21,11 +20,7 @@ class IcsExportMapperTest {
            EventExportProjection.IDX_AVAILABILITY to CalendarContract.Events.AVAILABILITY_BUSY,
        )

-        val event = reader.toIcsEvent(
-            reminderMinutes = listOf(10),
-            calendarName = "Personal",
-            allDayReminderTimeMinutes = NINE_AM,
-        )
+        val event = reader.toIcsEvent(reminderMinutes = listOf(10), calendarName = "Personal")

        assertThat(event.uid).isEqualTo("abc@host")
        assertThat(event.summary).isEqualTo("Standup")
@@ -52,11 +47,7 @@ class IcsExportMapperTest {
            EventExportProjection.IDX_EVENT_TIMEZONE to "UTC",
        )

-        val event = reader.toIcsEvent(
-            reminderMinutes = emptyList(),
-            calendarName = null,
-            allDayReminderTimeMinutes = NINE_AM,
-        )
+        val event = reader.toIcsEvent(reminderMinutes = emptyList(), calendarName = null)

        assertThat(event.uid).isEqualTo("7-1000000@calendula")
        assertThat(event.recurrenceRule).isEqualTo("FREQ=WEEKLY")
@@ -74,98 +65,6 @@ class IcsExportMapperTest {
            EventExportProjection.IDX_EVENT_TIMEZONE to "UTC",
        )

-        assertThat(reader.toIcsEvent(emptyList(), null, NINE_AM).isAllDay).isTrue()
-    }
-
-    @Test
-    fun `an all-day reminder is exported as its whole-day lead time`() {
-        // The raw offset encodes the firing time and is normally negative; left
-        // raw it would be written as a trigger after the event and dropped, so
-        // the backup would come back with no reminder at all.
-        val reader = MapColumnReader(
-            EventExportProjection.IDX_ID to 1L,
-            EventExportProjection.IDX_TITLE to "Anna Birthday",
-            EventExportProjection.IDX_DTSTART to 1_782_864_000_000L, // 2026-07-01 UTC, CEST
-            EventExportProjection.IDX_DTEND to 1_782_950_400_000L,
-            EventExportProjection.IDX_ALL_DAY to 1,
-            EventExportProjection.IDX_EVENT_TIMEZONE to "UTC",
-        )
-
-        val onTheDay = reader.toIcsEvent(listOf(-420), null, NINE_AM, BERLIN)
-        val dayBefore = reader.toIcsEvent(listOf(1_020), null, NINE_AM, BERLIN)
-
-        assertThat(onTheDay.reminderMinutes).containsExactly(0)
-        assertThat(dayBefore.reminderMinutes).containsExactly(1_440)
-    }
-
-    private companion object {
-        const val NINE_AM = 9 * 60
-        val BERLIN: ZoneId = ZoneId.of("Europe/Berlin")
-    }
-
-    @Test
-    fun `a recurring row carries its EXDATE exclusions`() {
-        val reader = MapColumnReader(
-            EventExportProjection.IDX_ID to 7L,
-            EventExportProjection.IDX_TITLE to "Weekly",
-            EventExportProjection.IDX_DTSTART to 1_000_000L,
-            EventExportProjection.IDX_DURATION to "P3600S",
-            EventExportProjection.IDX_ALL_DAY to 0,
-            EventExportProjection.IDX_RRULE to "FREQ=WEEKLY",
-            EventExportProjection.IDX_EXDATE to "20260901T080000Z,20260908T080000Z",
-            EventExportProjection.IDX_EVENT_TIMEZONE to "UTC",
-        )
-
-        val event = reader.toIcsEvent(
-            reminderMinutes = emptyList(),
-            calendarName = null,
-            allDayReminderTimeMinutes = NINE_AM,
-        )
-
-        assertThat(event.exDates)
-            .containsExactly("20260901T080000Z", "20260908T080000Z").inOrder()
-    }
-
-    @Test
-    fun `an all-day EXDATE keeps only the day, however the adapter padded it`() {
-        val reader = MapColumnReader(
-            EventExportProjection.IDX_ID to 8L,
-            EventExportProjection.IDX_TITLE to "Holiday",
-            EventExportProjection.IDX_DTSTART to 0L,
-            EventExportProjection.IDX_DURATION to "P1D",
-            EventExportProjection.IDX_ALL_DAY to 1,
-            EventExportProjection.IDX_RRULE to "FREQ=YEARLY",
-            EventExportProjection.IDX_EXDATE to "20260901,20270901T000000Z",
-            EventExportProjection.IDX_EVENT_TIMEZONE to "UTC",
-        )
-
-        val event = reader.toIcsEvent(
-            reminderMinutes = emptyList(),
-            calendarName = null,
-            allDayReminderTimeMinutes = NINE_AM,
-        )
-
-        assertThat(event.exDates).containsExactly("20260901", "20270901").inOrder()
-    }
-
-    @Test
-    fun `a one-off row exports no exclusions even if the column is set`() {
-        val reader = MapColumnReader(
-            EventExportProjection.IDX_ID to 9L,
-            EventExportProjection.IDX_TITLE to "Standup",
-            EventExportProjection.IDX_DTSTART to 1_000_000L,
-            EventExportProjection.IDX_DTEND to 1_900_000L,
-            EventExportProjection.IDX_ALL_DAY to 0,
-            EventExportProjection.IDX_EXDATE to "20260901T080000Z",
-            EventExportProjection.IDX_EVENT_TIMEZONE to "UTC",
-        )
-
-        val event = reader.toIcsEvent(
-            reminderMinutes = emptyList(),
-            calendarName = null,
-            allDayReminderTimeMinutes = NINE_AM,
-        )
-
-        assertThat(event.exDates).isEmpty()
+        assertThat(reader.toIcsEvent(emptyList(), null).isAllDay).isTrue()
    }
 }
--- a/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/ImportedEventValuesTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/data/calendar/ImportedEventValuesTest.kt
@@ -1,119 +0,0 @@
-package de.jeanlucmakiola.calendula.data.calendar
-
-import android.provider.CalendarContract
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.domain.EventColorOption
-import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
-import org.junit.jupiter.api.Test
-import kotlin.time.Instant
-
-class ImportedEventValuesTest {
-
-    private val dayStart = Instant.parse("2026-08-19T00:00:00Z")
-
-    private fun allDay(
-        rrule: String? = null,
-        exDates: List<String> = emptyList(),
-        color: Int? = null,
-        days: Int = 1,
-    ) = ParsedIcsEvent(
-        uid = "u@x",
-        summary = "Anna Birthday",
-        start = dayStart,
-        end = Instant.fromEpochMilliseconds(dayStart.toEpochMilliseconds() + days * 86_400_000L),
-        isAllDay = true,
-        zoneId = "UTC",
-        recurrenceRule = rrule,
-        exDates = exDates,
-        color = color,
-    )
-
-    private fun values(event: ParsedIcsEvent, palette: List<EventColorOption> = emptyList()) =
-        buildImportedEventValues(event, calendarId = 7L, uid = "u@x", palette = palette)
-
-    @Test
-    fun `a one-off carries DTEND and no recurrence`() {
-        val v = values(allDay())
-        assertThat(v[CalendarContract.Events.DTEND])
-            .isEqualTo(dayStart.toEpochMilliseconds() + 86_400_000L)
-        assertThat(v).doesNotContainKey(CalendarContract.Events.DURATION)
-        assertThat(v[CalendarContract.Events.ALL_DAY]).isEqualTo(1)
-        assertThat(v[CalendarContract.Events.EVENT_TIMEZONE]).isEqualTo("UTC")
-    }
-
-    @Test
-    fun `a recurring row carries DURATION instead of DTEND`() {
-        val v = values(allDay(rrule = "FREQ=YEARLY;INTERVAL=1"))
-        assertThat(v).doesNotContainKey(CalendarContract.Events.DTEND)
-        assertThat(v[CalendarContract.Events.RRULE]).isEqualTo("FREQ=YEARLY;INTERVAL=1")
-        assertThat(v[CalendarContract.Events.DURATION]).isEqualTo("P1D")
-    }
-
-    @Test
-    fun `an all-day series is never zero days long`() {
-        // A degenerate span would expand into no instances at all — the series
-        // would simply not exist (Codeberg #225).
-        val v = values(allDay(rrule = "FREQ=YEARLY;INTERVAL=1", days = 0))
-        assertThat(v[CalendarContract.Events.DURATION]).isEqualTo("P1D")
-    }
-
-    @Test
-    fun `EXDATEs ride along with the recurrence`() {
-        val v = values(allDay(rrule = "FREQ=DAILY", exDates = listOf("20260820", "20260822")))
-        assertThat(v[CalendarContract.Events.EXDATE]).isEqualTo("20260820,20260822")
-    }
-
-    @Test
-    fun `EXDATEs are not written without a recurrence to exclude from`() {
-        val v = values(allDay(exDates = listOf("20260820")))
-        assertThat(v).doesNotContainKey(CalendarContract.Events.EXDATE)
-    }
-
-    @Test
-    fun `an imported colour is written raw when the account publishes no palette`() {
-        val v = values(allDay(color = -2818048))
-        assertThat(v[CalendarContract.Events.EVENT_COLOR]).isEqualTo(-2818048)
-        assertThat(v[CalendarContract.Events.EVENT_COLOR_KEY]).isNull()
-    }
-
-    @Test
-    fun `an imported colour snaps to the nearest published palette key`() {
-        val palette = listOf(
-            EventColorOption(key = "1", argb = 0xFF0000FF.toInt()), // blue
-            EventColorOption(key = "2", argb = 0xFFFF4500.toInt()), // orangered
-            EventColorOption(key = "3", argb = 0xFF008000.toInt()), // green
-        )
-        // Tomato — visually an orangered, nothing like the blue or the green.
-        val v = values(allDay(color = 0xFFFF6347.toInt()), palette)
-
-        assertThat(v[CalendarContract.Events.EVENT_COLOR_KEY]).isEqualTo("2")
-        // A raw colour alongside a key is what a palette calendar rejects.
-        assertThat(v).doesNotContainKey(CalendarContract.Events.EVENT_COLOR)
-    }
-
-    @Test
-    fun `an event with no colour touches neither colour column`() {
-        val v = values(allDay())
-        assertThat(v).doesNotContainKey(CalendarContract.Events.EVENT_COLOR)
-        assertThat(v).doesNotContainKey(CalendarContract.Events.EVENT_COLOR_KEY)
-    }
-
-    @Test
-    fun `a timed event keeps its own zone and a seconds duration`() {
-        val start = Instant.parse("2026-08-19T08:00:00Z")
-        val event = ParsedIcsEvent(
-            uid = "u@x",
-            summary = "Standup",
-            start = start,
-            end = Instant.parse("2026-08-19T08:15:00Z"),
-            isAllDay = false,
-            zoneId = "Europe/Berlin",
-            recurrenceRule = "FREQ=WEEKLY",
-        )
-
-        val v = values(event)
-        assertThat(v[CalendarContract.Events.EVENT_TIMEZONE]).isEqualTo("Europe/Berlin")
-        assertThat(v[CalendarContract.Events.DURATION]).isEqualTo("P900S")
-        assertThat(v[CalendarContract.Events.ALL_DAY]).isEqualTo(0)
-    }
-}
--- a/app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsColorTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsColorTest.kt
@@ -1,40 +0,0 @@
-package de.jeanlucmakiola.calendula.domain.ics
-
-import com.google.common.truth.Truth.assertThat
-import org.junit.jupiter.api.Test
-
-class IcsColorTest {
-
-    @Test
-    fun `a raw Android colour int round-trips`() {
-        assertThat(parseIcsColorValue("-2818048")).isEqualTo(-2818048)
-    }
-
-    @Test
-    fun `a CSS3 name resolves opaque`() {
-        assertThat(parseIcsColorValue("tomato")).isEqualTo(0xFFFF6347.toInt())
-        assertThat(parseIcsColorValue("REBECCAPURPLE")).isEqualTo(0xFF663399.toInt())
-    }
-
-    @Test
-    fun `hex forms are accepted with and without alpha`() {
-        assertThat(parseIcsColorValue("#ff6347")).isEqualTo(0xFFFF6347.toInt())
-        assertThat(parseIcsColorValue("#80ff6347")).isEqualTo(0x80FF6347.toInt())
-    }
-
-    @Test
-    fun `a colour with no alpha byte is made opaque`() {
-        // 0x00FF6347 as a decimal int — an RGB triple that lost its alpha.
-        assertThat(parseIcsColorValue("16737095")).isEqualTo(0xFFFF6347.toInt())
-    }
-
-    @Test
-    fun `unusable values resolve to null`() {
-        assertThat(parseIcsColorValue(null)).isNull()
-        assertThat(parseIcsColorValue("")).isNull()
-        // Fossify interpolates a nullable calendar straight into the property.
-        assertThat(parseIcsColorValue("null")).isNull()
-        assertThat(parseIcsColorValue("chartreusey")).isNull()
-        assertThat(parseIcsColorValue("#abc")).isNull()
-    }
-}
--- a/app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsFossifyImportTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsFossifyImportTest.kt
@@ -1,586 +0,0 @@
-package de.jeanlucmakiola.calendula.domain.ics
-
-import com.google.common.truth.Truth.assertThat
-import kotlinx.datetime.TimeZone
-import org.junit.jupiter.api.Test
-import kotlin.time.Instant
-
-/**
- * Reading the Simple Calendar / Fossify export dialect (Codeberg #225).
- *
- * Every fixture is shaped as `IcsExporter.writeEvent` emits it — property order,
- * the `X-FOSSIFY-*` extensions and the `P0DT1H5M0S` duration spelling included.
- *
- * Their all-day `DTEND` is *usually* RFC-correct and must not be "corrected":
- * `Event.endTS` anchors a UI-created all-day event at noon of its last day
- * (`EventActivity.getStartEndTimes`), or at the exclusive midnight for a
- * CalDAV-sourced one, and the exporter's `+ TWELVE_HOURS` rounds either to the
- * following midnight. Shifting those by a day would corrupt them.
- *
- * The exception — and the whole of #225 — is events mirrored from Contacts.
- * `MainActivity` builds those with `startTS = endTS = timestamp`, so `+ 12h`
- * lands back on the starting day and they export zero length.
- */
-class IcsFossifyImportTest {
-
-    private val parser = IcsParser(TimeZone.of("Europe/Berlin"))
-
-    private fun fossify(vararg body: String) = (
-        listOf(
-            "BEGIN:VCALENDAR",
-            "PRODID:-//Fossify//NONSGML Event Calendar//EN",
-            "VERSION:2.0",
-        ) + body + listOf("END:VCALENDAR")
-        ).joinToString("\r\n")
-
-    private fun days(event: ParsedIcsEvent): Long =
-        (event.end - event.start).inWholeMilliseconds / 86_400_000L
-
-    @Test
-    fun `an all-day event keeps the exact span the file gives it`() {
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Anna Birthday",
-                "UID:abc123",
-                "X-FOSSIFY-CATEGORY-COLOR:-1155931",
-                "DTSTART;VALUE=DATE:19900412",
-                "DTEND;VALUE=DATE:19900413",
-                "X-FOSSIFY-MISSING-YEAR:0",
-                "RRULE:FREQ=YEARLY;INTERVAL=1;BYMONTH=4",
-                "END:VEVENT",
-            ),
-        )
-
-        val event = result.events.single()
-        assertThat(event.isAllDay).isTrue()
-        assertThat(days(event)).isEqualTo(1)
-    }
-
-    @Test
-    fun `contact-mirrored birthdays export zero length and must not vanish`() {
-        // The reported failure (#225). Fossify mirrors Contacts birthdays and
-        // anniversaries with startTS == endTS, so the exporter's +12h rounds
-        // back to the starting day: DTSTART == DTEND. Read literally these are
-        // yearly series of zero-length occurrences, which the provider expands
-        // into nothing at all — the birthdays import "successfully" and are
-        // then nowhere to be seen.
-        val text = checkNotNull(
-            javaClass.classLoader?.getResourceAsStream("ics/fossify-contact-birthdays.ics"),
-        ).use { it.readBytes().toString(Charsets.UTF_8) }
-
-        val result = parser.parse(text)
-
-        assertThat(result.events).hasSize(3)
-        result.events.forEach {
-            assertThat(it.isAllDay).isTrue()
-            assertThat(days(it)).isEqualTo(1)
-            assertThat(it.recurrenceRule).startsWith("FREQ=YEARLY")
-            // Their all-day reminder encoding: "on the day", not midnight UTC.
-            assertThat(it.semanticReminderMinutes()).containsExactly(0)
-        }
-    }
-
-    @Test
-    fun `a real Fossify holiday file imports unchanged`() {
-        // Shipped inside Fossify Calendar (assets/holidays/AT/public.ics). Its
-        // PRODID names Fossify, so any producer-sniffing shortcut would corrupt
-        // it — the file is plain, conformant iCalendar.
-        val text = checkNotNull(
-            javaClass.classLoader?.getResourceAsStream("ics/fossify-holidays-at.ics"),
-        ).use { it.readBytes().toString(Charsets.UTF_8) }
-
-        val result = parser.parse(text)
-
-        assertThat(result.events.map { it.summary })
-            .containsExactly("Neujahr", "Heilige Drei Könige").inOrder()
-        assertThat(result.events.map { days(it) }).containsExactly(1L, 1L)
-        assertThat(result.events.map { it.recurrenceRule }).containsExactly("FREQ=YEARLY", "FREQ=YEARLY")
-    }
-
-    @Test
-    fun `an all-day event with no DTEND lasts one day`() {
-        // RFC 5545 3.6.1, and the span the provider needs to expand a series.
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Holiday",
-                "DTSTART;VALUE=DATE:20260819",
-                "END:VEVENT",
-            ),
-        )
-
-        assertThat(days(result.events.single())).isEqualTo(1)
-    }
-
-    @Test
-    fun `a zero-length all-day event is widened rather than left to vanish`() {
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Holiday",
-                "DTSTART;VALUE=DATE:20260819",
-                "DTEND;VALUE=DATE:20260819",
-                "END:VEVENT",
-            ),
-        )
-
-        assertThat(days(result.events.single())).isEqualTo(1)
-    }
-
-    @Test
-    fun `a malformed repeat rule is repaired rather than passed to the provider`() {
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Standup",
-                "DTSTART:20260819T080000Z",
-                "DTEND:20260819T081500Z",
-                "RRULE:FREQ=WEEKLY;INTERVAL=1;BYDAY=",
-                "END:VEVENT",
-            ),
-        )
-
-        assertThat(result.events.single().recurrenceRule).isEqualTo("FREQ=WEEKLY;INTERVAL=1")
-        assertThat(result.warnings).contains(IcsParseWarning.RecurrenceRuleRepaired)
-    }
-
-    @Test
-    fun `a task is imported as an event and reported`() {
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VTODO",
-                "SUMMARY:Pay rent",
-                "DTSTART;VALUE=DATE:20260901",
-                "END:VTODO",
-            ),
-        )
-
-        val task = result.events.single()
-        assertThat(task.isTask).isTrue()
-        assertThat(task.summary).isEqualTo("Pay rent")
-        assertThat(days(task)).isEqualTo(1)
-        assertThat(result.warnings).contains(IcsParseWarning.TasksImportedAsEvents)
-    }
-
-    @Test
-    fun `a task dated only by DUE still imports`() {
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VTODO",
-                "SUMMARY:File taxes",
-                "DUE;VALUE=DATE:20260901",
-                "END:VTODO",
-            ),
-        )
-
-        assertThat(result.events.single().summary).isEqualTo("File taxes")
-    }
-
-    @Test
-    fun `a task with both DTSTART and DUE spans between them`() {
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VTODO",
-                "SUMMARY:Write report",
-                "DTSTART:20260901T090000Z",
-                "DUE:20260901T170000Z",
-                "END:VTODO",
-            ),
-        )
-
-        val task = result.events.single()
-        assertThat(task.start).isEqualTo(Instant.parse("2026-09-01T09:00:00Z"))
-        assertThat(task.end).isEqualTo(Instant.parse("2026-09-01T17:00:00Z"))
-    }
-
-    @Test
-    fun `a DUE ahead of the DTSTART is still the end`() {
-        // Property order isn't guaranteed; DUE must not be taken for the start.
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VTODO",
-                "SUMMARY:Write report",
-                "DUE:20260901T170000Z",
-                "DTSTART:20260901T090000Z",
-                "END:VTODO",
-            ),
-        )
-
-        val task = result.events.single()
-        assertThat(task.start).isEqualTo(Instant.parse("2026-09-01T09:00:00Z"))
-        assertThat(task.end).isEqualTo(Instant.parse("2026-09-01T17:00:00Z"))
-    }
-
-    @Test
-    fun `the per-event colour wins over the calendar colour`() {
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Holiday",
-                "X-FOSSIFY-CATEGORY-COLOR:-1155931",
-                "COLOR:tomato",
-                "X-FOSSIFY-EVENT-COLOR:-2818048",
-                "DTSTART:20260819T080000Z",
-                "DTEND:20260819T090000Z",
-                "END:VEVENT",
-            ),
-        )
-
-        assertThat(result.events.single().color).isEqualTo(-2818048)
-    }
-
-    @Test
-    fun `the calendar colour stands in when the event has none of its own`() {
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Holiday",
-                "X-FOSSIFY-CATEGORY-COLOR:-1155931",
-                "DTSTART:20260819T080000Z",
-                "DTEND:20260819T090000Z",
-                "END:VEVENT",
-            ),
-        )
-
-        assertThat(result.events.single().color).isEqualTo(-1155931)
-    }
-
-    @Test
-    fun `the legacy Simple Calendar colour spellings are read too`() {
-        val result = parser.parse(
-            listOf(
-                "BEGIN:VCALENDAR",
-                "PRODID:-//Simple Mobile Tools//NONSGML Event Calendar//EN",
-                "BEGIN:VEVENT",
-                "SUMMARY:Holiday",
-                "X-SMT-CATEGORY-COLOR:-1155931",
-                "DTSTART:20260819T080000Z",
-                "DTEND:20260819T090000Z",
-                "END:VEVENT",
-                "END:VCALENDAR",
-            ).joinToString("\r\n"),
-        )
-
-        assertThat(result.events.single().color).isEqualTo(-1155931)
-    }
-
-    @Test
-    fun `the literal null Fossify writes for a missing calendar is not a colour`() {
-        // Both properties interpolate a nullable calendar straight into the value.
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Holiday",
-                "X-FOSSIFY-CATEGORY-COLOR:null",
-                "CATEGORIES:null",
-                "DTSTART:20260819T080000Z",
-                "DTEND:20260819T090000Z",
-                "END:VEVENT",
-            ),
-        )
-
-        val event = result.events.single()
-        assertThat(event.color).isNull()
-        assertThat(event.calendarName).isNull()
-    }
-
-    @Test
-    fun `CATEGORIES names the source calendar`() {
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Anna Birthday",
-                "CATEGORIES:Birthdays",
-                "DTSTART;VALUE=DATE:20260819",
-                "DTEND;VALUE=DATE:20260820",
-                "END:VEVENT",
-            ),
-        )
-
-        assertThat(result.events.single().calendarName).isEqualTo("Birthdays")
-    }
-
-    @Test
-    fun `CATEGORIES does not outrank a property that names the calendar outright`() {
-        // Elsewhere CATEGORIES is a tag list, so it only stands in where nothing
-        // else named the calendar — X-WR-CALNAME and our own label win.
-        val result = IcsParser().parse(
-            listOf(
-                "BEGIN:VCALENDAR",
-                "X-WR-CALNAME:Work",
-                "BEGIN:VEVENT",
-                "SUMMARY:Standup",
-                "CATEGORIES:Holiday",
-                "DTSTART:20260819T080000Z",
-                "DTEND:20260819T090000Z",
-                "END:VEVENT",
-                "END:VCALENDAR",
-            ).joinToString("\r\n"),
-        )
-
-        assertThat(result.events.single().calendarName).isEqualTo("Work")
-    }
-
-    @Test
-    fun `a multi-valued CATEGORIES is a tag list, not a calendar name`() {
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Standup",
-                "CATEGORIES:Meeting,Personal",
-                "DTSTART:20260819T080000Z",
-                "DTEND:20260819T090000Z",
-                "END:VEVENT",
-            ),
-        )
-
-        assertThat(result.events.single().calendarName).isNull()
-    }
-
-    @Test
-    fun `a reminder written as a positive trigger is not read as a lead time`() {
-        // The exporter flips the sign for reminders stored below -1
-        // (`sign = if (reminder.minutes < -1) "" else "-"`), so a trigger can
-        // point after the start. On an all-day event that means a time of day.
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Anna Birthday",
-                "DTSTART;VALUE=DATE:20260819",
-                "DTEND;VALUE=DATE:20260820",
-                "BEGIN:VALARM",
-                "ACTION:DISPLAY",
-                "TRIGGER:P0DT9H0M0S",
-                "END:VALARM",
-                "END:VEVENT",
-            ),
-        )
-
-        val event = result.events.single()
-        assertThat(event.reminderMinutes).containsExactly(-540)
-        assertThat(event.semanticReminderMinutes()).containsExactly(0)
-    }
-
-    @Test
-    fun `an all-day reminder whose firing time is after noon keeps its full day`() {
-        // The raw offset is `days * 1440 - timeOfDay`, so an 18:00 notification
-        // time puts "1 day before" only six hours ahead of the UTC midnight.
-        // Rounding to the nearest day would read that as "on the day".
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Anna Birthday",
-                "DTSTART;VALUE=DATE:20260819",
-                "DTEND;VALUE=DATE:20260820",
-                "BEGIN:VALARM",
-                "ACTION:DISPLAY",
-                "TRIGGER:-P0DT6H0M0S",
-                "END:VALARM",
-                "END:VEVENT",
-            ),
-        )
-
-        assertThat(result.events.single().semanticReminderMinutes()).containsExactly(1440)
-    }
-
-    @Test
-    fun `an all-day reminder rounds to whole days before`() {
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Anna Birthday",
-                "DTSTART;VALUE=DATE:20260819",
-                "DTEND;VALUE=DATE:20260820",
-                "BEGIN:VALARM",
-                "ACTION:DISPLAY",
-                // 15h before midnight == "1 day before at 09:00".
-                "TRIGGER:-P0DT15H0M0S",
-                "END:VALARM",
-                "END:VEVENT",
-            ),
-        )
-
-        assertThat(result.events.single().semanticReminderMinutes()).containsExactly(1440)
-    }
-
-    @Test
-    fun `a timed reminder keeps its exact lead time`() {
-        // Their P0DT1H5M0S duration spelling, from Parser.getDurationCode.
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Standup",
-                "DTSTART:20260819T080000Z",
-                "DTEND:20260819T081500Z",
-                "BEGIN:VALARM",
-                "ACTION:DISPLAY",
-                "TRIGGER:-P0DT0H10M0S",
-                "END:VALARM",
-                "END:VEVENT",
-            ),
-        )
-
-        assertThat(result.events.single().semanticReminderMinutes()).containsExactly(10)
-    }
-
-    @Test
-    fun `a timed trigger that fires after the start is dropped, not clamped`() {
-        // A legal RFC 5545 follow-up alarm. Modelling it as a lead time of zero
-        // would invent a notification at the start the file never asked for.
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Standup",
-                "DTSTART:20260819T080000Z",
-                "DTEND:20260819T081500Z",
-                "BEGIN:VALARM",
-                "ACTION:DISPLAY",
-                "TRIGGER:PT30M",
-                "END:VALARM",
-                "END:VEVENT",
-            ),
-        )
-
-        assertThat(result.events.single().semanticReminderMinutes()).isEmpty()
-    }
-
-    @Test
-    fun `an all-day series' EXDATE day codes carry over`() {
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Standup",
-                "DTSTART;VALUE=DATE:20260819",
-                "DTEND;VALUE=DATE:20260820",
-                "RRULE:FREQ=DAILY;INTERVAL=1",
-                "EXDATE:20260820",
-                "EXDATE:20260822",
-                "END:VEVENT",
-            ),
-        )
-
-        assertThat(result.events.single().exDates).containsExactly("20260820", "20260822").inOrder()
-    }
-
-    @Test
-    fun `an all-day EXDATE keeps the day it spells out, whatever zone it carries`() {
-        // A midnight east of UTC resolves to an instant on the previous day;
-        // reading that back in UTC would exclude a day that isn't an occurrence
-        // and leave the one the user deleted in place.
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Standup",
-                "DTSTART;VALUE=DATE:20260819",
-                "DTEND;VALUE=DATE:20260820",
-                "RRULE:FREQ=DAILY",
-                "EXDATE;TZID=Europe/Berlin:20260821T000000",
-                "EXDATE;VALUE=DATE:20260823",
-                "END:VEVENT",
-            ),
-        )
-
-        assertThat(result.events.single().exDates)
-            .containsExactly("20260821", "20260823").inOrder()
-    }
-
-    @Test
-    fun `a timed series' bare EXDATE day code is resolved against the series time`() {
-        // They store excluded occurrences as day codes and write them out that
-        // way even for a timed series, where the property alone is ambiguous.
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Gym",
-                "DTSTART:20260819T170000Z",
-                "DTEND:20260819T180000Z",
-                "RRULE:FREQ=DAILY;INTERVAL=1",
-                "EXDATE:20260820",
-                "END:VEVENT",
-            ),
-        )
-
-        assertThat(result.events.single().exDates).containsExactly("20260820T170000Z")
-    }
-
-    @Test
-    fun `a floating EXDATE is read in the series' zone, not the device's`() {
-        // RFC 5545 ties EXDATE to DTSTART's form: with no Z and no TZID the
-        // value is New York wall time. Reading it in the device's Berlin zone
-        // would land on an instant no occurrence has, and the excluded
-        // occurrence would come back.
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Standup",
-                "DTSTART;TZID=America/New_York:20260819T100000",
-                "DTEND;TZID=America/New_York:20260819T103000",
-                "RRULE:FREQ=WEEKLY",
-                "EXDATE:20260826T100000",
-                "END:VEVENT",
-            ),
-        )
-
-        assertThat(result.events.single().exDates).containsExactly("20260826T140000Z")
-    }
-
-    @Test
-    fun `EXDATE is dropped along with an unusable recurrence rule`() {
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Gym",
-                "DTSTART:20260819T170000Z",
-                "DTEND:20260819T180000Z",
-                "RRULE:INTERVAL=1",
-                "EXDATE:20260820",
-                "END:VEVENT",
-            ),
-        )
-
-        val event = result.events.single()
-        assertThat(event.recurrenceRule).isNull()
-        assertThat(event.exDates).isEmpty()
-    }
-
-    @Test
-    fun `a whole export imports every component`() {
-        val result = parser.parse(
-            fossify(
-                "BEGIN:VEVENT",
-                "SUMMARY:Anna Birthday",
-                "UID:abc123",
-                "X-FOSSIFY-CATEGORY-COLOR:-1155931",
-                "CATEGORIES:Birthdays",
-                "LAST-MODIFIED:20260101T120000Z",
-                "TRANSP:TRANSPARENT",
-                "DTSTART;VALUE=DATE:19900412",
-                "DTEND;VALUE=DATE:19900413",
-                "X-FOSSIFY-MISSING-YEAR:0",
-                "DTSTAMP:20260819T100000Z",
-                "CLASS:PUBLIC",
-                "STATUS:CONFIRMED",
-                "RRULE:FREQ=YEARLY;INTERVAL=1;BYMONTH=4",
-                "END:VEVENT",
-                "BEGIN:VEVENT",
-                "SUMMARY:Standup",
-                "UID:def456",
-                "DTSTART:20260819T080000Z",
-                "DTEND:20260819T081500Z",
-                "RRULE:FREQ=WEEKLY;INTERVAL=1;BYDAY=TU",
-                "END:VEVENT",
-                "BEGIN:VTODO",
-                "SUMMARY:Pay rent",
-                "UID:ghi789",
-                "DTSTART;VALUE=DATE:20260901",
-                "END:VTODO",
-            ),
-        )
-
-        assertThat(result.events.map { it.summary })
-            .containsExactly("Anna Birthday", "Standup", "Pay rent").inOrder()
-        // Nothing may reach the provider as a zero-length all-day row.
-        assertThat(result.events.none { it.isAllDay && days(it) == 0L }).isTrue()
-    }
-}
--- a/app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsParserTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsParserTest.kt
@@ -165,36 +165,4 @@ class IcsParserTest {
        assertThat(result.events.map { it.uid }).containsExactly("good")
        assertThat(result.warnings).contains(IcsParseWarning.EventWithoutStartSkipped)
    }
-
-    @Test
-    fun `round-trips a timed series' deleted occurrences`() {
-        val event = IcsEvent(
-            uid = "u20@calendula",
-            summary = "Weekly",
-            start = instantUtc(2026, 6, 18, 13, 0),
-            end = instantUtc(2026, 6, 18, 13, 30),
-            isAllDay = false,
-            zoneId = "UTC",
-            recurrenceRule = "FREQ=WEEKLY",
-            exDates = listOf("20260625T130000Z"),
-        )
-
-        assertThat(roundTrip(event).exDates).containsExactly("20260625T130000Z")
-    }
-
-    @Test
-    fun `round-trips an all-day series' deleted occurrences`() {
-        val event = IcsEvent(
-            uid = "u21@calendula",
-            summary = "Holiday",
-            start = LocalDate(2026, 6, 18).atStartOfDayIn(TimeZone.UTC),
-            end = LocalDate(2026, 6, 19).atStartOfDayIn(TimeZone.UTC),
-            isAllDay = true,
-            zoneId = "UTC",
-            recurrenceRule = "FREQ=YEARLY",
-            exDates = listOf("20270618"),
-        )
-
-        assertThat(roundTrip(event).exDates).containsExactly("20270618")
-    }
 }
--- a/app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsRecurrenceTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsRecurrenceTest.kt
@@ -1,166 +0,0 @@
-package de.jeanlucmakiola.calendula.domain.ics
-
-import com.google.common.truth.Truth.assertThat
-import org.junit.jupiter.api.Test
-
-class IcsRecurrenceTest {
-
-    @Test
-    fun `a well-formed rule is unchanged`() {
-        val result = sanitizeRrule("FREQ=WEEKLY;INTERVAL=2;BYDAY=MO,WE")
-
-        assertThat(result.rule).isEqualTo("FREQ=WEEKLY;INTERVAL=2;BYDAY=MO,WE")
-        assertThat(result.repaired).isFalse()
-    }
-
-    @Test
-    fun `the RRULE prefix is stripped`() {
-        assertThat(sanitizeRrule("RRULE:FREQ=DAILY").rule).isEqualTo("FREQ=DAILY")
-    }
-
-    @Test
-    fun `an empty list part is dropped`() {
-        val bareByDay = sanitizeRrule("FREQ=WEEKLY;INTERVAL=1;BYDAY=")
-        assertThat(bareByDay.rule).isEqualTo("FREQ=WEEKLY;INTERVAL=1")
-        assertThat(bareByDay.repaired).isTrue()
-
-        assertThat(sanitizeRrule("FREQ=WEEKLY;BYDAY=MO,,WE;BYMONTH=").rule)
-            .isEqualTo("FREQ=WEEKLY;BYDAY=MO,WE")
-    }
-
-    @Test
-    fun `a nonsensical INTERVAL or COUNT is dropped, not fatal`() {
-        assertThat(sanitizeRrule("FREQ=DAILY;INTERVAL=0").rule).isEqualTo("FREQ=DAILY")
-        assertThat(sanitizeRrule("FREQ=DAILY;INTERVAL=every").rule).isEqualTo("FREQ=DAILY")
-        assertThat(sanitizeRrule("FREQ=DAILY;COUNT=0").rule).isEqualTo("FREQ=DAILY")
-    }
-
-    @Test
-    fun `a rule without a usable FREQ is unsalvageable`() {
-        assertThat(sanitizeRrule("INTERVAL=1;BYDAY=MO").rule).isNull()
-        assertThat(sanitizeRrule("FREQ=FORTNIGHTLY;INTERVAL=1").rule).isNull()
-        assertThat(sanitizeRrule("FREQ=;INTERVAL=1").rule).isNull()
-        assertThat(sanitizeRrule("").rule).isNull()
-        assertThat(sanitizeRrule(null).rule).isNull()
-    }
-
-    @Test
-    fun `no rule at all is not a repair`() {
-        assertThat(sanitizeRrule(null).repaired).isFalse()
-        assertThat(sanitizeRrule("").repaired).isFalse()
-        assertThat(sanitizeRrule("FREQ=FORTNIGHTLY").repaired).isTrue()
-    }
-
-    @Test
-    fun `normalising is not repairing`() {
-        // Case and a trailing separator change the text but lose nothing, and
-        // telling the user their file was faulty over either is crying wolf.
-        val lowercase = sanitizeRrule("freq=daily;count=3")
-        assertThat(lowercase.rule).isEqualTo("FREQ=DAILY;COUNT=3")
-        assertThat(lowercase.repaired).isFalse()
-
-        val trailing = sanitizeRrule("FREQ=DAILY;")
-        assertThat(trailing.rule).isEqualTo("FREQ=DAILY")
-        assertThat(trailing.repaired).isFalse()
-    }
-
-    @Test
-    fun `parts the provider's parser has no entry for are dropped`() {
-        // EventRecurrence.parse throws on any part name outside its own table,
-        // so passing one on would cost the whole event (Codeberg #225).
-        val result = sanitizeRrule("FREQ=MONTHLY;RSCALE=GREGORIAN;BYMONTHDAY=15")
-
-        assertThat(result.rule).isEqualTo("FREQ=MONTHLY;BYMONTHDAY=15")
-        assertThat(result.repaired).isTrue()
-        assertThat(sanitizeRrule("FREQ=YEARLY;X-THING=7").rule).isEqualTo("FREQ=YEARLY")
-    }
-
-    @Test
-    fun `WKST survives, a nonsense weekday does not`() {
-        assertThat(sanitizeRrule("FREQ=WEEKLY;WKST=SU").rule).isEqualTo("FREQ=WEEKLY;WKST=SU")
-        assertThat(sanitizeRrule("FREQ=WEEKLY;WKST=XX").rule).isEqualTo("FREQ=WEEKLY")
-    }
-
-    @Test
-    fun `a BYDAY item that isn't a weekday is dropped`() {
-        assertThat(sanitizeRrule("FREQ=MONTHLY;BYDAY=-1FR,1,MO").rule)
-            .isEqualTo("FREQ=MONTHLY;BYDAY=-1FR,MO")
-        assertThat(sanitizeRrule("FREQ=WEEKLY;BYDAY=mo,tu").rule)
-            .isEqualTo("FREQ=WEEKLY;BYDAY=MO,TU")
-    }
-
-    @Test
-    fun `a zero is dropped from the by-position parts only`() {
-        assertThat(sanitizeRrule("FREQ=MONTHLY;BYMONTHDAY=0,15").rule)
-            .isEqualTo("FREQ=MONTHLY;BYMONTHDAY=15")
-        assertThat(sanitizeRrule("FREQ=DAILY;BYHOUR=0,9").rule)
-            .isEqualTo("FREQ=DAILY;BYHOUR=0,9")
-    }
-
-    @Test
-    fun `an out-of-range numeric item is dropped`() {
-        // EventRecurrence.parseNumberList range-checks every one of these and
-        // throws out of insert, so being a number isn't enough (Codeberg #225).
-        assertThat(sanitizeRrule("FREQ=MONTHLY;BYMONTHDAY=15,32").rule)
-            .isEqualTo("FREQ=MONTHLY;BYMONTHDAY=15")
-        assertThat(sanitizeRrule("FREQ=DAILY;BYHOUR=25").rule).isEqualTo("FREQ=DAILY")
-        assertThat(sanitizeRrule("FREQ=YEARLY;BYMONTH=13").rule).isEqualTo("FREQ=YEARLY")
-        assertThat(sanitizeRrule("FREQ=YEARLY;BYWEEKNO=60").rule).isEqualTo("FREQ=YEARLY")
-        assertThat(sanitizeRrule("FREQ=YEARLY;BYYEARDAY=400").rule).isEqualTo("FREQ=YEARLY")
-        assertThat(sanitizeRrule("FREQ=DAILY;BYSECOND=60").rule).isEqualTo("FREQ=DAILY")
-        assertThat(sanitizeRrule("FREQ=DAILY;BYHOUR=25").repaired).isTrue()
-    }
-
-    @Test
-    fun `the edges of each range survive`() {
-        assertThat(sanitizeRrule("FREQ=MONTHLY;BYMONTHDAY=-31,31").repaired).isFalse()
-        assertThat(sanitizeRrule("FREQ=YEARLY;BYYEARDAY=-366,366;BYWEEKNO=-53,53").repaired)
-            .isFalse()
-        assertThat(sanitizeRrule("FREQ=DAILY;BYHOUR=23;BYMINUTE=59;BYSECOND=59").repaired)
-            .isFalse()
-        // BYSETPOS is the one part the provider leaves unbounded.
-        assertThat(sanitizeRrule("FREQ=MONTHLY;BYDAY=MO;BYSETPOS=-1,400").rule)
-            .isEqualTo("FREQ=MONTHLY;BYDAY=MO;BYSETPOS=-1,400")
-    }
-
-    @Test
-    fun `an UNTIL that isn't a timestamp is dropped`() {
-        assertThat(sanitizeRrule("FREQ=DAILY;UNTIL=20260819T235959Z").rule)
-            .isEqualTo("FREQ=DAILY;UNTIL=20260819T235959Z")
-        assertThat(sanitizeRrule("FREQ=DAILY;UNTIL=2026-08-19").rule).isEqualTo("FREQ=DAILY")
-    }
-
-    @Test
-    fun `UNTIL and COUNT together keep UNTIL`() {
-        // EventRecurrence.parse throws outright on a rule carrying both.
-        val both = sanitizeRrule("FREQ=WEEKLY;COUNT=10;UNTIL=20260101T000000Z")
-
-        assertThat(both.rule).isEqualTo("FREQ=WEEKLY;UNTIL=20260101T000000Z")
-        assertThat(both.repaired).isTrue()
-    }
-
-    @Test
-    fun `a COUNT the UNTIL check never sees is left alone`() {
-        // An UNTIL dropped for its shape doesn't take the COUNT down with it.
-        val staleUntil = sanitizeRrule("FREQ=WEEKLY;COUNT=10;UNTIL=2026-01-01")
-
-        assertThat(staleUntil.rule).isEqualTo("FREQ=WEEKLY;COUNT=10")
-        assertThat(staleUntil.repaired).isTrue()
-    }
-
-    @Test
-    fun `a part without a value separator is reported as repaired`() {
-        val noEquals = sanitizeRrule("FREQ=WEEKLY;BYDAY")
-
-        assertThat(noEquals.rule).isEqualTo("FREQ=WEEKLY")
-        assertThat(noEquals.repaired).isTrue()
-    }
-
-    @Test
-    fun `a trailing separator is normalisation, not a repair`() {
-        val trailing = sanitizeRrule("FREQ=DAILY;")
-
-        assertThat(trailing.rule).isEqualTo("FREQ=DAILY")
-        assertThat(trailing.repaired).isFalse()
-    }
-}
--- a/app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsWriterTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsWriterTest.kt
@@ -149,55 +149,4 @@ class IcsWriterTest {
        // Stable across calls — a re-export of the same row yields the same UID.
        assertThat(deriveIcsUid(null, 7, 1000)).isEqualTo(deriveIcsUid(null, 7, 1000))
    }
-
-    @Test
-    fun `a timed series writes its exclusions as UTC stamps`() {
-        val event = IcsEvent(
-            uid = "u9@calendula",
-            summary = "Weekly",
-            start = instantUtc(2026, 6, 18, 13, 0),
-            end = instantUtc(2026, 6, 18, 13, 30),
-            isAllDay = false,
-            zoneId = "UTC",
-            recurrenceRule = "FREQ=WEEKLY",
-            exDates = listOf("20260625T130000Z", "20260702T130000Z"),
-        )
-
-        assertThat(lines(listOf(event)))
-            .contains("EXDATE:20260625T130000Z,20260702T130000Z")
-    }
-
-    @Test
-    fun `an all-day series marks its exclusions VALUE=DATE`() {
-        val start = LocalDate(2026, 6, 18).atStartOfDayIn(TimeZone.UTC)
-        val event = IcsEvent(
-            uid = "u10@calendula",
-            summary = "Holiday",
-            start = start,
-            end = LocalDate(2026, 6, 19).atStartOfDayIn(TimeZone.UTC),
-            isAllDay = true,
-            zoneId = "UTC",
-            recurrenceRule = "FREQ=YEARLY",
-            exDates = listOf("20270618"),
-        )
-
-        // RFC 5545 ties EXDATE's value type to DTSTART's; a bare day code
-        // without VALUE=DATE reads as a malformed DATE-TIME.
-        assertThat(lines(listOf(event))).contains("EXDATE;VALUE=DATE:20270618")
-    }
-
-    @Test
-    fun `a one-off event never writes an EXDATE`() {
-        val event = IcsEvent(
-            uid = "u11@calendula",
-            summary = "Standup",
-            start = instantUtc(2026, 6, 18, 13, 0),
-            end = instantUtc(2026, 6, 18, 13, 30),
-            isAllDay = false,
-            zoneId = "UTC",
-            exDates = listOf("20260625T130000Z"),
-        )
-
-        assertThat(lines(listOf(event)).none { it.startsWith("EXDATE") }).isTrue()
-    }
 }
--- a/app/src/test/java/de/jeanlucmakiola/calendula/ui/imports/ImportTargetTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/ui/imports/ImportTargetTest.kt
@@ -1,89 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.imports
-
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
-import org.junit.jupiter.api.Test
-import kotlin.time.Instant
-
-/** Which calendar a bulk import lands on before the user touches the picker. */
-class ImportTargetTest {
-
-    private fun cal(id: Long, name: String, local: Boolean = false) = CalendarSource(
-        id = id,
-        displayName = name,
-        accountName = "acc@local",
-        accountType = if (local) "LOCAL" else "com.google",
-        color = 0,
-        isVisibleInSystem = true,
-        isLocal = local,
-    )
-
-    private val calendars = listOf(
-        cal(1L, "Work"),
-        cal(2L, "Personal", local = true),
-        cal(3L, "Birthdays", local = true),
-    )
-
-    @Test
-    fun `a calendar named like the file's wins`() {
-        assertThat(defaultImportTarget(calendars, "Birthdays")).isEqualTo(3L)
-    }
-
-    @Test
-    fun `the name match ignores case`() {
-        assertThat(defaultImportTarget(calendars, "birthdays")).isEqualTo(3L)
-    }
-
-    @Test
-    fun `an unmatched name falls back to the first local calendar`() {
-        assertThat(defaultImportTarget(calendars, "Holidays")).isEqualTo(2L)
-    }
-
-    @Test
-    fun `no name at all falls back to the first local calendar`() {
-        assertThat(defaultImportTarget(calendars, null)).isEqualTo(2L)
-    }
-
-    @Test
-    fun `with no local calendars the first of any kind is taken`() {
-        assertThat(defaultImportTarget(listOf(cal(1L, "Work")), null)).isEqualTo(1L)
-    }
-
-    @Test
-    fun `an empty list preselects nothing`() {
-        assertThat(defaultImportTarget(emptyList(), "Birthdays")).isNull()
-    }
-
-    private fun event(calendarName: String?) = ParsedIcsEvent(
-        uid = "u@x",
-        summary = "E",
-        start = Instant.fromEpochMilliseconds(0L),
-        end = Instant.fromEpochMilliseconds(3_600_000L),
-        isAllDay = false,
-        zoneId = "UTC",
-        calendarName = calendarName,
-    )
-
-    @Test
-    fun `a file whose events all name one calendar names it`() {
-        assertThat(fileCalendarName(List(3) { event("Birthdays") })).isEqualTo("Birthdays")
-    }
-
-    @Test
-    fun `disagreeing events name none`() {
-        assertThat(fileCalendarName(listOf(event("Birthdays"), event("Anniversaries")))).isNull()
-    }
-
-    @Test
-    fun `one tagged event among unnamed ones names none`() {
-        // CATEGORIES is a tag list everywhere but the Fossify family, so a lone
-        // tagged event must not decide where the whole file lands.
-        assertThat(fileCalendarName(listOf(event("Holiday")) + List(9) { event(null) })).isNull()
-    }
-
-    @Test
-    fun `a file that names nothing names none`() {
-        assertThat(fileCalendarName(List(3) { event(null) })).isNull()
-    }
-}
--- a/app/src/test/java/de/jeanlucmakiola/calendula/widget/WidgetRolloverSchedulerTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/widget/WidgetRolloverSchedulerTest.kt
@@ -1,164 +0,0 @@
-package de.jeanlucmakiola.calendula.widget
-
-import com.google.common.truth.Truth.assertThat
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.LocalDateTime
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.atStartOfDayIn
-import kotlinx.datetime.toInstant
-import kotlinx.datetime.toLocalDateTime
-import org.junit.jupiter.api.Test
-import kotlin.time.Duration
-import kotlin.time.Duration.Companion.hours
-import kotlin.time.Duration.Companion.minutes
-import kotlin.time.Instant
-
-/**
- * The rollover alarm is what makes the widgets stop highlighting yesterday
- * (#228), so the "when is the next local midnight" arithmetic is the one piece
- * worth pinning down — especially where midnight is not 00:00.
- */
-class WidgetRolloverSchedulerTest {
-
-    private val berlin = TimeZone.of("Europe/Berlin")
-
-    private fun at(local: String, zone: TimeZone): Instant =
-        LocalDateTime.parse(local).toInstant(zone)
-
-    private fun nextRollover(local: String, zone: TimeZone = berlin): Instant =
-        WidgetRolloverScheduler.nextRolloverAt(at(local, zone), zone)
-
-    // --- the ordinary day ----------------------------------------------------
-
-    @Test
-    fun `midday rolls over at the coming midnight`() {
-        val next = nextRollover("2026-08-27T12:00:00")
-        assertThat(next).isEqualTo(at("2026-08-28T00:00:05", berlin))
-    }
-
-    @Test
-    fun `a second before midnight still targets tonight, not tomorrow night`() {
-        val next = nextRollover("2026-08-27T23:59:59")
-        assertThat(next).isEqualTo(at("2026-08-28T00:00:05", berlin))
-    }
-
-    @Test
-    fun `at midnight exactly the target is the next day, never the current instant`() {
-        // Re-arming after a firing must move a whole day on, or the widget wakes
-        // itself in a tight loop.
-        val now = at("2026-08-28T00:00:00", berlin)
-        val next = WidgetRolloverScheduler.nextRolloverAt(now, berlin)
-        assertThat(next).isEqualTo(at("2026-08-29T00:00:05", berlin))
-        assertThat(next - now).isGreaterThan(Duration.ZERO)
-    }
-
-    @Test
-    fun `re-arming from the slack instant itself moves a full day on`() {
-        // What actually happens in practice: the receiver runs at midnight + slack.
-        val now = at("2026-08-28T00:00:05", berlin)
-        assertThat(WidgetRolloverScheduler.nextRolloverAt(now, berlin))
-            .isEqualTo(at("2026-08-29T00:00:05", berlin))
-    }
-
-    @Test
-    fun `the result is always in the future for every minute of a day`() {
-        val zone = berlin
-        // Spans Berlin's 2024 spring-forward: the likeliest source of a target
-        // in the past, i.e. an alarm that fires immediately, forever.
-        var probe = LocalDateTime.parse("2024-03-29T00:00:00").toInstant(zone)
-        val end = LocalDateTime.parse("2024-04-01T00:00:00").toInstant(zone)
-        while (probe < end) {
-            assertThat(WidgetRolloverScheduler.nextRolloverAt(probe, zone)).isGreaterThan(probe)
-            probe += 1.minutes
-        }
-    }
-
-    // --- daylight saving -----------------------------------------------------
-
-    @Test
-    fun `spring forward keeps the rollover one day away, not one hour short`() {
-        // Berlin skipped 02:00-03:00 on 31 March 2024, so that day was 23h long.
-        // A rollover computed as "now + 24h" would land at 01:00 on 1 April.
-        val now = at("2024-03-30T12:00:00", berlin)
-        val next = WidgetRolloverScheduler.nextRolloverAt(now, berlin)
-        assertThat(next).isEqualTo(at("2024-03-31T00:00:05", berlin))
-        assertThat(next - now).isLessThan(24.hours)
-    }
-
-    @Test
-    fun `fall back does not overshoot into the repeated hour`() {
-        // Berlin repeated 02:00-03:00 on 27 October 2024: a 25h day, so
-        // "now + 24h" would land at 23:00 on the 26th and never roll over.
-        val now = at("2024-10-26T12:00:00", berlin)
-        val next = WidgetRolloverScheduler.nextRolloverAt(now, berlin)
-        assertThat(next).isEqualTo(at("2024-10-27T00:00:05", berlin))
-        assertThat(next.toLocalDateTime(berlin).date).isEqualTo(LocalDate.parse("2024-10-27"))
-    }
-
-    @Test
-    fun `a zone that repeats midnight takes the first start of day`() {
-        // Sao Paulo used to end DST by moving 00:00 back to 23:00, so the day
-        // began twice. Pinned as the accepted trade: the widget runs an hour
-        // ahead until the next redraw. No live zone does this since 2019.
-        val saoPaulo = TimeZone.of("America/Sao_Paulo")
-        val next = WidgetRolloverScheduler.nextRolloverAt(
-            at("2018-02-16T12:00:00", saoPaulo), saoPaulo,
-        )
-        val local = next.toLocalDateTime(saoPaulo)
-        assertThat(local.date).isEqualTo(LocalDate.parse("2018-02-17"))
-        assertThat(local.hour).isEqualTo(0)
-    }
-
-    @Test
-    fun `a zone where midnight does not exist rolls over at the real start of day`() {
-        // Cuba starts DST at 00:00, so 11 March 2018 began at 01:00 in Havana.
-        // Targeting a literal 00:00 there would arm an instant on the wrong day.
-        val havana = TimeZone.of("America/Havana")
-        val next = WidgetRolloverScheduler.nextRolloverAt(at("2018-03-10T12:00:00", havana), havana)
-        val local = next.toLocalDateTime(havana)
-        assertThat(local.date).isEqualTo(LocalDate.parse("2018-03-11"))
-        assertThat(local.hour).isEqualTo(1)
-        assertThat(local.minute).isEqualTo(0)
-        // And it is genuinely the first instant of that date, not a guess.
-        assertThat(next).isEqualTo(
-            LocalDate.parse("2018-03-11").atStartOfDayIn(havana) +
-                WidgetRolloverScheduler.ROLLOVER_SLACK,
-        )
-    }
-
-    // --- timezone changes ----------------------------------------------------
-
-    @Test
-    fun `the same instant rolls over at different times in different zones`() {
-        // TIMEZONE_CHANGED must re-arm to the new local midnight: the arithmetic
-        // follows the zone, not a cached offset.
-        val instant = at("2026-08-27T12:00:00", berlin)
-        val tokyo = TimeZone.of("Asia/Tokyo")
-        val berlinNext = WidgetRolloverScheduler.nextRolloverAt(instant, berlin)
-        val tokyoNext = WidgetRolloverScheduler.nextRolloverAt(instant, tokyo)
-        assertThat(tokyoNext).isNotEqualTo(berlinNext)
-        assertThat(tokyoNext).isLessThan(berlinNext)
-        assertThat(tokyoNext.toLocalDateTime(tokyo).hour).isEqualTo(0)
-    }
-
-    @Test
-    fun `a half-hour offset zone still lands on its own midnight`() {
-        val kathmandu = TimeZone.of("Asia/Kathmandu")
-        val next = WidgetRolloverScheduler.nextRolloverAt(
-            at("2026-08-27T12:00:00", kathmandu), kathmandu,
-        )
-        val local = next.toLocalDateTime(kathmandu)
-        assertThat(local.date.toString()).isEqualTo("2026-08-28")
-        assertThat(local.hour).isEqualTo(0)
-    }
-
-    // --- the wiring ----------------------------------------------------------
-
-    @Test
-    fun `the receiver actually handles the action the alarm is sent with`() {
-        // The single point where the whole fix would die silently: the alarm
-        // fires, the receiver drops it on the action guard, nothing redraws.
-        assertThat(WidgetUpdateReceiver.HANDLED_ACTIONS)
-            .contains(WidgetUpdateReceiver.ACTION_ROLLOVER)
-    }
-}
--- a/app/src/test/resources/ics/fossify-contact-birthdays.ics
+++ b/app/src/test/resources/ics/fossify-contact-birthdays.ics
@@ -1,64 +0,0 @@
-BEGIN:VCALENDAR
-PRODID:-//Fossify//NONSGML Event Calendar//EN
-VERSION:2.0
-BEGIN:VEVENT
-SUMMARY:Anna Schmidt
-UID:101
-X-FOSSIFY-CATEGORY-COLOR:-1155931
-CATEGORIES:Birthdays
-LAST-MODIFIED:20250615T150640Z
-TRANSP:TRANSPARENT
-DTSTART;VALUE=DATE:19900412
-DTEND;VALUE=DATE:19900412
-X-FOSSIFY-MISSING-YEAR:0
-DTSTAMP:20260819T120000Z
-CLASS:PUBLIC
-STATUS:CONFIRMED
-RRULE:FREQ=YEARLY;INTERVAL=1;BYMONTH=4
-BEGIN:VALARM
-DESCRIPTION:Reminder
-ACTION:DISPLAY
-TRIGGER:P0DT9H0M0S
-END:VALARM
-END:VEVENT
-BEGIN:VEVENT
-SUMMARY:Opa
-UID:102
-X-FOSSIFY-CATEGORY-COLOR:-1155931
-CATEGORIES:Birthdays
-LAST-MODIFIED:20250615T150640Z
-TRANSP:TRANSPARENT
-DTSTART;VALUE=DATE:19700603
-DTEND;VALUE=DATE:19700603
-X-FOSSIFY-MISSING-YEAR:1
-DTSTAMP:20260819T120000Z
-CLASS:PUBLIC
-STATUS:CONFIRMED
-RRULE:FREQ=YEARLY;INTERVAL=1;BYMONTH=6
-BEGIN:VALARM
-DESCRIPTION:Reminder
-ACTION:DISPLAY
-TRIGGER:P0DT9H0M0S
-END:VALARM
-END:VEVENT
-BEGIN:VEVENT
-SUMMARY:Hochzeitstag
-UID:103
-X-FOSSIFY-CATEGORY-COLOR:-1155931
-CATEGORIES:Anniversaries
-LAST-MODIFIED:20250615T150640Z
-TRANSP:TRANSPARENT
-DTSTART;VALUE=DATE:20050917
-DTEND;VALUE=DATE:20050917
-X-FOSSIFY-MISSING-YEAR:0
-DTSTAMP:20260819T120000Z
-CLASS:PUBLIC
-STATUS:CONFIRMED
-RRULE:FREQ=YEARLY;INTERVAL=1;BYMONTH=9
-BEGIN:VALARM
-DESCRIPTION:Reminder
-ACTION:DISPLAY
-TRIGGER:P0DT9H0M0S
-END:VALARM
-END:VEVENT
-END:VCALENDAR
--- a/app/src/test/resources/ics/fossify-holidays-at.ics
+++ b/app/src/test/resources/ics/fossify-holidays-at.ics
@@ -1,25 +0,0 @@
-BEGIN:VCALENDAR
-VERSION:2.0
-CALSCALE:GREGORIAN
-PRODID:Fossify Calendar Holiday Generator
-METHOD:PUBLISH
-X-PUBLISHED-TTL:PT1H
-BEGIN:VEVENT
-UID:fossify_c10f9ad245dc2e57fb3652abee6ed8a06744f0bd
-SUMMARY:Neujahr
-DTSTAMP:20260526T132315Z
-DTSTART;VALUE=DATE:19800101
-DTEND;VALUE=DATE:19800102
-STATUS:CONFIRMED
-RRULE:FREQ=YEARLY
-END:VEVENT
-BEGIN:VEVENT
-UID:fossify_8a60ccf65b65265f768dd33a0b7aefc7620e3ee2
-SUMMARY:Heilige Drei Könige
-DTSTAMP:20260526T132315Z
-DTSTART;VALUE=DATE:19800106
-DTEND;VALUE=DATE:19800107
-STATUS:CONFIRMED
-RRULE:FREQ=YEARLY
-END:VEVENT
-END:VCALENDAR
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -346,101 +346,6 @@ a latch that disables its own scheduling once a real broadcast arrives — canno
 be copied, because our failure mode includes a broadcast that arrives with no
 alert row behind it.

-## Importing foreign `.ics`
-
-`IcsParser` is deliberately liberal, because the files it is handed were written
-by other people's calendars. What that costs us, learned from reading the Simple
-Calendar / Fossify exporter (#225):
-
-**An all-day event may never reach the provider zero days long.** This is what
-#225 was: Fossify mirrors Contacts birthdays and anniversaries with
-`startTS = endTS` (`MainActivity`), so its exporter's `dayCode(endTS + 12h)`
-rounds back to the starting day and writes `DTEND == DTSTART`. Taken literally
-that is a yearly series of zero-length occurrences, which the provider expands
-into no instances at all — the import reports success and the birthdays are
-nowhere. Nothing is logged, because nothing failed. `resolveEnd` floors an
-all-day span at a day (also RFC 5545 §3.6.1, which gives a `DATE` `DTSTART` with
-no `DTEND` a one-day duration) and `buildImportedEventValues` floors an all-day
-`DURATION` at `P1D`.
-
-Do **not** generalise that into correcting the producer's `DTEND` by sniffing its
-`PRODID`. The same exporter is right everywhere else: `Event.endTS` anchors a
-UI-created all-day event at *noon* of its last day
-(`EventActivity.getStartEndTimes`), or at the exclusive midnight when the row
-came from CalDAV, and `+ TWELVE_HOURS` rounds either to the following midnight.
-Shifting those would push every one of them out by a day. The holiday files
-bundled inside Fossify are a second trap: their `PRODID` reads
-`Fossify Calendar Holiday Generator` and their content is plain conformant
-iCalendar. Both that file and a contact-birthday export are kept as fixtures in
-`app/src/test/resources/ics`. Clamp the degenerate case; never rewrite the
-conformant one.
-
-**One bad event must not cost the file.** The provider validates `RRULE` through
-`EventRecurrence.parse`, which *throws* — out of `insert`, not out of a later
-read. That parser works off a fixed table of part names and throws on anything
-outside it, so `sanitizeRrule` is a **whitelist**: unrecognised parts (RFC 7529
-`RSCALE`, vendor `X-` extensions) and unusable values go, and only a missing
-`FREQ` gives up on the rule. It reports whether it actually *dropped* something,
-separately from the rule text it returns — case and a trailing `;` normalise away
-and must not raise the "faulty repeat rule" warning at the user. Behind all that,
-`CalendarRepositoryImpl.importEvents` isolates each event, counting rejects into
-`IcsImportSummary.failed` rather than unwinding the batch and reporting only
-"couldn't read this file".
-
-Smaller dialect handling: `VTODO` components import as events (Calendula models
-no tasks; dropping them silently lost half of some exports), a single-valued
-`CATEGORIES` stands in for the `X-WR-CALNAME` Fossify never writes and preselects
-a target calendar of that name — as a *fallback* only, since everywhere else the
-property is a tag list and must not outrank something that names the calendar
-outright — bare `EXDATE` day codes on a timed series are resolved against the
-series' own time of day (as is a floating `EXDATE` DATE-TIME — RFC 5545 ties it
-to `DTSTART`'s zone, not the device's) while an all-day `EXDATE` keeps the day it
-spells out rather than the day its resolved instant lands on in UTC, and an
-all-day `VALARM` trigger pointing *after* the start — which is how that family
-encodes "on the day at 09:00" — is read as zero days before. On a *timed* event
-the same shape means a follow-up alarm and is dropped: clamping it to zero would
-invent a reminder at the start that the file never asked for.
-
-All-day reminder offsets are **whole days, rounded up** in both directions. A
-file's raw offset is `days × 1440 − timeOfDay`, so rounding to the nearest day
-would drop a day for every producer whose all-day notifications fire after noon
-("1 day before at 18:00" arrives as `TRIGGER:-PT6H`). The export side is the
-mirror image: an all-day row's raw provider `MINUTES` has the firing time encoded
-into it and is normally *negative*, which the writer used to discard as a trigger
-after the event — so `toIcsEvent` decodes it back through
-`fromProviderAllDayMinutes` first, and the importing device re-encodes it against
-its own setting.
-
-**A backup carries the series' deleted occurrences.** `EXDATE` lives on the
-master row, so the export query's `ORIGINAL_ID IS NULL` filter — which does drop
-`RECURRENCE-ID` overrides — never hid it; it simply wasn't read. It is now part
-of `EventExportProjection`, and `IcsWriter` marks an all-day series' exclusions
-`VALUE=DATE`, because RFC 5545 ties `EXDATE`'s value type to `DTSTART`'s and a
-bare day code without it reads as a malformed DATE-TIME. Sync adapters disagree
-on whether an all-day exclusion is `yyyyMMdd` or a padded midnight stamp, so
-`exportExDates` drops the time part on the way out. Without this, an in-app
-backup→restore resurrected every occurrence the user had deleted.
-
-That re-encode is sampled where the reminder will actually *fire*, not at
-`DTSTART` (`importedAllDayReminderDate`). An imported series' `DTSTART` is only an
-anchor and is routinely ancient — Fossify writes a year-less contact birthday at
-1970, and a real birth year is usually older still — from a year whose timezone
-rules predate DST across most of Europe. Sampling the UTC offset there skews every
-modern occurrence by the delta, the same trap `nextYearlyOccurrence` exists for on
-the managed special-dates path. Decoding is unaffected and stays anchored at
-`DTSTART`: it only asks which local *day* the encoded instant falls on.
-
-Colour arrives as a raw ARGB from an app with no idea which account it is landing
-in. A calendar whose account publishes a palette rejects a raw `EVENT_COLOR`, so
-`buildImportedEventValues` snaps the imported colour to the nearest published key
-(`nearestTo`, measured in Oklab) and writes the raw value only where there is no
-palette. The match runs against `publishedEventColors`, **not** the curated
-`eventColorPalette`: curation is a picker concession that folds look-alikes and
-drops the neutrals outright from an oversized palette, but every published key is
-one the calendar accepts. The single-event review form deliberately keeps no colour at all: its
-first question is which calendar to use, and answering it clears the colour
-anyway.
-
 ## Testing

 JUnit 5 + Truth + Turbine on the JVM. The seams that make it work:
--- a/docs/RELEASING.md
+++ b/docs/RELEASING.md
@@ -172,12 +172,9 @@ F-Droid but not Play:
 Until those are fixed, Play's graphics are managed by hand in the console. Then
 pass `images:true` to the `listing` lane.

-**Track.** Uploads go straight to `production` at a full rollout
-(`PLAY_RELEASE_STATUS=completed`). The merge to `main` is already the human
-gate — a release only gets there after on-device review — so a second manual
-promotion in the Play Console added delay without adding a decision. Set the
-`PLAY_TRACK` repo variable (e.g. `internal`) to stage a release instead, or
-`PLAY_RELEASE_STATUS=draft` to hold it unpublished.
+**Track.** Uploads go to `internal` by default; promotion to production stays a
+manual action in the Play Console, matching the rule that UI releases wait for
+on-device review. Override with the `PLAY_TRACK` repo variable.

 ### Manual re-sign / recovery

@@ -236,7 +233,7 @@ Two consequences worth remembering:

 | Variable | Default | Purpose |
 | --- | --- | --- |
-| `PLAY_TRACK` | `production` | Play track the bundle is uploaded to. Set to `internal`/`alpha`/`beta` to stage instead. |
+| `PLAY_TRACK` | `internal` | Play track the bundle is uploaded to. |
 | `PLAY_RELEASE_STATUS` | `completed` | `completed`, `draft`, `inProgress` or `halted`. |
 | `PLAY_DRY_RUN` | `false` | `true` validates the Play edit against the API and discards it — use to rehearse. |

--- a/fastlane/Fastfile
+++ b/fastlane/Fastfile
@@ -29,7 +29,7 @@ platform :android do

    supply(
      aab: aab,
-      track: options[:track] || "production",
+      track: options[:track] || "internal",
      release_status: options[:release_status] || "completed",

      # The APK belongs to F-Droid and the Codeberg download; Play only ever
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,20 +1,20 @@
 [versions]
-agp = "9.2.1"
+agp = "9.3.1"
 kotlin = "2.3.21"
 ksp = "2.3.11"
 hilt = "2.60.1"
 coreKtx = "1.19.0"
 appcompat = "1.7.1"
-lifecycleRuntime = "2.11.0"
+lifecycleRuntime = "2.10.0"
 activityCompose = "1.13.0"
 composeBom = "2026.06.01"
 # Material 3 Expressive APIs currently live only in the 1.5 alpha line.
 # Pin explicitly to override the BOM (which ships stable 1.4.0).
 # Re-evaluate when 1.5.0 stable lands.
-material3 = "1.5.0-alpha26"
+material3 = "1.5.0-alpha25"
 datastore = "1.2.1"
-junit = "6.1.3"
-junitPlatform = "6.1.3"
+junit = "6.1.2"
+junitPlatform = "6.1.2"
 truth = "1.4.5"
 androidxJunit = "1.3.0"
 espressoCore = "3.7.0"
@@ -26,7 +26,7 @@ lifecycleCompose = "2.10.0"
 androidxTestRules = "1.7.0"
 # Glance: 1.1.1 is the latest stable (1.2.0 is still rc, 1.3.0 alpha).
 glance = "1.1.1"
-work = "2.11.2"
+work = "2.10.1"
 documentfile = "1.1.0"

 [libraries]