Drop the ellipsis in week and day event chips too (#164) (#222)

Reviewed-on: https://codeberg.org/jlmakiola/calendula/pulls/222

.forgejo/ISSUE_TEMPLATE/bug_report.md

@@ -21,9 +21,9 @@ labels:
 - Calendula version: <!-- Settings → bottom of the screen -->
 - Android version:
 - Device:
-- Installed from: <!-- official F-Droid / the self-hosted repo / Google Play / Codeberg APK or Obtainium / built from source -->
+- Installed from: <!-- official F-Droid / the self-hosted repo / built from source -->
 - Affected calendar: <!-- Google, CalDAV (DAVx5, Nextcloud, …), on-device/local,
-                         subscribed/WebCal, birthdays. Provider behaviour differs
+                         subscribed/WebCal, birthdays — provider behaviour differs
                          a lot per account type, so this often points straight at
                          the cause -->
 - Time zone: <!-- only if the problem involves dates or all-day events -->

.forgejo/ISSUE_TEMPLATE/config.yml

@@ -6,8 +6,8 @@ contact_links:
   - name: Translate Calendula
     url: https://weblate.dev.jeanlucmakiola.de/engage/calendula/
     about: >-
-      Translations are managed on Weblate. It owns every values-* file, so a
+      Translations are managed on Weblate, not here — it owns every values-*
-      hand-edited translation gets overwritten on the next sync.
+      file, so a hand-edited translation gets overwritten on the next sync.
       No coding needed: pick or request a language and translate in the browser.
 
   - name: Contributing guide

.forgejo/ISSUE_TEMPLATE/crash_report.md

@@ -1,6 +1,6 @@
 ---
 name: Crash report
-about: Report a crash. Calendula can capture this for you (Settings → Report a problem, or the prompt after a crash). It copies the report to your clipboard and prefills this form.
+about: Report a crash. Calendula can capture this for you (Settings → Report a problem, or the prompt after a crash) — it copies the report to your clipboard and prefills this form.
 title: "Crash: "
 labels:
   - bug
@@ -11,10 +11,10 @@ labels:
 <!--
 Thanks for reporting a crash in Calendula!
 
-If the app prefilled this for you, the crash report is already below. Add
+If the app prefilled this for you, the crash report is already below — just add
 what you were doing and submit. Otherwise, paste the report from your clipboard
 into the code block. The report contains only app/Android/device versions and the
-stack trace, with no personal data or calendar content.
+stack trace — no personal data or calendar content.
 -->
 
 ### What happened

.forgejo/ISSUE_TEMPLATE/feature_request.md

@@ -9,7 +9,7 @@ labels:
 ### What would you like Calendula to do?
 
 
-### What problem does it solve?
+### Why — what problem does it solve?
 
 
 ### Anything else

.forgejo/PULL_REQUEST_TEMPLATE.md

@@ -5,7 +5,7 @@ Please skim CONTRIBUTING.md if you haven't:
 https://codeberg.org/jlmakiola/calendula/src/branch/main/CONTRIBUTING.md
 
 Two things it's easy to get wrong:
-  • Features need a discussed issue first. An undiscussed feature PR may be
+  • Features need a discussed issue first — an undiscussed feature PR may be
     closed unmerged even when the code is good.
   • Target the release branch for your issue's milestone (milestone 2.18.0 →
     release/v2.18.0), not main. If you targeted main, just say so below and it
@@ -17,7 +17,7 @@ Two things it's easy to get wrong:
 
 ### Why
 
-<!-- Closes #123: link the issue this implements or fixes. -->
+<!-- Closes #123 — link the issue this implements or fixes. -->
 
 
 ### How it was tested
@@ -34,7 +34,7 @@ are especially useful for UI changes.
 ### Checklist
 
 - [ ] There's an issue for this, and (for a feature) it got a go-ahead
-- [ ] Targeting the release branch for that issue's milestone (or `main`, noted above)
+- [ ] Targeting the release branch for that issue's milestone — or `main`, noted above
 - [ ] `./gradlew lint test assembleDebug` passes locally
 - [ ] No `values-*/strings.xml` touched (Weblate owns those; new English strings in `values/` are fine)
 - [ ] `CHANGELOG.md` updated under `## [Unreleased]`, if the change is user-visible

.forgejo/workflows/ci.yaml

@@ -37,40 +37,6 @@ jobs:
       - name: Reproducible-release invariant
         run: bash scripts/check_reproducible_release.sh
 
-      # versionCode must match versionName (the official F-Droid repo builds the
-      # tag as committed), and a beta must never reach main.
-      - name: Committed version is well-formed
-        env:
-          BASE: ${{ github.base_ref }}
-        run: |
-          set -e
-          bash scripts/version_info.sh --check
-          if [ "${BASE#refs/heads/}" = "main" ] && [ "$(bash scripts/version_info.sh channel)" = "beta" ]; then
-            echo "ERROR: versionName $(bash scripts/version_info.sh version) is a beta." >&2
-            echo "Set the stable version (and its versionCode) before merging into main." >&2
-            exit 1
-          fi
-
-      # Play rejects a "What's New" over 500 characters, which would fail the
-      # upload after the release had already shipped everywhere else. Cheap, so
-      # it runs on every PR rather than only on the release merge. A beta ships
-      # no What's New, so only the older files are checked for one.
-      - name: Changelog length invariant
-        run: bash scripts/check_changelog_lengths.sh
-
-      # The whole listing goes to Play with every release; a field over its cap
-      # or an image Play rejects would fail that upload.
-      - name: Store listing invariant
-        run: |
-          if ! command -v python3 >/dev/null 2>&1; then
-            if command -v apt-get >/dev/null 2>&1; then
-              apt-get update && apt-get install -y python3
-            elif command -v apk >/dev/null 2>&1; then
-              apk add --no-cache python3
-            fi
-          fi
-          python3 scripts/check_store_listing.py
-
       # Decide whether anything that affects the app build changed. Docs, store
       # metadata, licence texts and forge housekeeping don't, so those PRs skip
       # the SDK + Gradle work below but still report a green `ci`.

.gitattributes

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

.gitea/actions/android-env/action.yml

@@ -1,57 +0,0 @@
-name: Android build environment
-description: JDK 17, Android SDK + build tools, Gradle cache and jq for the release and beta pipelines.
-runs:
-  using: composite
-  steps:
-    - name: Setup Java
-      uses: actions/setup-java@v4
-      with:
-        distribution: 'zulu'
-        java-version: '17'
-
-    - name: Setup Android SDK
-      uses: android-actions/setup-android@v3
-      with:
-        packages: ''
-
-    - name: Setup Android SDK cache
-      uses: actions/cache@v4
-      with:
-        path: /opt/android-sdk
-        key: ${{ runner.os }}-android-sdk-37-36.0.0
-
-    - name: Install Android SDK packages
-      shell: bash
-      run: |
-        yes | sdkmanager --licenses >/dev/null || true
-        sdkmanager \
-          "platform-tools" \
-          "platforms;android-37.0" \
-          "build-tools;36.0.0"
-
-    - name: Setup Gradle cache
-      uses: actions/cache@v4
-      with:
-        path: |
-          ~/.gradle/caches
-          ~/.gradle/wrapper
-        key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties', 'gradle/libs.versions.toml') }}
-        restore-keys: |
-          ${{ runner.os }}-gradle-
-
-    - name: Install jq
-      shell: bash
-      run: |
-        set -e
-        SUDO=""
-        if command -v sudo >/dev/null 2>&1; then SUDO="sudo"; fi
-        if command -v apt-get >/dev/null 2>&1; then
-          $SUDO apt-get update
-          $SUDO apt-get install -y jq
-        elif command -v apk >/dev/null 2>&1; then
-          $SUDO apk add --no-cache jq
-        fi
-
-    - name: Grant execute permission for gradlew
-      shell: bash
-      run: chmod +x ./gradlew

.gitea/workflows/beta.yaml

@@ -1,97 +0,0 @@
-name: Beta — Codeberg pre-release
-
-# Pushing a release/* branch whose versionName is X.Y.Z-beta.N publishes a
-# Codeberg pre-release (APK + SHA-256) and a Gitea pre-release (R8 mapping).
-# Betas never reach F-Droid or Play. See docs/RELEASING.md.
-on:
-  push:
-    branches: ['release/**']
-
-concurrency:
-  group: beta
-  cancel-in-progress: false
-
-jobs:
-  detect:
-    # Gitea only; see the same guard in release.yaml.
-    if: github.repository_owner == 'makiolaj'
-    runs-on: light
-    outputs:
-      is_beta: ${{ steps.v.outputs.is_beta }}
-      version: ${{ steps.v.outputs.version }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Resolve version and whether it still needs publishing
-        id: v
-        run: |
-          set -e
-          INFO=$(bash scripts/version_info.sh)
-          echo "$INFO"
-          echo "$INFO" >> "$GITHUB_OUTPUT"
-          if [ "$(bash scripts/version_info.sh channel)" != beta ]; then
-            echo "Not a beta — nothing to do."
-            echo "is_beta=false" >> "$GITHUB_OUTPUT"
-            exit 0
-          fi
-          GATE=$(bash scripts/release_gate.sh)
-          echo "is_beta=${GATE#cut=}" >> "$GITHUB_OUTPUT"
-
-  beta:
-    needs: detect
-    if: needs.detect.outputs.is_beta == 'true'
-    runs-on: gradle
-    env:
-      ANDROID_HOME: /opt/android-sdk
-      ANDROID_SDK_ROOT: /opt/android-sdk
-      VERSION: ${{ needs.detect.outputs.version }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          submodules: recursive
-
-      - name: Android build environment
-        uses: ./.gitea/actions/android-env
-
-      - name: Pin versionCode to versionName
-        run: bash scripts/version_info.sh --pin
-
-      - name: Unit tests
-        run: ./gradlew testDebugUnitTest
-
-      # The real app key, so a beta updates in place to later betas and stable.
-      - name: Setup Android Keystore
-        env:
-          KEYSTORE_BASE64: ${{ secrets.KEYSTORE_BASE64 }}
-          KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}
-          KEY_ALIAS: ${{ secrets.KEY_ALIAS }}
-        run: bash scripts/write_keystore.sh
-
-      - name: Build release APK
-        run: ./gradlew assembleRelease
-
-      - name: Create tag + Gitea pre-release
-        env:
-          TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          API: ${{ github.server_url }}/api/v1/repos/${{ github.repository }}
-          SHA: ${{ github.sha }}
-        run: |
-          set -e
-          bash scripts/release_notes.sh "$VERSION" > release-notes.md
-          cat release-notes.md
-          TAG="v$VERSION" PRERELEASE=true NOTES_FILE=release-notes.md \
-            MAPPING=app/build/outputs/mapping/release/mapping.txt \
-            bash scripts/publish_gitea_release.sh
-
-      - name: Publish pre-release to Codeberg
-        env:
-          TOKEN: ${{ secrets.CODEBERG_RELEASE_TOKEN }}
-          API: https://codeberg.org/api/v1/repos/jlmakiola/calendula
-          SHA: ${{ github.sha }}
-        run: |
-          set -e
-          TAG="v$VERSION" PRERELEASE=true NOTES_FILE=release-notes.md \
-            APK=app/build/outputs/apk/release/app-release.apk \
-            bash scripts/publish_codeberg_release.sh

.gitea/workflows/release.yaml

@@ -7,9 +7,7 @@ name: Release — F-Droid repo + Gitea/Codeberg release + Play
 # that release to Codeberg with the signed APK + a SHA-256 checksum as a
 # direct-download channel — the tag is an output of the pipeline, not its
 # trigger. Ordinary merges (no version bump) fall through `detect` and do
-# nothing. Betas (X.Y.Z-beta.N) never come through here: beta.yaml cuts them
+# nothing.
-# from release/* branches as Codeberg-only pre-releases, and `detect` refuses
-# one that reaches main.
 #
 # A trailing `play` job then uploads the App Bundle to Google Play. It is last
 # and separate because Play is the only channel that can reject a good build for
@@ -43,7 +41,7 @@ jobs:
     # secrets. repository_owner differs between the two forges regardless of
     # URL, proxy or instance rename, so this closes it permanently.
     if: github.repository_owner == 'makiolaj'
-    runs-on: light
+    runs-on: docker
     outputs:
       is_release: ${{ steps.v.outputs.is_release }}
       version: ${{ steps.v.outputs.version }}
@@ -56,28 +54,56 @@ jobs:
 
       - name: Resolve version and whether it is a new release
         id: v
+        env:
+          # Tags are read from Codeberg, which is canonical — deliberately NOT
+          # from the Gitea API this workflow runs on. The Codeberg -> Gitea sync
+          # is a push mirror, i.e. `git push --mirror`, which deletes refs the
+          # source does not have. A tag minted here on Gitea is therefore wiped
+          # by the next sync (Codeberg does not have it yet) and only reappears
+          # once the tag push at the end of this workflow propagates back.
+          # Asking Gitea inside that window would report "no tag" for a release
+          # that already shipped, and cut it a second time.
+          # Public repo, so this read needs no token.
+          TAG_API: https://codeberg.org/api/v1/repos/jlmakiola/calendula
         run: |
           set -e
-          INFO=$(bash scripts/version_info.sh)
+          VERSION=$(grep -oP 'versionName\s*=\s*"\K[^"]+' app/build.gradle.kts)
-          echo "$INFO"
+          if [ -z "$VERSION" ]; then echo "No versionName in app/build.gradle.kts" >&2; exit 1; fi
-          echo "$INFO" >> "$GITHUB_OUTPUT"
+          MAJOR=$(echo "$VERSION" | cut -d. -f1); MINOR=$(echo "$VERSION" | cut -d. -f2); PATCH=$(echo "$VERSION" | cut -d. -f3)
-          VERSION=$(echo "$INFO" | sed -n 's/^version=//p')
+          MAJOR=${MAJOR:-0}; MINOR=${MINOR:-0}; PATCH=${PATCH:-0}
-          CHANNEL=$(echo "$INFO" | sed -n 's/^channel=//p')
+          VERSION_CODE=$(( MAJOR * 10000 + MINOR * 100 + PATCH ))
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "version_code=$VERSION_CODE" >> "$GITHUB_OUTPUT"
+          echo "Resolved version $VERSION (code $VERSION_CODE)"
           if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
             echo "Manual dispatch — re-sign path, not a release."
             echo "is_release=false" >> "$GITHUB_OUTPUT"
             exit 0
           fi
-          # Backstop for CI's guard: betas ship from release/* via beta.yaml.
+          # A tag for this version already existing means the release shipped on
-          if [ "$CHANNEL" != "stable" ]; then
+          # an earlier push; do nothing. Absent => this merge cuts the release.
-            echo "versionName $VERSION on main is a beta. Set the stable version before merging to main." >&2
+          #
-            exit 1
+          # Anything other than a clean 200/404 is treated as fatal rather than
-          fi
+          # as "no tag". A Codeberg outage or a network blip would otherwise
-          # Tags are read from Codeberg, the canonical forge: a tag minted here is
+          # read as absent and re-cut a release that has already shipped —
-          # wiped by the next mirror sync until Codeberg has it. A lookup error is
+          # republishing to F-Droid and Play. Failing here is recoverable; a
-          # fatal, since guessing "no tag" would re-cut a shipped release.
+          # duplicate release is not.
-          GATE=$(bash scripts/release_gate.sh)
+          STATUS=$(curl -s -o /dev/null -w '%{http_code}' "$TAG_API/git/refs/tags/v$VERSION" || echo 000)
-          echo "is_release=${GATE#cut=}" >> "$GITHUB_OUTPUT"
+          case "$STATUS" in
+            200)
+              echo "Tag v$VERSION already exists on Codeberg — nothing to release."
+              echo "is_release=false" >> "$GITHUB_OUTPUT"
+              ;;
+            404)
+              echo "No tag for v$VERSION on Codeberg yet — cutting the release."
+              echo "is_release=true" >> "$GITHUB_OUTPUT"
+              ;;
+            *)
+              echo "Codeberg tag lookup for v$VERSION returned HTTP $STATUS." >&2
+              echo "Refusing to guess: treating this as 'no tag' could re-cut a shipped release." >&2
+              exit 1
+              ;;
+          esac
 
   # Releases: build + sign + publish, then mint the tag and Gitea release.
   # Also runs on manual dispatch, where it skips the build and just re-signs and
@@ -85,7 +111,7 @@ jobs:
   release:
     needs: detect
     if: needs.detect.outputs.is_release == 'true' || github.event_name == 'workflow_dispatch'
-    runs-on: gradle
+    runs-on: docker
     env:
       ANDROID_HOME: /opt/android-sdk
       ANDROID_SDK_ROOT: /opt/android-sdk
@@ -98,13 +124,65 @@ jobs:
         with:
           submodules: recursive
 
-      - name: Android build environment
+      - name: Setup Java
-        uses: ./.gitea/actions/android-env
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'zulu'
+          java-version: '17'
 
-      # The committed versionName is the source of truth; pin the derived code.
+      - name: Setup Android SDK
+        uses: android-actions/setup-android@v3
+        with:
+          packages: ''
+
+      - name: Setup Android SDK cache
+        uses: actions/cache@v4
+        with:
+          path: /opt/android-sdk
+          key: ${{ runner.os }}-android-sdk-37-36.0.0
+
+      - name: Install Android SDK packages
+        run: |
+          yes | sdkmanager --licenses >/dev/null || true
+          sdkmanager \
+            "platform-tools" \
+            "platforms;android-37.0" \
+            "build-tools;36.0.0"
+
+      - name: Setup Gradle cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties', 'gradle/libs.versions.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+
+      - name: Install jq
+        run: |
+          set -e
+          SUDO=""
+          if command -v sudo >/dev/null 2>&1; then SUDO="sudo"; fi
+          if command -v apt-get >/dev/null 2>&1; then
+            $SUDO apt-get update
+            $SUDO apt-get install -y jq
+          elif command -v apk >/dev/null 2>&1; then
+            $SUDO apk add --no-cache jq
+          fi
+
+      - name: Grant execute permission for gradlew
+        run: chmod +x ./gradlew
+
+      # The committed versionName is the source of truth. Pin versionCode to the
+      # value derived from it so the published APK's code is always
+      # MAJOR*10000 + MINOR*100 + PATCH even if the committed code was forgotten.
       - name: Pin versionCode to versionName
         if: env.IS_RELEASE == 'true'
-        run: bash scripts/version_info.sh --pin
+        run: |
+          set -e
+          sed -i "s/versionCode = .*/versionCode = $VERSION_CODE/" app/build.gradle.kts
+          grep -E 'versionName|versionCode' app/build.gradle.kts
 
       # Test the exact commit being shipped (only on a real release).
       - name: Unit tests
@@ -117,7 +195,15 @@ jobs:
           KEYSTORE_BASE64: ${{ secrets.KEYSTORE_BASE64 }}
           KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}
           KEY_ALIAS: ${{ secrets.KEY_ALIAS }}
-        run: bash scripts/write_keystore.sh
+        run: |
+          mkdir -p app
+          echo "$KEYSTORE_BASE64" | base64 --decode > app/upload-keystore.jks
+          cat > key.properties <<EOF
+          storePassword=$KEY_PASSWORD
+          keyPassword=$KEY_PASSWORD
+          keyAlias=$KEY_ALIAS
+          storeFile=upload-keystore.jks
+          EOF
 
       - name: Build release APK
         if: env.IS_RELEASE == 'true'
@@ -226,7 +312,6 @@ jobs:
       # Creating it with target_commitish makes Gitea create the vX.Y.Z tag at
       # this commit, so the tag only ever marks a fully-shipped release (and a
       # failure before here leaves no tag, so re-running the workflow retries).
-      # Also attaches the R8 mapping, best-effort.
       - name: Create tag + Gitea release
         if: env.IS_RELEASE == 'true'
         env:
@@ -235,10 +320,74 @@ jobs:
           SHA: ${{ github.sha }}
         run: |
           set -e
-          bash scripts/release_notes.sh "$VERSION" > release-notes.md
+          TAG="v$VERSION"
-          TAG="v$VERSION" PRERELEASE=false NOTES_FILE=release-notes.md \
+          # Notes = this version's CHANGELOG section.
-            MAPPING=app/build/outputs/mapping/release/mapping.txt \
+          awk -v ver="$VERSION" '
-            bash scripts/publish_gitea_release.sh
+            $0 ~ "^## \\[" ver "\\]" { flag = 1; next }
+            /^## \[/ { flag = 0 }
+            flag' CHANGELOG.md > release-notes.md
+          sed -i -e '/./,$!d' release-notes.md
+          if [ ! -s release-notes.md ]; then
+            echo "_No changelog entry for ${VERSION} — see CHANGELOG.md._" > release-notes.md
+          fi
+          python3 - "$TAG" "$SHA" <<'PY' > payload.json
+          import json, sys
+          print(json.dumps({
+              "tag_name": sys.argv[1],
+              "target_commitish": sys.argv[2],
+              "name": sys.argv[1],
+              "body": open("release-notes.md").read(),
+              "draft": False,
+              "prerelease": False,
+          }))
+          PY
+          # Upsert (re-run safe): PATCH if a release for the tag already exists,
+          # else POST a new one (which also creates the tag at target_commitish).
+          curl -s -H "Authorization: token $TOKEN" "$API/releases/tags/$TAG" > existing.json
+          ID=$(jq -r '.id // empty' existing.json 2>/dev/null || true)
+          if [ -n "$ID" ]; then
+            CODE=$(curl -s -o response.json -w '%{http_code}' -X PATCH \
+              -H "Authorization: token $TOKEN" -H "Content-Type: application/json" \
+              -d @payload.json "$API/releases/$ID")
+            OK=200
+          else
+            CODE=$(curl -s -o response.json -w '%{http_code}' -X POST \
+              -H "Authorization: token $TOKEN" -H "Content-Type: application/json" \
+              -d @payload.json "$API/releases")
+            OK=201
+          fi
+          cat response.json
+          if [ "$CODE" != "$OK" ]; then
+            echo "Release upsert failed with HTTP $CODE (expected $OK)" >&2
+            exit 1
+          fi
+          echo "Created/updated release $TAG at $SHA"
+
+      # Archive the R8 mapping so user crash stacktraces stay deobfuscatable.
+      # Attached to the release (it's not an APK, so it fits the no-binaries
+      # rule). Best-effort: never fail a release over it.
+      - name: Attach R8 mapping to Gitea release
+        if: env.IS_RELEASE == 'true'
+        continue-on-error: true
+        env:
+          TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          API: ${{ github.server_url }}/api/v1/repos/${{ github.repository }}
+        run: |
+          set -e
+          MAP="app/build/outputs/mapping/release/mapping.txt"
+          if [ ! -f "$MAP" ]; then echo "No mapping.txt (R8 off?) — skipping."; exit 0; fi
+          TAG="v$VERSION"
+          ASSET="mapping-${VERSION}.txt.gz"
+          gzip -c "$MAP" > "/tmp/$ASSET"
+          ID=$(curl -s -H "Authorization: token $TOKEN" "$API/releases/tags/$TAG" | jq -r '.id // empty')
+          if [ -z "$ID" ]; then echo "Could not resolve release id — skipping."; exit 0; fi
+          # Replace any prior asset of the same name (re-run safe).
+          OLD=$(curl -s -H "Authorization: token $TOKEN" "$API/releases/$ID/assets" \
+            | jq -r --arg n "$ASSET" '.[] | select(.name==$n) | .id')
+          [ -n "$OLD" ] && curl -s -X DELETE -H "Authorization: token $TOKEN" "$API/releases/$ID/assets/$OLD" >/dev/null || true
+          curl -s -X POST -H "Authorization: token $TOKEN" \
+            -F "attachment=@/tmp/$ASSET" \
+            "$API/releases/$ID/assets?name=$ASSET" -o /dev/null -w "asset upload HTTP %{http_code}\n"
 
       # Mirror the release to the Codeberg mirror as a direct-download channel
       # for users who don't want F-Droid. Gitea already push-mirrors branches +
@@ -257,10 +406,84 @@ jobs:
           SHA: ${{ github.sha }}
         run: |
           set -e
-          [ -s release-notes.md ] || bash scripts/release_notes.sh "$VERSION" > release-notes.md
+          if [ -z "${TOKEN:-}" ]; then
-          TAG="v$VERSION" PRERELEASE=false NOTES_FILE=release-notes.md \
+            echo "CODEBERG_RELEASE_TOKEN not set — skipping Codeberg publish."
-            APK=app/build/outputs/apk/release/app-release.apk \
+            exit 0
-            bash scripts/publish_codeberg_release.sh
+          fi
+          TAG="v$VERSION"
+          APK="app/build/outputs/apk/release/app-release.apk"
+          if [ ! -f "$APK" ]; then echo "No release APK found — skipping." >&2; exit 1; fi
+          ASSET_APK="calendula_v${VERSION}.apk"
+          ASSET_SUM="${ASSET_APK}.sha256"
+          cp "$APK" "/tmp/$ASSET_APK"
+          ( cd /tmp && sha256sum "$ASSET_APK" > "$ASSET_SUM" )
+
+          # Release notes: reuse the section extracted for the Gitea release,
+          # fall back to the CHANGELOG entry if that step's file is gone.
+          if [ ! -s release-notes.md ]; then
+            awk -v ver="$VERSION" '
+              $0 ~ "^## \\[" ver "\\]" { flag = 1; next }
+              /^## \[/ { flag = 0 }
+              flag' CHANGELOG.md > release-notes.md
+            sed -i -e '/./,$!d' release-notes.md
+          fi
+          [ -s release-notes.md ] || echo "_See CHANGELOG.md for ${VERSION}._" > release-notes.md
+          # The pipeline creates the tag via the Gitea API, which the push mirror
+          # (sync_on_commit only fires on real git pushes) doesn't propagate
+          # promptly — so a release POST that carries a target_commitish can
+          # outrun the mirror and 500 on a commit/tag Codeberg hasn't received.
+          # Push the tag straight to Codeberg so it's guaranteed present, then
+          # attach the release to that existing tag with NO target_commitish
+          # (which is what triggered the 500).
+          git tag -f "$TAG" "$SHA"
+          git push -f "https://jlmakiola:${TOKEN}@codeberg.org/jlmakiola/calendula.git" \
+            "refs/tags/$TAG"
+          python3 - "$TAG" <<'PY' > cb-payload.json
+          import json, sys
+          print(json.dumps({
+              "tag_name": sys.argv[1],
+              "name": sys.argv[1],
+              "body": open("release-notes.md").read(),
+              "draft": False,
+              "prerelease": False,
+          }))
+          PY
+          # Create (or update) the release. Codeberg 500s on a POST/GET against a
+          # tag it has only just received — the release request outruns the
+          # indexing of the ref we pushed a moment ago — so a single attempt kept
+          # failing and skipping the mirror even though the very same call
+          # succeeds seconds later. Retry with backoff, and PATCH in place if a
+          # release already exists (re-run safe). A 5xx body still exits curl 0,
+          # so the loop, not `set -e`, controls the flow.
+          ID=""
+          for attempt in 1 2 3 4 5 6; do
+            EXIST=$(curl -s -H "Authorization: token $TOKEN" "$API/releases/tags/$TAG" | jq -r '.id // empty' 2>/dev/null || true)
+            if [ -n "$EXIST" ]; then
+              curl -s -o /dev/null -w "release PATCH HTTP %{http_code}\n" -X PATCH \
+                -H "Authorization: token $TOKEN" -H "Content-Type: application/json" \
+                -d @cb-payload.json "$API/releases/$EXIST"
+              ID="$EXIST"; break
+            fi
+            CODE=$(curl -s -o cb-response.json -w "%{http_code}" -X POST \
+              -H "Authorization: token $TOKEN" -H "Content-Type: application/json" \
+              -d @cb-payload.json "$API/releases")
+            echo "release POST attempt $attempt HTTP $CODE"
+            ID=$(jq -r '.id // empty' cb-response.json 2>/dev/null || true)
+            [ -n "$ID" ] && break
+            sleep $((attempt * 10))
+          done
+          if [ -z "$ID" ]; then echo "Could not resolve Codeberg release id after retries." >&2; exit 1; fi
+
+          # Attach APK + checksum, replacing any prior asset of the same name.
+          for A in "$ASSET_APK" "$ASSET_SUM"; do
+            OLD=$(curl -s -H "Authorization: token $TOKEN" "$API/releases/$ID/assets" \
+              | jq -r --arg n "$A" '.[] | select(.name==$n) | .id')
+            [ -n "$OLD" ] && curl -s -X DELETE -H "Authorization: token $TOKEN" "$API/releases/$ID/assets/$OLD" >/dev/null || true
+            curl -s -X POST -H "Authorization: token $TOKEN" \
+              -F "attachment=@/tmp/$A" \
+              "$API/releases/$ID/assets?name=$A" -o /dev/null -w "asset $A HTTP %{http_code}\n"
+          done
+          echo "Published $TAG to Codeberg."
 
       # Play takes an App Bundle, not the APK, so it is a second artifact from
       # the same source and the same signing config — not a repackage of the
@@ -328,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
+      # Where the bundle lands. `internal` by default so a release reaches
-      # gate (a bumped versionName only reaches main after on-device review), so
+      # testers rather than the public, and promotion to production stays a
-      # a second manual promotion in the Play Console bought nothing but delay.
+      # deliberate human action in the Play Console — the same posture as
-      # Override with the PLAY_TRACK repo variable to stage a release instead.
+      # holding UI releases for on-device review. Override with the PLAY_TRACK
-      PLAY_TRACK: ${{ vars.PLAY_TRACK || 'production' }}
+      # 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.

.gitea/workflows/renovate.yml

@@ -1,17 +1,8 @@
 name: Renovate
 
 on:
-  # Every merge to main. Mirror syncs from Codeberg fire push events here (the
+  # Weekly sweep. Mondays 05:00 UTC — this cron owns the cadence; the repo's
-  # same trigger release.yaml relies on), so a merged Renovate PR is followed
+  # renovate.json5 deliberately has no internal schedule (avoids double-gating).
-  # within minutes by a run that rebases the sibling PRs it just conflicted —
-  # most bumps touch gradle/libs.versions.toml. Outside renovate.json5's
-  # `schedule` window such a run only maintains existing branches
-  # (updateNotScheduled), it never opens new PRs. Renovate's own rebases push
-  # to renovate/* branches, not main, so this cannot loop.
-  push:
-    branches: [main]
-  # Weekly sweep for new updates. Mondays 05:00 UTC, inside the schedule window
-  # in renovate.json5 — keep the two in step.
   schedule:
     - cron: '0 5 * * 1'
   # Manual run for an on-demand sweep from the Actions tab.

CHANGELOG.md

@@ -7,393 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-### Added
-- **Long press an event to select it.** In the day, 3-day and week views, a long press lifts the event and selects it. Keep your finger down and move to drag it straight away. A selected event has handles at its top and bottom: drag them to change when it starts or ends, in 15-minute steps and across midnight if you want. The bar at the top edits, duplicates, shares or deletes it, and tapping elsewhere or going back deselects it. Read-only events can be selected but not moved or resized ([#141]).
-- **Long press an empty slot to draft an event.** In the day, 3-day and week views, a long press on free time drops a block of your default event length there. Move it while still holding, or let go and drag it or its handles into place, then tap the tick to open a new event at that time. The ✕, a tap elsewhere or going back throws the draft away ([#153]).
-- **Tap a phone number in an event to call it.** Phone numbers in an event's title, location and description are now links. Tapping one opens your phone app with the number filled in, ready to call. A conference dial-in like "+1 646 558 8656,,850123#" brings its meeting ID along. Meeting IDs and PINs on their own, dates, times and amounts stay plain text. Long-pressing a field copies it, even when you press on a link ([#339]).
-- **Formatted event descriptions read properly.** Descriptions from Outlook, Exchange and Google Calendar are often stored as HTML, which used to show up as a wall of tags. The event view now shows them as formatted text: bold, italics, lists and links work, table rows sit on one line each, and the fonts and colours the sender picked are left out so the text matches the app. Search matches the text you see. The edit form still shows the original, so saving an event never changes its formatting ([#271]).
-- **Scroll back to earlier days in the agenda.** Scroll up past today to see earlier days' events, loaded a month at a time. Past days follow the past-events setting: Dim fades them, and with Hide the agenda still starts at today ([#367]).
-- **Create an event from shared or selected text.** Share text to Calendula, or select text in another app and pick Create event from the selection menu, and the new-event form opens with it filled in. A shared subject becomes the title, otherwise the first line does, and the rest goes into the description. The event starts at the next full hour with your default length; Calendula doesn't try to read a date out of the text. If Calendula was opened just for this, saving or closing the form takes you back to the app you came from ([#306]).
-- **Tapping an event can open the edit form.** Settings → Views → Events → Tapping an event opens can now be set to Edit form instead of Details. Taps in the views and in search then go straight to the editor for events you can edit; read-only events, reminder notifications and widgets still open the details. The editor has Duplicate, Share and Delete in its menu, and going back with unsaved changes asks whether to save, discard or keep editing ([#178]).
-- **A black theme for AMOLED screens.** Settings → Appearance → Theme now has Black next to System, Light and Dark. It's the dark theme with pure black backgrounds, which saves battery on AMOLED screens and makes event colours stand out more. Day cells and the hour grid stay a shade above black so the grid lines still show, and sheets and menus still stand out from the page. It works with Material You colours too. The home-screen widgets aren't affected ([#181]).
-
-### Fixed
-- **Event colours follow the theme you picked in Calendula.** With the app set to Dark on a phone in light mode, or the other way round, events took their colours from the phone's setting, so they could come out too pale or too dark. They now match the app's theme. Starting the app with a theme set in Calendula also no longer flashes the phone's light or dark background first ([#181]).
-- **Events on the day the clocks change show at their real time.** In the day, 3-day and week views, events later on the day of a daylight saving change were drawn an hour off, so a 14:45 event showed at 15:45. They now sit at their own time. When the clocks go back, 02:00 to 03:00 happens twice: an event in that hour now stays in the right one when you move, resize or edit it, and the editor and event details add the zone, like CEST or CET, so you can tell the two apart ([#387]).
-- **The agenda always starts today.** Coming from the month or day view, the agenda used to start at the day you had open there, so "Next 30 days" could show the 1st to the 30th of the month. It now opens on today with your chosen range. Backing out of a day you opened from the agenda still returns you to where you were ([#367]).
-- **Multi-day events dim on the days already behind you.** With past events dimmed, an event running over several days stayed at full strength on its earlier days until it ended. Those days now dim in the agenda, month, week and day views ([#367]).
-
-## [2.22.5] — 2026-10-07
-
-### Fixed
-- **Reopening the app the next morning shows the right day.** The month view used to mark yesterday as today and keep the day you picked the evening before selected, so you had to tap today to see its events. Every view now moves on to the new day at midnight and when you come back to the app. A view you browsed to another date stays where it is ([#373]).
-
-## [2.22.4] — 2026-10-07
-
-### Fixed
-- **Edits and deletions show up straight away on every phone.** On some phones, Samsung among them, an edited, moved or deleted event stayed where it was until the app was restarted, so a second edit could act on an event that had already changed. Calendula now refreshes its views itself after every change, and again when you come back to the app ([#364]).
-- **The home-screen widgets do less work per update.** The month widget loads the months around the one it shows instead of more than two years of events, and the agenda widget only its chosen range. This should help widgets that stayed on "loading" on slower phones ([#363]).
-
-## [2.22.3] — 2026-10-02
-
-### Fixed
-- **The store listing is called "Calendula: Calendar" again,** with "Calendar" in each store language. Since 2.22.0 the Play listing comes from the repository, whose title was only "Calendula". The app is unchanged ([#361]).
-
-## [2.22.2] — 2026-10-02
-
-### Fixed
-- **2.22 reaches Google Play.** The Dutch store listing used the locale code `nl`, which Play rejects, so the Play uploads of 2.22.0 and 2.22.1 failed. It now uses `nl-NL`, and CI checks every store locale against the codes Play accepts. The app is unchanged from 2.22.1 ([#359]).
-
-## [2.22.1] — 2026-10-02
-
-### Fixed
-- **Tapping a link in an event's location opens it in the browser instead of a maps app.** Links are underlined, as in the description, and tapping the rest of the location still opens maps. A link with a capitalised `Https://`, or wrapped in `<…>` the way Outlook and Teams write them, opens correctly too. When no app can open a link, a short message says so instead of the tap doing nothing ([#357]).
-
-## [2.22.0] — 2026-10-01
-
-### Added
-- **Day, Week, and Month all page with a swipeable pager that follows your finger** instead of cutting between dates ([#131], [#336]).
-- **Pages can open the split agenda.** Swipe up from a full month to reveal the compact grid and month agenda; tap a day to filter it, then swipe down to return. The transition gives haptic feedback ([#111]).
-- **A multi-day view shows a configurable number of days side by side,** with today in the first column. Set the day count in Settings ([#193]).
-- **A "Visible hours" setting fits a chosen range of hours to the screen** when Day, Week, or the new multi-day view opens; earlier and later hours stay a scroll away ([#322]).
-- **Timeline views mark events that run outside the visible hours** with a coloured edge at the top or bottom, and keep them tappable underneath it ([#188]).
-- **Week numbers open their week.** Tap a week number in the month grid to open Week at that row; Back returns to Month ([#197]).
-
 ### Changed
-- **Day, multi-day, and Week share one timeline and morph into each other** when you switch views, instead of each view rebuilding its own ([#184]).
+- Month-view event titles no longer end in an ellipsis. The "…" took the width
-- **The back gesture previews the view you're returning to** and springs back to the current one if you cancel the gesture ([#185]).
+  of a couple of characters and told you nothing you couldn't already see, so
-- **Split view opens with the month's agenda.** It starts at today in the current month; tapping a day filters the list, and the filter chip restores the full month. Swiping the list moves by day when filtered and by month otherwise ([#142]).
+  the title now simply runs to the edge of its chip — a few more letters per
-- **Today stands out in the month grid.** Its whole cell has a distinct background; tapping Today briefly expands that cell and nudges its neighbours aside ([#241]).
+  cell, which is often the difference between two events you can tell apart and
-- **All-day reminders due today or tomorrow say so** instead of spelling out the date ([#308]).
+  two you can't ([#164]).
-- **Store listing in every app language.** Google Play and F-Droid show the description in all 16 languages the app ships, and each release publishes the Play listing from the repository ([#285]).
-
-### Fixed
-- **Titles and locations stop growing at 255 characters.** Some CalDAV servers (Open-Xchange among them) silently truncate longer values on sync; Calendula now caps them first and shows a counter once you're close ([#331]).
-- **The "Calendar" launcher alias is translatable.** The "App name" setting's alternate label was hard-coded to English regardless of the app's language ([#251]).
-- **Multi-day events stay above shorter events.** Month and Week bars, Split day lists, and Agenda now place multi-day events before one-day all-day events, then timed events; declined events remain last ([#291]).
-- **Editing one occurrence of a coloured Google series saves again.** Saving with "Only this event" kept you on the edit screen without saving anything ([#338]).
-
-## [2.21.0] — 2026-09-23
-
-### Added
-- **Setup makes sure you have a calendar to write to.** A fresh install could
-  finish onboarding and land on an empty grid with nothing saying why — either
-  because the device had no calendar at all, or because every calendar it had
-  was switched off. Setup now covers both: it offers to create a calendar on
-  this device or to add an account that syncs one, and it lists the calendars
-  that exist but are switched off so you can turn them back on ([#287]).
-
-### Changed
-- **The month grid gives its days more room.** Week numbers are set smaller and
-  their gutter is measured from the widest number it has to seat instead of
-  holding a fixed 40dp; event chips spend less of their width on padding; and
-  the labels in both are tracked more tightly, which is worth roughly a
-  character per chip ([#189], [#190], [#212], [#213]).
-- **A month day shows as many events as it has height for.** The limit was a
-  flat three at every size, so a tall week row threw away space it could have
-  filled, while a cramped one drew a third chip its band could not hold and put
-  the "more" marker below the clip, where nothing showed the day held more at
-  all. It is measured per week row now, and a tablet or a landscape phone seats
-  more of them.
-- **Split view no longer pads a short month out to six rows.** A five-row month
-  was handing the day pane a blank row and its gap — a sixth of the grid. The
-  grid now draws only the rows its month spans and the pane grows into the rest
-  ([#162]).
-
-### Fixed
-- **Short events show their title in week and day view.** A block needed 20dp
-  of height before it drew any title at all, which at fit-the-whole-day put the
-  cutoff around the half hour. The padding now tapers as the block shrinks, so
-  a short event keeps its name ([#289]).
-- **A fully zoomed-out timeline sits still.** Rounding its height up left it as
-  much as a pixel per hour taller than the viewport those hours are meant to
-  fill — some 24px of leftover scroll, enough to bounce off Android's
-  overscroll stretch ([#290]).
-- **Backup & restore says what is going on instead of coming up blank.** It
-  built its rows straight from the calendar list, so loading, a provider error,
-  and a device with nothing to export all rendered as an empty page with no
-  buttons on it ([#304]).
-- **An event with no title reads in your language.** It was labelled "(Ohne
-  Titel)" on every screen but the event's own, whatever language the phone was
-  set to: the German text was chosen before the translated one could be
-  ([#321]).
-- **A calendar the system gives no name reads in your language.** The same
-  cause, in the calendar lists and pickers — and because the calendar editor
-  starts from that name, saving such a calendar wrote the German text into it
-  for real ([#329]).
-
-## [2.20.4] — 2026-09-20
-
-### Fixed
-- **The app no longer reopens the event you last came in on.** Opening an event
-  from a reminder or a home-screen widget made the app return to that same
-  event on every later launch — and show an error screen once the event had
-  been deleted. Android hands an app the launch it was started with again each
-  time it is rebuilt, and Calendula was acting on it every time instead of
-  once ([#309]).
-- **"Today" works in the agenda again.** Scrolling a few days ahead and tapping
-  today did nothing, because the agenda is browsed by scrolling rather than by
-  moving its date, and the button only moved the date. It now brings the list
-  back to today, and it stays offered while the list is scrolled away — before,
-  it was hidden in exactly the situation it is for ([#305]).
-- **Calendula is filed under "Calendar & Agenda" in the self-hosted repo.**
-  Browsing by category in an F-Droid client set to prefer that repo listed the
-  app under "Time" instead ([#294]).
-
-## [2.20.3] — 2026-09-12
-
-### Fixed
-- **A custom agenda range crashed the app in French.** Choosing a custom range
-  for the agenda — or simply typing a number into that field — closed the app on
-  any phone set to French. The French translation of the "%d days" label was
-  missing the wording French uses for counts of two and above, and Android has
-  nothing to fall back on when that particular form is absent, so every value
-  except one day was affected ([#297], [#298]).
-
-## [2.20.2] — 2026-09-12
-
-### Fixed
-- **Crash reports are filed in English.** Reporting a crash from a phone set to
-  another language prefilled the issue — title and body — in that language, so
-  a French crash arrived on Codeberg as a French issue ([#297], [#298]). The
-  text that is *posted* is now English for everyone; the dialog that asks you
-  to send it, and everything else you see in the app, is still translated.
-
-## [2.20.1] — 2026-09-07
-
-### Fixed
-- **An empty calendar now explains itself.** "No calendars configured" offered
-  an "Open system calendar settings" button that opened nothing — every screen
-  wired it to the same reload that had just produced the empty state. It now
-  opens the system's account chooser, filtered to the providers that sync
-  calendars ([#239]).
-- **Calendars that are all switched off no longer look like an empty month.**
-  When every calendar on the device is hidden at system level there is nothing
-  to draw, but the app said nothing at all: it only ever checked whether the
-  device had *no* calendars, so a device that had them and hid them fell
-  through to a blank grid with no hint. That case now says so, and points at
-  Settings → Calendars — the one screen that can switch a calendar back on. The
-  navigation drawer's calendar list drew the same conflation and is fixed with
-  it ([#239]).
-
-## [2.20.0] — 2026-09-07
-
-### Added
-- **Long-press to copy.** Holding down the title, the location or the
-  description on an event puts that whole field on the clipboard. Tapping still
-  does what it always did — the location opens maps, a link in the description
-  opens — and the times, calendar, repeat rule and guests stay uncopyable. Below
-  Android 13 a short confirmation appears; from Android 13 on the system shows
-  its own clipboard chip ([#195]).
-- **The open-source projects Calendula ships** are now listed under Settings →
-  About, each with its copyright holder and licence, and each row tapping
-  through to that project's source ([#281]).
-
-### Changed
-- Event titles no longer end in an ellipsis. The "…" took the width of a couple
-  of characters and told you nothing you couldn't already see, so the title now
-  simply runs to the edge of its chip in the month, week and day views — a few
-  more letters per event, which is often the difference between two events you
-  can tell apart and two you can't. Right-to-left languages keep the ellipsis,
-  where clipping would cut the beginning of a title rather than its end
-  ([#164]).
-- Month-view events now show their start time before the title, where the chip
-  is wide enough to keep the title readable — in landscape, on a foldable and on
-  a tablet, and never at the cost of a narrow phone column. All-day events show
-  no time, and neither does a bar carried in from the previous week, whose start
-  is not in that row. Event times across the month, week and day views are also
-  set in a regular weight against the title's, so a time reads as a time rather
-  than as part of the name next to it ([#219]).
-- **The hour lines in week and day view are now an hour grid.** The setting
-  that drew a faint separator line at each hour now seats every hour in its own
-  rounded cell, so an hour boundary reads as the seam between two surfaces
-  rather than a line drawn across one — the same negative space that separates
-  the month grid's days and the week's columns. An event that starts on the hour
-  fills its cell instead of overhanging the seam, and one that runs past
-  midnight still meets the edge of its column ([#113]).
-- **An invitation you haven't answered now reads as an outline.** An event still
-  waiting on your reply is drawn with the calendar's colour on its border and
-  its title and nothing behind it, so it stands apart from the ones you have
-  accepted — on the month chips, the all-day bars and the week and day blocks
-  alike. Declined events keep their filled, struck-through chip and now sort
-  last in the month view as well, so a day with more events than fit drops the
-  ones you said no to first ([#230]).
-- The calendar titles now shorten instead of being cut off. When the full month
-  name doesn't fit the top bar, the month and week views fall back to its
-  three-letter form and the day view drops the weekday, rather than trailing off
-  mid-word at large font sizes. The view switcher, the title and the agenda's
-  range bar also line up with the grid underneath them ([#165]).
-- The jump-to-today button in the toolbar now shows today's date. It drew a
-  generic calendar icon, which told you nothing you didn't already know from
-  tapping it; it now carries the current day number in an outlined box, so the
-  bar says what day it is as well as taking you there. It rolls over at midnight
-  on its own ([#220]).
-- The quick-switch pill disappears when there is nothing left to switch between,
-  and you can now turn calendar views off all the way down to a single one — the
-  setting used to hold two open purely to keep the pill fed ([#150]).
-
-### Fixed
-- **A long location no longer runs off the edge of its field.** The location on
-  the edit screen sat on one line, so a full postal address or a long meeting
-  link scrolled sideways out of sight as you typed it. It now wraps and the card
-  grows to fit, with the pin and the contacts button staying level with the first
-  line at any font size. A multi-line address you paste in is joined with commas
-  — the way one picked from your contacts always has been — instead of running
-  together into a single word ([#273]).
-- **The event form capitalizes sentences again.** The title, description and
-  guest fields had stopped starting a sentence with a capital letter; they
-  follow the keyboard's usual behaviour once more. The location is deliberately
-  left alone, since it is as often a URL as an address ([#146]).
-- **A block you pick up no longer loses its second line.** Dragging an event
-  whose time or title wrapped to two lines clipped the floating copy to one line
-  for as long as you held it, and it snapped back on drop. The copy now measures
-  its text exactly as the block does ([#267]).
-
-## [2.19.4] — 2026-09-01
-
-### Fixed
-- **A deleted occurrence no longer comes back when the series is re-timed.**
-  Delete a single occurrence of a repeating event, then change the time of the
-  whole series, and the occurrence you had removed reappeared. Doing it the
-  other way round — "This and all following events" — lost every removal in the
-  part of the series being changed. Removals now travel with the event: they
-  keep their place in the series across a time change, a move to a different
-  day, a timezone change and a switch to or from an all-day event, and they
-  carry over when a series is split. Repeating events on your device's own
-  calendars are affected, including the birthday and anniversary calendars
-  Calendula creates from your contacts ([#248]).
-- **Home-screen widgets now turn the page at midnight.** Both the month and the
-  agenda widget kept highlighting yesterday as "today" — and the agenda kept
-  greying out the wrong events as already past — until you paged the month back
-  and forth or removed and re-added the widget. Calendula now wakes itself at the
-  day boundary and redraws, and re-arms after a reboot, a clock change or a
-  flight into another timezone. Paging the month widget forward and back also
-  stops quietly pinning it to that month, so it follows the date again instead of
-  being stranded on the month you happened to be looking at ([#228]).
-- **"Only this event" now actually saves your edit.** On some calendars —
-  including Google ones that still show as on-device, and any local calendar —
-  editing a single occurrence of a repeating event did nothing at all: the scope
-  dialog closed, the edit screen stayed put, and saving again just repeated it.
-  Android can only attach a single-occurrence change to its series once the
-  calendar has been synced at least once, so on those calendars the change had
-  nowhere to go. Calendula now removes that one occurrence from the series and
-  saves the edit as its own event instead, which is what you see either way. A
-  save that does fail also says so for longer, rather than flashing past
-  ([#234]).
-- **A failed import no longer costs you the whole file.** One event the calendar
-  refuses used to abort the entire import with nothing on screen but "couldn't
-  read this file". Events are now added one at a time: anything rejected is
-  counted and shown, and the rest still arrive. A faulty repeat rule in the file
-  is repaired instead of being handed on ([#225]).
-- **All-day reminders survive a backup and an import.** They fire at the hour you
-  chose, not at midnight UTC — the same rule the app already applied to all-day
-  events you create yourself — and an export no longer leaves them out of the
-  file entirely. An imported yearly birthday fires at the right hour too, even
-  though the file dates it back to the year of birth ([#225]).
-- **Birthdays and anniversaries imported from Fossify Calendar now show up.**
-  Fossify writes the ones it mirrors from your contacts as events that start and
-  end on the same day, which the calendar read as lasting no time at all: they
-  imported without complaint and then appeared nowhere. Any all-day event that
-  ends where it starts, or carries no end at all, is now a one-day event
-  ([#225]).
-- **A backup no longer brings back occurrences you had deleted.** Remove a single
-  occurrence of a repeating event, back up, restore — and it was there again,
-  because the removals never made it into the file. They travel with the series
-  now, so a restored calendar looks the way you left it ([#225]).
-- **A reminder left on your account's default no longer went off as the event
-  started.** An event whose reminder says "Default" is the account's to time, not
-  Calendula's — it was reading that setting as a lead time of its own and firing a
-  minute after the event began. It now leaves such a reminder alone, and says so
-  on the event.
-- **"Only this event" on an event that doesn't repeat now edits or deletes it.**
-  Deleting used to write an exclusion onto a one-off event instead — which left
-  the event there and lost its end time — and editing filed the change away as an
-  exception to nothing, so it vanished.
-- **An import that the calendar cuts short now tells you how far it got.** Losing
-  the calendar or the permission part way through a big file reported the whole
-  import as failed, so importing again added everything twice.
-- **An event that runs past midnight can be dragged by either half.** Its second
-  half couldn't be picked up at all, and the first could only be moved later. Both
-  halves now move, and both are previewed while you hold either one, so the event
-  reads as moving rather than growing. The blocks are cut square at midnight
-  instead of rounded off, a month row draws an event crossing into the next week
-  as one bar, and a move across a daylight-saving change no longer lands an hour
-  out ([#253]).
-
-### Added
-- **More of an imported `.ics` survives the trip**: tasks come across as events
-  rather than being dropped in silence, deleted occurrences of a repeating event
-  stay deleted, a calendar named like the one the file came from is preselected,
-  and event colours are carried over — matched to the closest colour your
-  calendar's account offers, so a migrated calendar still reads at a glance
-  ([#225]).
-- **Belarusian, Hungarian and Slovak**, all three contributed as community
-  translations through
-  [Calendula's Weblate](https://weblate.dev.jeanlucmakiola.de/projects/calendula/).
-  Belarusian covers about nine tenths of the app, Slovak about a third and
-  Hungarian is just under way, so untranslated parts still show in English until
-  they fill out. Pick any of them under Settings → Language or in Android's
-  per-app language settings. Thanks to Dmitri Gabinski (Belarusian), Ábel Nagy
-  (Hungarian) and Julie (Slovak); help finishing them is very welcome.
-
-### Changed
-- **Arabic, Polish and Simplified Chinese are now complete**, all three carried
-  the rest of the way this cycle — Simplified Chinese from a fifth of the app to
-  all of it. Czech and Russian grew too — Russian to about half — and still have
-  room. Thanks to Sup99999 (Arabic), Bazyli Cyran (Polish), JeanWenzel
-  (Simplified Chinese), James Trivette (Czech), and SpiritOTHawk and Artur
-  (Russian).
-
-## [2.19.3] — 2026-08-22
-
-### Added
-- **Czech, Japanese and Russian**, all three contributed as community
-  translations through
-  [Calendula's Weblate](https://weblate.dev.jeanlucmakiola.de/projects/calendula/).
-  They are early — Czech covers about a third of the app, Russian a fifth,
-  Japanese has just started — so untranslated parts still show in English until
-  they fill out. Pick any of them under Settings → Language or in Android's
-  per-app language settings. Thanks to James Trivette (Czech), ame0011
-  (Japanese), and chip and Pablo (Russian); help finishing them is very welcome.
-
-### Changed
-- **Brazilian Portuguese is now complete**, covering the whole app. Thanks to
-  bkrz for carrying it the rest of the way.
-
-## [2.19.2] — 2026-08-17
-
-### Changed
-- **A meeting you declined is now struck through** wherever it appears — month,
-  week, day, agenda, search and both widgets — and no longer schedules a
-  reminder. Declining an invitation in Google Calendar left the event looking
-  like any other in Calendula, and it still notified you about a meeting you had
-  said no to. It stays visible rather than disappearing: the organiser still
-  expects an answer from you, and the slot is still spoken for ([#180]).
-
-### Fixed
-- **Tapping an event in month view opens the event**, not the day it sits on.
-  Every month style is affected — page, rolling, seamless weeks — and until now
-  the only way to reach an event from the month was to open its day first and
-  find it again there. Tapping anywhere else in the cell still opens the day
-  ([#187]).
-- **An edit made to an event now shows the moment you re-open it.** Adding a
-  description to an event and opening it again showed the sheet as it was before
-  the save, because the detail was only re-read when a different occurrence was
-  opened ([#196]).
-- **The month widget's arrows stopped working after a couple of taps.** The grid
-  was serialised as roughly 740 views, and one update ran to half a megabyte —
-  more than the launcher's buffer takes. The third update overran it, and Android
-  responded by dropping the whole widget host, which killed updates for *every*
-  widget on the home screen, ours and other apps', until the launcher rebound.
-  The grid now draws 192 views, and a resized widget reflows to its new size
-  instead of clipping ([#214]).
-- Tapping a widget's refresh or month arrows redraws that widget by its own id
-  instead of asking Android to update all of them, which does nothing in a
-  process the tap has just woken from cold ([#18]).
-- **Jump-to-today in seamless weeks lands on the current week** instead of
-  leaving a sliver of the previous row on screen ([#191]).
-- Day and week view no longer run their events flush against the right edge
-  ([#192]).
 
 ## [2.19.1] — 2026-08-11
 
@@ -1803,74 +1422,3 @@ automatically, with zero telemetry and no internet permission.
 [#163]: https://codeberg.org/jlmakiola/calendula/issues/163
 [#173]: https://codeberg.org/jlmakiola/calendula/issues/173
 [#164]: https://codeberg.org/jlmakiola/calendula/issues/164
-[#165]: https://codeberg.org/jlmakiola/calendula/issues/165
-[#180]: https://codeberg.org/jlmakiola/calendula/issues/180
-[#187]: https://codeberg.org/jlmakiola/calendula/issues/187
-[#191]: https://codeberg.org/jlmakiola/calendula/issues/191
-[#192]: https://codeberg.org/jlmakiola/calendula/issues/192
-[#196]: https://codeberg.org/jlmakiola/calendula/issues/196
-[#214]: https://codeberg.org/jlmakiola/calendula/issues/214
-[#225]: https://codeberg.org/jlmakiola/calendula/issues/225
-[#228]: https://codeberg.org/jlmakiola/calendula/issues/228
-[#234]: https://codeberg.org/jlmakiola/calendula/issues/234
-[#219]: https://codeberg.org/jlmakiola/calendula/issues/219
-[#248]: https://codeberg.org/jlmakiola/calendula/issues/248
-[#253]: https://codeberg.org/jlmakiola/calendula/issues/253
-[#273]: https://codeberg.org/jlmakiola/calendula/issues/273
-[#113]: https://codeberg.org/jlmakiola/calendula/issues/113
-[#220]: https://codeberg.org/jlmakiola/calendula/issues/220
-[#195]: https://codeberg.org/jlmakiola/calendula/issues/195
-[#281]: https://codeberg.org/jlmakiola/calendula/issues/281
-[#230]: https://codeberg.org/jlmakiola/calendula/issues/230
-[#150]: https://codeberg.org/jlmakiola/calendula/issues/150
-[#146]: https://codeberg.org/jlmakiola/calendula/issues/146
-[#267]: https://codeberg.org/jlmakiola/calendula/issues/267
-[#239]: https://codeberg.org/jlmakiola/calendula/issues/239
-[#297]: https://codeberg.org/jlmakiola/calendula/issues/297
-[#298]: https://codeberg.org/jlmakiola/calendula/issues/298
-[#309]: https://codeberg.org/jlmakiola/calendula/issues/309
-[#305]: https://codeberg.org/jlmakiola/calendula/issues/305
-[#294]: https://codeberg.org/jlmakiola/calendula/issues/294
-[#287]: https://codeberg.org/jlmakiola/calendula/issues/287
-[#189]: https://codeberg.org/jlmakiola/calendula/issues/189
-[#190]: https://codeberg.org/jlmakiola/calendula/issues/190
-[#212]: https://codeberg.org/jlmakiola/calendula/issues/212
-[#213]: https://codeberg.org/jlmakiola/calendula/issues/213
-[#162]: https://codeberg.org/jlmakiola/calendula/issues/162
-[#289]: https://codeberg.org/jlmakiola/calendula/issues/289
-[#290]: https://codeberg.org/jlmakiola/calendula/issues/290
-[#304]: https://codeberg.org/jlmakiola/calendula/issues/304
-[#321]: https://codeberg.org/jlmakiola/calendula/issues/321
-[#329]: https://codeberg.org/jlmakiola/calendula/issues/329
-[#285]: https://codeberg.org/jlmakiola/calendula/issues/285
-[#338]: https://codeberg.org/jlmakiola/calendula/issues/338
-[#111]: https://codeberg.org/jlmakiola/calendula/issues/111
-[#131]: https://codeberg.org/jlmakiola/calendula/issues/131
-[#142]: https://codeberg.org/jlmakiola/calendula/issues/142
-[#184]: https://codeberg.org/jlmakiola/calendula/issues/184
-[#185]: https://codeberg.org/jlmakiola/calendula/issues/185
-[#188]: https://codeberg.org/jlmakiola/calendula/issues/188
-[#193]: https://codeberg.org/jlmakiola/calendula/issues/193
-[#197]: https://codeberg.org/jlmakiola/calendula/issues/197
-[#241]: https://codeberg.org/jlmakiola/calendula/issues/241
-[#251]: https://codeberg.org/jlmakiola/calendula/issues/251
-[#291]: https://codeberg.org/jlmakiola/calendula/issues/291
-[#308]: https://codeberg.org/jlmakiola/calendula/issues/308
-[#322]: https://codeberg.org/jlmakiola/calendula/issues/322
-[#331]: https://codeberg.org/jlmakiola/calendula/issues/331
-[#336]: https://codeberg.org/jlmakiola/calendula/issues/336
-[#357]: https://codeberg.org/jlmakiola/calendula/issues/357
-[#359]: https://codeberg.org/jlmakiola/calendula/issues/359
-[#361]: https://codeberg.org/jlmakiola/calendula/issues/361
-[#363]: https://codeberg.org/jlmakiola/calendula/issues/363
-[#364]: https://codeberg.org/jlmakiola/calendula/issues/364
-[#367]: https://codeberg.org/jlmakiola/calendula/issues/367
-[#373]: https://codeberg.org/jlmakiola/calendula/issues/373
-[#141]: https://codeberg.org/jlmakiola/calendula/issues/141
-[#153]: https://codeberg.org/jlmakiola/calendula/issues/153
-[#339]: https://codeberg.org/jlmakiola/calendula/issues/339
-[#387]: https://codeberg.org/jlmakiola/calendula/issues/387
-[#271]: https://codeberg.org/jlmakiola/calendula/issues/271
-[#181]: https://codeberg.org/jlmakiola/calendula/issues/181
-[#306]: https://codeberg.org/jlmakiola/calendula/issues/306
-[#178]: https://codeberg.org/jlmakiola/calendula/issues/178

CONTRIBUTING.md

@@ -1,13 +1,13 @@
 # Contributing to Calendula
 
 Calendula is a Material 3 Expressive calendar app that lives strictly on top of
-Android's `CalendarContract`, with no app database, sync stack or network access.
+Android's `CalendarContract` — no app database, no sync stack, no network access.
-That constraint shapes most review comments, so skim
+That constraint shapes most review comments, so
-[`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) before you write code. This file
+[`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) is worth skimming before you write
-covers the practical side.
+code. This file is the practical how.
 
-[Codeberg](https://codeberg.org/jlmakiola/calendula) is the canonical home for
+**[Codeberg](https://codeberg.org/jlmakiola/calendula) is the canonical home** —
-issues, pull requests and releases. The self-hosted Gitea instance referenced in the
+issues, pull requests, releases. The self-hosted Gitea instance referenced in the
 release docs is build infrastructure only; there is nothing to contribute there.
 Be decent to the people you meet in the tracker.
 
@@ -18,20 +18,20 @@ Be decent to the people you meet in the tracker.
 | Add a feature | **Open an issue first** and wait for a go-ahead |
 | Fix a bug | Open an issue, then a pull request |
 | Fix a typo, a comment, or docs | Just open the pull request |
-| Add or fix a translation | Use [Weblate](#translations), not a pull request |
+| Add or fix a translation | **Don't** — [use Weblate](#translations) |
 
 Features get an opinion before they get code: whether Calendula should do a
 thing at all is the one decision a patch can't make. A feature PR that arrives
-without a discussed issue may be closed unmerged even when the code is good, so
+without a discussed issue may be closed unmerged even when the code is good —
 please don't spend a weekend on one first.
 
 Bugs are more straightforward, but still start with an issue: it's what carries
 the milestone and gives the changelog something to link.
 
 Issue templates cover bug, crash, feature and question. For a crash, let the app
-do the work: *Settings → Report a problem*, or the prompt shown after a crash,
+do the work — **Settings → Report a problem**, or the prompt shown after a crash,
 captures the stack trace and prefills the form. The report contains app, Android
-and device versions plus the trace, and no calendar content or personal data.
+and device versions plus the trace; no calendar content, no personal data.
 
 ## Which branch to target
 
@@ -45,20 +45,20 @@ Once your issue has a milestone, that milestone names your branch:
 | `2.18.0` | `release/v2.18.0` |
 
 Every milestone has a matching branch. If it's somehow missing, target `main` and
-mention it in the PR, and it will be retargeted. Don't pick an older release branch:
+mention it in the PR — it will be retargeted. Don't pick an older release branch:
 they're kept after shipping, so the newest one isn't necessarily yours.
 
 ## Translations
 
-**Never edit a `values-*/strings.xml` file in a pull request**, German included.
+**Never edit a `values-*/strings.xml` file in a pull request** — German included.
 Translations are owned by a self-hosted Weblate that writes to this repository
 directly, and a hand-edit is overwritten on the next sync.
 
-[Translate Calendula on Weblate](https://weblate.dev.jeanlucmakiola.de/engage/calendula/)
+→ **[Translate Calendula on Weblate](https://weblate.dev.jeanlucmakiola.de/engage/calendula/)**
 
 Adding a *new* English string to `values/strings.xml` is normal PR work; Weblate
 picks it up and offers it to translators. Partial translations are expected and
-fine; missing keys are informational. Stale and orphaned keys are not, so run
+fine — missing keys are informational. Stale and orphaned keys are not, so run
 
 ```sh
 python3 scripts/check_translations.py
@@ -67,7 +67,7 @@ python3 scripts/check_translations.py
 before pushing. It reports those more clearly than lint's `MissingTranslation`
 does.
 
-## Build and test
+## Build & test
 
 ```sh
 git clone --recurse-submodules https://codeberg.org/jlmakiola/calendula.git
@@ -77,11 +77,11 @@ The `floret-kit` submodule is a composite build compiled from source. An
 existing clone needs `git submodule update --init --recursive`, or nothing
 resolves.
 
-- **JDK 17**, not newer: the Android Gradle Plugin requires exactly 17. Set
+- **JDK 17** — not newer; the Android Gradle Plugin requires exactly 17. Set
   `JAVA_HOME` if your default differs.
-- **Android SDK**: platform 37 (`compileSdk`) and build-tools 36.0.0, located
+- **Android SDK** — platform 37 (`compileSdk`) and build-tools 36.0.0, located
   via `ANDROID_HOME` or a gitignored `local.properties` with `sdk.dir`. If you
-  go the `local.properties` route, the included build needs its own copy at
+  go the `local.properties` route the included build needs its own copy at
   `floret-kit/local.properties`; `ANDROID_HOME` covers both at once and is the
   easier path.
 
@@ -109,21 +109,21 @@ These are the ones that turn into review comments.
 
 1. **No network.** Calendula holds no `INTERNET` permission, and that's a
    feature rather than an oversight. Anything that would need one is a product
-   decision before it's a patch. The crash reporter opens a prefilled web issue
+   decision before it's a patch — the crash reporter deliberately opens a
-   on purpose instead of posting anything itself.
+   prefilled web issue instead of posting anything itself.
 2. **The provider is the only database.** No Room, no cache, no local mirror of
    events. `CalendarContract` is the single source of truth, which is also why
    externally synced changes work for free.
 3. **Don't patch UI state after a write.** A `ContentObserver` re-queries and
    views recompose from fresh provider state. Hand-patching a list after saving
-   appears to work, then drifts away from what the provider stored.
+   appears to work, then quietly diverges from what the provider actually stored.
 4. **`domain/` has no Android imports.** Models, validation, recurrence
    rendering, conflict snapshots and the `.ics` codec stay pure Kotlin so they
    remain JVM-testable.
 5. **Tests run on the JVM.** JUnit 5 + Truth + Turbine. The seams exist for you:
    fake the data source (`FakeCalendarDataSource`), and feed mappers plain maps
    through `ColumnReader` instead of cursors. Instrumented tests are a last
-   resort.
+   resort, not a default.
 6. **Read before touching the subtle pipelines.** Recurring writes (UNTIL vs
    DURATION, exception URIs, series splits), save-conflict detection and reminder
    delivery (post-before-mark) follow provider-driven rules that are documented
@@ -138,14 +138,14 @@ These are the ones that turn into review comments.
 ## UI conventions
 
 Material 3 Expressive throughout, built from the system's own tokens and
-components: colour-scheme tokens rather than hardcoded colours, `ListItem` for
+components — colour-scheme tokens rather than hardcoded colours, `ListItem` for
 settings rows.
 
 **Selection pickers are full-screen.** Every browse-style "choose one" surface
 uses floret-kit's `FullScreenPicker` / `OptionPicker`; one that needs a commit or
 extra action passes it through the picker's `actions` slot. The exception is the
 recurring-scope chooser (*this / this and following / all*), which stays a
-compact dialog, because a two- or three-option decision reads better as a popup than as
+compact dialog — a two- or three-option decision reads better as a popup than as
 a nearly empty screen. `AlertDialog` is for plain confirmations only, and radio-
 or text-list dialogs aren't used at all.
 
@@ -154,7 +154,7 @@ Shared UI machinery lives in the `floret-kit` submodule and has
 changing it means a pull request against that repository plus a submodule bump
 here.
 
-## Commits and pull requests
+## Commits & pull requests
 
 Conventional commits, scoped to the area you touched:
 
@@ -165,13 +165,13 @@ docs(architecture): record what the second review pass changed
 ```
 
 Types in use: `feat` `fix` `docs` `refactor` `style` `chore` `ci` `build`
-`revert`. Reference the issue in the subject or the body. Keep commits small.
+`revert`. Reference the issue in the subject or the body. Keep commits small —
-Small commits revert cleanly, which matters more here than a tidy history.
+small commits revert cleanly, which matters more here than a tidy history.
 
 If your change is user-visible, add an entry under `## [Unreleased]` in
 [`CHANGELOG.md`](CHANGELOG.md). Match the surrounding voice: entries describe
-what changed *for the person using the app*, and why. Code changes don't go
+what changed *for the person using the app*, and why, not what changed in the
-there. Link the issue and add its reference at the bottom of the file. It may get
+code. Link the issue and add its reference at the bottom of the file. It may get
 reworded when the release is cut, so don't agonise over it.
 
 Please don't commit planning or design documents. Code, tests, architecture notes

README.md

@@ -4,8 +4,8 @@
 
 <h1>Calendula</h1>
 
-<p><strong>A Material 3 Expressive calendar for Android.</strong><br>
+<p><strong>A modern Material 3 Expressive calendar for Android.</strong><br>
-It works on top of the system calendar and has no network access.</p>
+Reads, writes, and reminds — on top of the system calendar, with zero network access.</p>
 
 <p>
 <a href="https://codeberg.org/jlmakiola/calendula/actions"><img src="https://codeberg.org/jlmakiola/calendula/actions/workflows/ci.yaml/badge.svg?branch=main" alt="CI"></a>
@@ -18,97 +18,90 @@ It works on top of the system calendar and has no network access.</p>
 <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>
 </p>
 
 <p>
-<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/01-week.png" width="13%" alt="Week view">&nbsp;
+<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/01-week.png" width="16%" alt="Week view">&nbsp;
-<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/02-month.png" width="13%" alt="Month view">&nbsp;
+<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/02-month.png" width="16%" alt="Month view">&nbsp;
-<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/03-agenda.png" width="13%" alt="Agenda view">&nbsp;
+<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/03-day.png" width="16%" alt="Day view">&nbsp;
-<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/04-detail.png" width="13%" alt="Event detail">&nbsp;
+<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/04-detail.png" width="16%" alt="Event detail">&nbsp;
-<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/05-recurring.png" width="13%" alt="Editing a recurring event">&nbsp;
+<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/05-agenda.png" width="16%" alt="Agenda view">&nbsp;
-<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/06-calendars.png" width="13%" alt="Calendars from your accounts">&nbsp;
+<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/06-onboarding.png" width="16%" alt="Reminder onboarding">
-<img src="fastlane/metadata/android/en-US/images/phoneScreenshots/07-dark.png" width="13%" alt="Dark theme">
 </p>
 
 </div>
 
-Calendula is named after the flower. Both its name and the word *calendar*
+Calendula is named after the flower whose name — like the word *calendar* —
-come from the Latin *kalendae*, the first day of the month.
+comes from the Latin *kalendae*, the first day of the month. It lives
+entirely on top of Android's `CalendarContract`: any calendar synced to your
+device (CalDAV via DAVx5, Google, local, WebCal subscriptions, …) simply
+appears, and everything you create or edit syncs back the same way. No own
+database, no sync stack reinvented.
 
-The app works directly on Android's `CalendarContract`. Any calendar synced to
+## ✨ Features
-your device (CalDAV via DAVx5, Google, local, WebCal subscriptions) shows up in
-Calendula, and whatever you create or edit syncs back the same way. Calendula
-has no database or sync code of its own.
 
-## Features
+**Calendar**
 
-### Calendar
+- Month, week, and day views with a one-tap view switcher
+- Full event details — attendees and their responses, reminders, recurrence
+  (humanized), availability, visibility, foreign time zones
+- Per-calendar visibility toggle, grouped by account
 
-- Month, week and day views, with a switcher in the top bar
+**Editing**
-- Event details with attendees and their responses, reminders, recurrence in
-  plain words, availability, visibility and foreign time zones
-- Calendars can be shown or hidden one by one, grouped by account
-- Your contacts' birthdays, anniversaries and other dates, if you turn it on.
-  Contacts are read on the device and never changed.
 
-### Editing
+- Create, edit, and delete events — including recurring events with scoped
+  writes: *only this event*, *this and all following*, or *the whole series*
+- Recurrence picker with one-tap presets and custom rules (interval, weekday
+  toggles, end conditions); rules it can't express are preserved verbatim
+- Conflict-safe saves: if an event changed elsewhere while you were editing,
+  Calendula asks instead of silently overwriting
+- Read-only calendars (WebCal, birthdays) are detected and respected
 
-- Create, edit and delete events. For a recurring event you choose whether a
+**Reminders**
-  change applies to *only this event*, *this and all following*, or *the whole
-  series*.
-- The repeat picker has presets and custom rules (interval, weekdays, end
-  condition). Rules it can't show are kept as they are.
-- If an event changed elsewhere while you were editing it, Calendula asks
-  before saving over it.
-- Read-only calendars such as WebCal subscriptions and birthdays are detected
-  and can't be edited by accident.
 
-### Reminders
+- Event reminders delivered by Calendula itself as notifications —
+  essential when it's your only calendar app, since Android delegates
+  reminder delivery to calendar apps
+- Tap a reminder to land on the event
 
-- Calendula shows event reminders as notifications itself. Android leaves
+**Design & privacy**
-  reminder delivery to calendar apps, so if Calendula is your only one, this is
-  where your reminders come from.
-- Tapping a reminder opens the event.
 
-### Design and privacy
+- Real Material 3 Expressive throughout — dynamic color (Android 12+),
+  expressive motion and shapes, light/dark theme
+- English and German UI plus community translations (Spanish, French, Italian,
+  Polish, and more in progress), per-app language setting — and [open to more
+  languages](#-translations)
+- **Zero telemetry, zero analytics, no internet permission** — your data
+  never leaves the device
 
-- Material 3 Expressive throughout, with dynamic color on Android 12+, light
+## 📦 Install
-  and dark themes, and expressive motion and shapes
-- Available in 16 languages, with a per-app language setting.
-  [Help translate](#translations).
-- No telemetry, no analytics and no internet permission. Your data stays on
-  the device.
 
-## Install
+Pick whichever channel you already use — they all install the same app:
-
-All channels install the same app:
 
 | Channel | Updates | Notes |
 | --- | --- | --- |
 | [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; add the repo once |
+| [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 automatic with Obtainium |
+| [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)
 
-Calendula is in the official [F-Droid](https://f-droid.org) repository. Search
+Calendula is on the **official [F-Droid](https://f-droid.org) repository** —
-for Calendula in any F-Droid client, or
+just search for **Calendula** in any F-Droid client, or
 [install it from f-droid.org](https://f-droid.org/packages/de.jeanlucmakiola.calendula/).
 
-F-Droid builds from source on its own schedule, so a new version usually shows
+F-Droid rebuilds from source on its own schedule, so a new version usually
-up there a few days after release.
+shows up there a few days after release.
 
 ### Self-hosted F-Droid repo (fastest updates)
 
-The release pipeline builds, signs and publishes every release to a
+Every release is built, signed, and published to a self-hosted F-Droid
-self-hosted F-Droid repository, so new versions land there first. Add it once
+repository as part of the release pipeline, so it lands there first. Add it once
 and your F-Droid client handles updates from then on:
 
 1. In your F-Droid client, open *Settings → Repositories → Add* (or open the
@@ -122,87 +115,80 @@ and your F-Droid client handles updates from then on:
    fingerprint (SHA-256):
    `C2C0 6404 02BF 458F C0ED 957A F0B3 7AA4 C140 22E7 2F89 CE90 B596 5B45 8CF7 3425`</sub>
 
-2. Refresh, search for Calendula and install it.
+2. Refresh, search for **Calendula**, install.
 
 ### Codeberg release / Obtainium
 
-Every release is also on
+If you'd rather not use F-Droid at all, every release is also published on
-[Codeberg](https://codeberg.org/jlmakiola/calendula/releases) with the signed
+**[Codeberg](https://codeberg.org/jlmakiola/calendula/releases)** with the
-APK (`calendula_vX.Y.Z.apk`) and a `.sha256` checksum. Download it and install
+signed APK (`calendula_vX.Y.Z.apk`) and a `.sha256` checksum attached — download
-it directly.
+and install it directly.
 
-For automatic updates from Codeberg, use
+For automatic updates from that channel, use
-[Obtainium](https://github.com/ImranR98/Obtainium). On your phone,
+**[Obtainium](https://github.com/ImranR98/Obtainium)** — on the phone,
-[add Calendula in one tap](https://apps.obtainium.imranr.dev/redirect?r=obtainium://add/https://codeberg.org/jlmakiola/calendula),
+**[add Calendula in one tap](https://apps.obtainium.imranr.dev/redirect?r=obtainium://add/https://codeberg.org/jlmakiola/calendula)**,
-or add it by hand: *Add App*, paste `https://codeberg.org/jlmakiola/calendula`,
+or do it by hand: *Add App* → paste `https://codeberg.org/jlmakiola/calendula`
-then *Add*. Obtainium then watches the releases and tells you when a new one
+→ *Add*. Either way, Obtainium tracks the releases and prompts you when a new
-is out. Betas of upcoming versions are published there too, as pre-releases; to
+one appears.
-test them, switch on *Include prereleases* for Calendula in Obtainium.
 
-### Google Play
+### Google Play (coming soon)
 
-Calendula is on
+Calendula is on its way to Google Play as an additional channel. It isn't live
-[Google Play](https://play.google.com/store/apps/details?id=de.jeanlucmakiola.calendula).
+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
+> **Testers wanted.** Play requires a round of closed testing before the app can
-Play and any other channel means uninstalling first. You lose the app settings.
+> go public, and I'm still looking for testers. If you'd like to help, email
-Your events live in the system calendar and aren't affected.
+> **[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
 
-It's a plain Gradle build with no proprietary dependencies. See
+The build is a plain Gradle build with no proprietary dependencies — see
-[docs/BUILDING.md](docs/BUILDING.md), and note the `floret-kit` submodule.
+**[docs/BUILDING.md](docs/BUILDING.md)** (note the `floret-kit` submodule).
 
-<sub>Official F-Droid, the self-hosted repo and the Codeberg releases share the
+<sub>Official F-Droid, the self-hosted repo, and the Codeberg releases all share
-same signing key, so you can switch between them without reinstalling. Google
+the same signing key, so you can switch freely between them without
-Play is the exception (see above).</sub>
+reinstalling.</sub>
 
-## Documentation
+## 📚 Documentation
 
-- [Contributing](CONTRIBUTING.md): how to report bugs, propose features and send patches
+- **[Contributing](CONTRIBUTING.md)** — how to report, propose, and patch
-- [Building from source](docs/BUILDING.md): requirements and Gradle tasks
+- **[Building from source](docs/BUILDING.md)** — requirements and Gradle tasks
-- [Architecture](docs/ARCHITECTURE.md): the layers and the main pipelines
+- **[Architecture](docs/ARCHITECTURE.md)** — the layered design and key pipelines
-- [Milestones](https://codeberg.org/jlmakiola/calendula/milestones): what has shipped and what's next
+- **[Milestones](https://codeberg.org/jlmakiola/calendula/milestones)** — what's shipped and what's next
-- [Privacy policy](docs/PRIVACY.md): the source of the page at
-  [jeanlucmakiola.de/calendula/privacy](https://jeanlucmakiola.de/calendula/privacy)
 
-## Contributing
+## 🤝 Contributing
 
-Bug reports, ideas and patches are welcome on
+Bug reports, ideas, and patches are all welcome on
-[Codeberg](https://codeberg.org/jlmakiola/calendula/issues).
+**[Codeberg](https://codeberg.org/jlmakiola/calendula/issues)**.
 
-Start with an issue. A feature gets a yes or no before anyone writes code, and
+The short version: **start with an issue.** Features get a yes-or-no before they
-features and bugs are assigned a milestone whose `release/vX.Y.Z` branch your
+get code, and both features and bugs are assigned a milestone whose
-pull request targets. Typo and docs fixes can go straight to a pull request.
+`release/vX.Y.Z` branch your pull request then targets. Typo and docs fixes can
-Translations go through [Weblate](#translations), not pull requests.
+skip straight to a pull request. Translations don't go through pull requests at
+all — [Weblate owns them](#-translations).
 
-Read [CONTRIBUTING.md](CONTRIBUTING.md) before writing code. It covers the
+Read **[CONTRIBUTING.md](CONTRIBUTING.md)** before writing code: it covers the
-workflow, the build (including the `floret-kit` submodule) and the
+workflow, the build (note the `floret-kit` submodule), and the architectural
-architectural rules changes are reviewed against.
+rules a change is reviewed against.
 
-## Translations
+## 🌍 Translations
 
-Calendula is written in English. Translators on Weblate have added Arabic,
+Calendula ships in English and German, with community translations in Arabic,
-Belarusian, Chinese (Simplified), Czech, French, German, Hungarian, Italian,
+Chinese, French, Italian, Polish, Portuguese, Russian, and Spanish at varying
-Japanese, Polish, Portuguese (Portugal and Brazil), Russian, Slovak and Spanish,
+degrees of completeness — partial is fine, untranslated strings simply fall back
-some of them partly. Untranslated strings fall back to English, so a partial
+to English. You're warmly invited to add or finish your language. Translations
-translation is fine. Translations are managed on a self-hosted Weblate:
+are managed on a self-hosted **Weblate**:
 
-[Help translate Calendula](https://weblate.dev.jeanlucmakiola.de/engage/calendula/)
+**→ [Help translate Calendula](https://weblate.dev.jeanlucmakiola.de/engage/calendula/)**
 
-You don't need to code. Register on the Weblate server, pick a language (or
+No coding needed — register on the Weblate server, pick (or request) a language,
-request one) and translate in your browser. The app links here from the top of
+and translate the strings in your browser. You can also reach this link in the
-*Settings → App language*.
+app from the top of **Settings → App language**.
 
-## Privacy
+## 📜 License
 
-Calendula has no analytics, tracking, ads, crash-reporting SDK or third-party
+[MIT](LICENSE) — Jean-Luc Makiola, 2026
-services. It doesn't have the internet permission, so it can't send anything
-anywhere. Your events stay in Android's own calendar store.
-
-[Privacy policy](https://jeanlucmakiola.de/calendula/privacy), written in
-[`docs/PRIVACY.md`](docs/PRIVACY.md), which is what that page renders.
-
-## License
-
-[MIT](LICENSE), Jean-Luc Makiola, 2026

app/build.gradle.kts

@@ -26,14 +26,10 @@ android {
         // These committed values ARE the source of truth for a release: merging
         // a bumped versionName into main triggers .gitea/workflows/release.yaml,
         // which builds this version and then creates the matching vX.Y.Z tag +
-        // release itself. A versionName of X.Y.Z-beta.N pushed to a release/*
+        // release itself (versionCode is pinned to MAJOR*10000 + MINOR*100 +
-        // branch instead cuts a Codeberg-only pre-release (beta.yaml).
+        // PATCH from versionName, e.g. 2.7.2 -> 20702). See docs/RELEASING.md.
-        // versionCode is derived from versionName by scripts/version_info.sh
+        versionCode = 21901
-        // (up to 2.22.3: 2.22.3 -> 22203; from 2.22.4: 2.23.0-beta.1 -> 2230001,
+        versionName = "2.19.1"
-        // 2.22.4 -> 2220499), and CI fails if the committed one doesn't match.
-        // See docs/RELEASING.md.
-        versionCode = 2230004
-        versionName = "2.23.0-beta.4"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -117,16 +113,12 @@ android {
     lint {
         // Community translations are expected to be partial — a missing string
         // falls back to the English base at runtime — so don't fail the build on
-        // it. A translated <plurals> may likewise skip a CLDR quantity form its
+        // it. Likewise a translated <plurals> may not fill every CLDR quantity
-        // locale defines (e.g. Arabic "zero"): Android falls back to "other" for
+        // form its locale defines (e.g. Arabic needs "zero"); the missing form
-        // any form it cannot find, so MissingQuantity is informational too.
+        // falls back to "other" at runtime, so MissingQuantity is informational
-        // What a translation must NOT skip is "other" itself — nothing falls back
+        // too. Stale/extra keys (ExtraTranslation) stay fatal; scripts/
-        // for that one, not even the base locale, so it throws
+        // check_translations.py guards the same invariants with clearer,
-        // Resources$NotFoundException at runtime (Codeberg #297/#298).
+        // translator-facing messages.
-        // MissingQuantity doesn't tell the two cases apart, so that invariant is
-        // enforced by scripts/check_translations.py instead, with a clearer
-        // translator-facing message. Stale/extra keys (ExtraTranslation) stay
-        // fatal.
         informational += listOf("MissingTranslation", "MissingQuantity")
     }
 
@@ -175,10 +167,7 @@ dependencies {
     implementation("de.jeanlucmakiola.floret:core-time")
     implementation("de.jeanlucmakiola.floret:core-locale")
     implementation("de.jeanlucmakiola.floret:core-crash")
-    implementation("de.jeanlucmakiola.floret:core-di")
-    implementation("de.jeanlucmakiola.floret:core-prefs")
     implementation("de.jeanlucmakiola.floret:core-reminders")
-    implementation("de.jeanlucmakiola.floret:core-android")
     implementation("de.jeanlucmakiola.floret:identity")
     implementation("de.jeanlucmakiola.floret:components")
     implementation(libs.kotlinx.coroutines.core)

app/proguard-rules.pro

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

app/src/androidTest/java/de/jeanlucmakiola/calendula/data/calendar/MoveEventExceptionsTest.kt

@@ -1,91 +0,0 @@
-package de.jeanlucmakiola.calendula.data.calendar
-
-import android.Manifest
-import android.content.ContentUris
-import android.content.ContentValues
-import android.provider.CalendarContract
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.test.rule.GrantPermissionRule
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.domain.toEditForm
-import kotlinx.datetime.TimeZone
-import org.junit.Rule
-import org.junit.Test
-import org.junit.runner.RunWith
-
-/**
- * Moving a synced series keeps its deleted and edited occurrences, although the
- * moved row has no `_sync_id` for exception rows to attach to.
- */
-@RunWith(AndroidJUnit4::class)
-class MoveEventExceptionsTest {
-
-    @get:Rule
-    val permissionRule: GrantPermissionRule = GrantPermissionRule.grant(
-        Manifest.permission.READ_CALENDAR,
-        Manifest.permission.WRITE_CALENDAR,
-    )
-
-    private val context = InstrumentationRegistry.getInstrumentation().targetContext
-    private val resolver = context.contentResolver
-    private val ds = AndroidCalendarDataSource(context)
-    private val zone = TimeZone.currentSystemDefault()
-
-    private val day = 86_400_000L
-    private val start = 1_893_492_000_000L // 2030-01-01T10:00Z
-    private val hour = 3_600_000L
-
-    /** "day offset:title" of every instance on [calendarId]. */
-    private fun occurrences(calendarId: Long): List<String> =
-        ds.instances(start - day, start + 10 * day)
-            .filter { it.calendarId == calendarId }
-            .map { "${(it.start.toEpochMilliseconds() - start) / day}:${it.title}" }
-            .sorted()
-
-    @Test
-    fun movedSeriesKeepsCancelledAndModifiedOccurrences() {
-        val a = ds.createLocalCalendar("move-test-a", 0xFF336699.toInt(), null)
-        val b = ds.createLocalCalendar("move-test-b", 0xFF993366.toInt(), null)
-        try {
-            val src = insertSyncedSeries(a)
-            ds.deleteOccurrence(src, start + 2 * day)
-            val occurrence = ds.eventDetail(src, 540)!!.toEditForm(start + 3 * day, start + 3 * day + hour, zone)
-            ds.updateOccurrence(src, start + 3 * day, occurrence, occurrence.copy(title = "edited"), 540)
-            val expected = listOf("0:series", "1:series", "3:edited", "4:series")
-            assertThat(occurrences(a)).isEqualTo(expected)
-
-            val form = ds.eventDetail(src, 540)!!.toEditForm(start, start + hour, zone)
-            ds.moveEvent(src, b, form, form, 540)
-
-            assertThat(occurrences(a)).isEmpty()
-            assertThat(occurrences(b)).isEqualTo(expected)
-        } finally {
-            ds.deleteCalendar(a)
-            ds.deleteCalendar(b)
-        }
-    }
-
-    /** A daily series carrying a `_sync_id`, so its exceptions are real exception rows. */
-    private fun insertSyncedSeries(calendarId: Long): Long {
-        val accountName = resolver.query(
-            ContentUris.withAppendedId(CalendarContract.Calendars.CONTENT_URI, calendarId),
-            arrayOf(CalendarContract.Calendars.ACCOUNT_NAME), null, null, null,
-        )!!.use { it.moveToFirst(); it.getString(0) }
-        val uri = CalendarContract.Events.CONTENT_URI.buildUpon()
-            .appendQueryParameter(CalendarContract.CALLER_IS_SYNCADAPTER, "true")
-            .appendQueryParameter(CalendarContract.Calendars.ACCOUNT_NAME, accountName)
-            .appendQueryParameter(CalendarContract.Calendars.ACCOUNT_TYPE, CalendarContract.ACCOUNT_TYPE_LOCAL)
-            .build()
-        val values = ContentValues().apply {
-            put(CalendarContract.Events.CALENDAR_ID, calendarId)
-            put(CalendarContract.Events.TITLE, "series")
-            put(CalendarContract.Events.DTSTART, start)
-            put(CalendarContract.Events.DURATION, "P3600S")
-            put(CalendarContract.Events.RRULE, "FREQ=DAILY;COUNT=5")
-            put(CalendarContract.Events.EVENT_TIMEZONE, "UTC")
-            put(CalendarContract.Events._SYNC_ID, "move-test-series")
-        }
-        return ContentUris.parseId(resolver.insert(uri, values)!!)
-    }
-}

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

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

app/src/main/AndroidManifest.xml

@@ -151,19 +151,6 @@
                 <data android:mimeType="application/ics" />
             </intent-filter>
 
-            <!-- Text shared or selected in another app opens a prefilled new
-                 event (MainActivity.sharedTextExtrasOrNull, issue #306). -->
-            <intent-filter>
-                <action android:name="android.intent.action.SEND" />
-                <category android:name="android.intent.category.DEFAULT" />
-                <data android:mimeType="text/plain" />
-            </intent-filter>
-            <intent-filter android:label="@string/process_text_create_event">
-                <action android:name="android.intent.action.PROCESS_TEXT" />
-                <category android:name="android.intent.category.DEFAULT" />
-                <data android:mimeType="text/plain" />
-            </intent-filter>
-
             <!-- Let another app or widget (e.g. the Todo Agenda widget) launch us
                  to create a new event, the way the AOSP calendar accepts it:
                  ACTION_INSERT on the events *dir* mime type, carrying the new
@@ -343,13 +330,9 @@
         </receiver>
 
         <!-- Keeps both widgets fresh: the calendar provider broadcasts
-             PROVIDER_CHANGED on any data change (our writes and external sync).
+             PROVIDER_CHANGED on any data change (our writes and external sync),
-             The day boundary arrives as the app's own ROLLOVER alarm (#228), by
+             and the system broadcasts the date/time ones at midnight / clock
-             explicit PendingIntent, so it needs no filter here; DATE_CHANGED is
+             changes so "today" highlighting rolls over. -->
-             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. -->
         <receiver
             android:name=".widget.WidgetUpdateReceiver"
             android:exported="true">
@@ -363,8 +346,6 @@
                 <action android:name="android.intent.action.DATE_CHANGED" />
                 <action android:name="android.intent.action.TIME_SET" />
                 <action android:name="android.intent.action.TIMEZONE_CHANGED" />
-                <action android:name="android.intent.action.BOOT_COMPLETED" />
-                <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
             </intent-filter>
         </receiver>
 

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

@@ -10,7 +10,6 @@ import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesScheduler
 import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesSyncWorker
 import de.jeanlucmakiola.calendula.data.reminders.ReminderMaintenanceScheduler
 import de.jeanlucmakiola.calendula.data.reminders.ReminderMaintenanceWorker
-import de.jeanlucmakiola.calendula.widget.WidgetRolloverScheduler
 import de.jeanlucmakiola.floret.crash.CrashConfig
 import de.jeanlucmakiola.floret.crash.CrashReporter
 import kotlinx.coroutines.CoroutineScope
@@ -32,34 +31,19 @@ class CalendulaApp : Application() {
         // respecting, on-device; the user submits the report by hand). The
         // capture/loop-detection/report machinery lives in floret-kit's
         // core-crash; only the app label + issue-tracker URLs are app-specific.
-        // The prefilled issue's own title and body are the kit's, in English:
-        // they are posted to the tracker, so they don't follow the device
-        // language the way the dialog around them does.
         CrashReporter.install(
             this,
             CrashConfig(
                 appLabel = getString(R.string.app_name),
                 newIssueUrl = getString(R.string.report_issue_url),
                 chooseIssueUrl = getString(R.string.report_issue_choose_url),
+                issueTitle = getString(R.string.crash_report_issue_title),
             ),
         )
         reconcileAutoBackup()
         reconcileSpecialDates()
         reconcileCalendarVisibility()
         startReminderDelivery()
-        reconcileWidgetRollover()
-    }
-
-    /**
-     * Re-arm the widgets' midnight rollover from whatever is actually placed
-     * (#228). Idempotent, and it covers what no broadcast reaches — an alarm
-     * dropped by a force-stop is armed again the next time the app is opened.
-     * Off the main thread: a handful of binder calls on every process start.
-     */
-    private fun reconcileWidgetRollover() {
-        CoroutineScope(SupervisorJob() + Dispatchers.Default).launch {
-            WidgetRolloverScheduler.sync(this@CalendulaApp)
-        }
     }
 
     /**

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

@@ -25,22 +25,13 @@ import androidx.core.content.IntentCompat
 import androidx.core.net.toUri
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.lifecycle.lifecycleScope
 import dagger.hilt.android.AndroidEntryPoint
-import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.prefs.ThemeMode
-import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
-import de.jeanlucmakiola.floret.prefs.ThemeMode
-import de.jeanlucmakiola.floret.prefs.isDark
-import de.jeanlucmakiola.floret.prefs.isPureBlack
 import de.jeanlucmakiola.calendula.data.prefs.is24Hour
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.buildInsertEventForm
-import de.jeanlucmakiola.calendula.domain.sharedTextOrNull
-import de.jeanlucmakiola.calendula.ui.ExternalRequests
-import de.jeanlucmakiola.calendula.ui.InsertRequest
 import de.jeanlucmakiola.calendula.ui.RootScreen
-import de.jeanlucmakiola.calendula.ui.common.LocalShowHourGrid
+import de.jeanlucmakiola.calendula.ui.common.LocalShowHourLines
-import de.jeanlucmakiola.calendula.ui.common.LocalMultiDayCount
 import de.jeanlucmakiola.calendula.ui.common.LocalTimelineZoom
 import de.jeanlucmakiola.calendula.ui.common.rememberTimelineZoom
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
@@ -57,43 +48,47 @@ import de.jeanlucmakiola.floret.crash.CrashReportDialog
 import de.jeanlucmakiola.floret.crash.CrashReporter
 import de.jeanlucmakiola.floret.crash.submitCrashReport
 import de.jeanlucmakiola.calendula.ui.theme.CalendulaTheme
-import de.jeanlucmakiola.calendula.ui.theme.WindowThemeCache
-import de.jeanlucmakiola.calendula.ui.theme.windowBackgroundRes
 import de.jeanlucmakiola.calendula.ui.theme.calendulaTypography
 import de.jeanlucmakiola.calendula.ui.theme.resolveFontFamily
-import kotlinx.coroutines.launch
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Clock
 import kotlin.time.Instant
-import javax.inject.Inject
+
+/** A prefilled create form from an external launch, with the source it came from. */
+private data class InsertRequest(val form: EventForm, val source: ImportSource)
 
 @AndroidEntryPoint
 class MainActivity : AppCompatActivity() {
 
-    @Inject lateinit var calendarRepository: CalendarRepository
-    @Inject lateinit var settingsPrefs: SettingsPrefs
-
     // Which of light/dark the system bars are drawn for. The styles installed
     // in onCreate read this field live, so androidx's config-change replay
     // picks up the in-app override instead of the night resource qualifier.
     private var systemBarsDark = false
 
-    private val requests = ExternalRequests(
+    // The occurrence a reminder notification was tapped for (eventId, begin,
-        onExternalFormClosed = {
+    // end — the detail screen's key shape). singleTop + onNewIntent route a
-            insertFormOpen = false
+    // tap into the running activity; CalendarHost consumes and clears it.
-            if (launchedForInsert) finish()
+    private var requestedDetailKey by mutableStateOf<LongArray?>(null)
-        },
-    )
 
-    // Whether such a form is still open. Only then does a recreation re-read the
+    // A navigation a home-screen widget asked for (open a date / start a
-    // intent to bring it back; a saved or dismissed one stays closed.
+    // create). Consumed once by CalendarHost, same pattern as the detail key.
-    private var insertFormOpen = false
+    private var requestedNav by mutableStateOf<WidgetNavRequest?>(null)
 
-    // Started just for an external create, so closing its form returns to the
+    // An .ics file opened/shared into the app (ACTION_VIEW/SEND). Consumed once
-    // app that asked instead of leaving the calendar on top of it.
+    // by CalendarHost's import flow.
-    private var launchedForInsert = false
+    private var requestedImportUri by mutableStateOf<Uri?>(null)
+
+    // A prefilled new-event form from an external ACTION_INSERT launch (another
+    // app/widget asking us to create an event, issue #30). Consumed once by
+    // CalendarHost, which opens it in the create form for review.
+    private var requestedInsert by mutableStateOf<InsertRequest?>(null)
+
+    // An external "edit this event" (ACTION_EDIT on content://.../events/<id>):
+    // opens the occurrence in the edit form. Same occurrence-key shape as the
+    // detail channel; consumed once by CalendarHost.
+    private var requestedEditKey by mutableStateOf<LongArray?>(null)
 
     // A captured crash report awaiting the user's decision, surfaced as a dialog
     // over the calendar on the next launch (the single-crash path). A startup
@@ -115,53 +110,25 @@ class MainActivity : AppCompatActivity() {
             return
         }
 
-        val systemDark = resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK ==
+        systemBarsDark = resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK ==
             Configuration.UI_MODE_NIGHT_YES
-        // The stored theme only arrives after the first frame, so a Light, Dark
-        // or Black override starts from its last mirrored copy: the matching
-        // backdrop and bar icons instead of the night qualifier's (#181).
-        val cachedTheme = WindowThemeCache.read(this)
-        cachedTheme?.windowBackgroundRes()?.let { window.setBackgroundDrawableResource(it) }
-        systemBarsDark = (cachedTheme ?: ThemeMode.SYSTEM).isDark(systemDark)
         applyEdgeToEdge()
-        lifecycleScope.launch {
+        requestedDetailKey = intent.detailKeyOrNull() ?: intent.viewEventKeyOrNull()
-            settingsPrefs.themeMode.collect { mode ->
+        requestedNav = intent.navRequestOrNull()
-                WindowThemeCache.write(this@MainActivity, mode)
+        requestedImportUri = intent.importUriOrNull()
-                window.setBackgroundDrawableResource(mode.windowBackgroundRes() ?: R.color.window_background)
+        requestedInsert = intent.insertRequestOrNull()
-            }
+        requestedEditKey = intent.editEventKeyOrNull()
-        }
-        // Android hands the intent that started the task back to onCreate every
-        // time the activity is recreated — on a rotation, or on a restart after
-        // the system reclaimed the process. Re-running a launch that opens one
-        // specific event is what made a single reminder or widget tap re-open
-        // that event on every later launch, an error screen once the event had
-        // been deleted (#309); the user left it long ago, and the activity
-        // restores where they actually were along with its saved state.
-        //
-        // Only those channels are held back. An .ics import or a prefilled
-        // create form keeps no saved state of its own, so re-reading the intent
-        // is what carries one through a recreation — the create form only while
-        // it's still open.
-        val replaying = savedInstanceState != null || intent.isRelaunch()
-        if (!replaying) {
-            requests.detailKey = intent.detailKeyOrNull() ?: intent.viewEventKeyOrNull()
-            requests.editKey = intent.editEventKeyOrNull()
-        }
-        requests.nav = intent.navRequestOrNull()
-            ?.takeUnless { replaying && it is WidgetNavRequest.OpenEvent }
-        requests.importUri = intent.importUriOrNull()
-        val insertOpenBefore = savedInstanceState?.getBoolean(KEY_INSERT_FORM_OPEN) == true
-        requests.insert = intent.createRequestOrNull()?.takeIf { !replaying || insertOpenBefore }
-        insertFormOpen = requests.insert != null
-        launchedForInsert = savedInstanceState?.getBoolean(KEY_LAUNCHED_FOR_INSERT)
-            ?: (requests.insert != null)
         if (CrashReporter.shouldPrompt(this)) pendingCrashReport = CrashReporter.pendingReport(this)
         setContent {
             // One activity-scoped SettingsViewModel drives both the theme here
             // and the Settings screen, so a theme change applies app-wide at once.
             val settingsViewModel: SettingsViewModel = hiltViewModel()
             val settings by settingsViewModel.state.collectAsStateWithLifecycle()
-            val darkTheme = settings.themeMode.isDark(isSystemInDarkTheme())
+            val darkTheme = when (settings.themeMode) {
+                ThemeMode.SYSTEM -> isSystemInDarkTheme()
+                ThemeMode.LIGHT -> false
+                ThemeMode.DARK -> true
+            }
             // onCreate can only see the night resource qualifier, not the in-app
             // override — re-apply from the resolved theme so the bar icons follow
             // the app's light/dark choice.
@@ -187,7 +154,6 @@ class MainActivity : AppCompatActivity() {
             // weeks and switching between the week and day view.
             val timelineZoom = rememberTimelineZoom(
                 stored = settings.timelineScale,
-                hours = settings.timelineHours,
                 onPersist = settingsViewModel::setTimelineScale,
             )
             val fonts by settingsViewModel.fontState.collectAsStateWithLifecycle()
@@ -200,20 +166,28 @@ class MainActivity : AppCompatActivity() {
             CalendulaTheme(
                 darkTheme = darkTheme,
                 dynamicColor = settings.dynamicColor,
-                pureBlack = settings.themeMode.isPureBlack,
                 typography = typography,
             ) {
                 Box(modifier = Modifier.fillMaxSize()) {
                     CompositionLocalProvider(
                         LocalUse24HourFormat provides use24Hour,
-                        LocalShowHourGrid provides settings.showHourGrid,
+                        LocalShowHourLines provides settings.showHourLines,
                         LocalTimelineZoom provides timelineZoom,
-                        LocalMultiDayCount provides settings.multiDayCount,
                         LocalSoftenColors provides settings.softenColors,
                     ) {
                         RootScreen(
                             modifier = Modifier.fillMaxSize(),
-                            requests = requests,
+                            requestedDetailKey = requestedDetailKey,
+                            onDetailKeyConsumed = { requestedDetailKey = null },
+                            widgetNavRequest = requestedNav,
+                            onWidgetNavConsumed = { requestedNav = null },
+                            requestedImportUri = requestedImportUri,
+                            onImportConsumed = { requestedImportUri = null },
+                            requestedInsertForm = requestedInsert?.form,
+                            requestedInsertSource = requestedInsert?.source ?: ImportSource.Insert,
+                            onInsertConsumed = { requestedInsert = null },
+                            requestedEditKey = requestedEditKey,
+                            onEditKeyConsumed = { requestedEditKey = null },
                         )
                     }
                     // A persistent corner marker so a debug build is never
@@ -253,46 +227,21 @@ class MainActivity : AppCompatActivity() {
         )
     }
 
-    override fun onStart() {
-        super.onStart()
-        // Changes made while we were away may never have notified us (#364).
-        calendarRepository.refresh()
-    }
-
     override fun onResume() {
         super.onResume()
         // Reaching a running UI means startup succeeded; reset the loop trail.
         CrashReporter.markHealthy(this)
     }
 
-    override fun onSaveInstanceState(outState: Bundle) {
-        super.onSaveInstanceState(outState)
-        outState.putBoolean(KEY_INSERT_FORM_OPEN, insertFormOpen)
-        outState.putBoolean(KEY_LAUNCHED_FOR_INSERT, launchedForInsert)
-    }
-
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
-        (intent.detailKeyOrNull() ?: intent.viewEventKeyOrNull())?.let { requests.detailKey = it }
+        (intent.detailKeyOrNull() ?: intent.viewEventKeyOrNull())?.let { requestedDetailKey = it }
-        intent.navRequestOrNull()?.let { requests.nav = it }
+        intent.navRequestOrNull()?.let { requestedNav = it }
-        intent.importUriOrNull()?.let { requests.importUri = it }
+        intent.importUriOrNull()?.let { requestedImportUri = it }
-        intent.createRequestOrNull()?.let {
+        intent.insertRequestOrNull()?.let { requestedInsert = it }
-            requests.insert = it
+        intent.editEventKeyOrNull()?.let { requestedEditKey = it }
-            insertFormOpen = true
-        }
-        intent.editEventKeyOrNull()?.let { requests.editKey = it }
     }
 
-    /**
-     * Whether this launch is the task being resumed rather than a fresh
-     * delivery — Android sets the flag when an activity is started from the
-     * recents list, where the intent it carries is the one the task was started
-     * with however long ago. `onNewIntent` is the channel a real new request
-     * arrives on while the task lives, so nothing is lost by ignoring these.
-     */
-    private fun Intent.isRelaunch(): Boolean =
-        flags and Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY != 0
-
     /**
      * The `.ics` Uri an external app asked us to open (file manager `ACTION_VIEW`)
      * or share into us (`ACTION_SEND`). Restricted to content/file schemes so the
@@ -301,9 +250,7 @@ class MainActivity : AppCompatActivity() {
     private fun Intent.importUriOrNull(): Uri? {
         val uri = when (action) {
             Intent.ACTION_VIEW -> data
-            // Plain text is a create (#306), never a file to import.
             Intent.ACTION_SEND -> IntentCompat.getParcelableExtra(this, Intent.EXTRA_STREAM, Uri::class.java)
-                .takeUnless { type == SHARED_TEXT_TYPE }
             else -> null
         } ?: return null
         // The calendar "view time" Uri (a date tap) is also ACTION_VIEW/content;
@@ -348,36 +295,6 @@ class MainActivity : AppCompatActivity() {
         return InsertRequest(form, if (namesEnd) ImportSource.Insert else ImportSource.InsertOpenEnded)
     }
 
-    /** Any external request to create an event: shared text or an insert intent. */
-    private fun Intent.createRequestOrNull(): InsertRequest? = sharedTextRequestOrNull() ?: insertRequestOrNull()
-
-    /**
-     * Plain text shared into us (`ACTION_SEND`) or picked from a text-selection
-     * menu (`ACTION_PROCESS_TEXT`), as a new event at the default time (#306).
-     */
-    private fun Intent.sharedTextRequestOrNull(): InsertRequest? {
-        val shared = when (action) {
-            Intent.ACTION_SEND -> if (type == SHARED_TEXT_TYPE) {
-                sharedTextOrNull(
-                    subject = getCharSequenceExtra(Intent.EXTRA_SUBJECT)?.toString(),
-                    text = getCharSequenceExtra(Intent.EXTRA_TEXT)?.toString(),
-                )
-            } else {
-                null
-            }
-            Intent.ACTION_PROCESS_TEXT ->
-                sharedTextOrNull(subject = null, text = getCharSequenceExtra(Intent.EXTRA_PROCESS_TEXT)?.toString())
-            else -> null
-        } ?: return null
-        val form = buildInsertEventForm(
-            title = shared.title,
-            description = shared.description,
-            zone = TimeZone.currentSystemDefault(),
-            now = Clock.System.now(),
-        )
-        return InsertRequest(form, ImportSource.InsertOpenEnded)
-    }
-
     /** A Long extra's value, or null when the extra is absent. */
     private fun Intent.longExtraOrNull(key: String): Long? =
         if (hasExtra(key)) getLongExtra(key, 0L) else null
@@ -503,9 +420,6 @@ class MainActivity : AppCompatActivity() {
         // The calendar provider's authority/host. A date tap arrives as
         // ACTION_VIEW on content://com.android.calendar/time/<epochMillis>.
         private const val CALENDAR_PROVIDER_HOST = "com.android.calendar"
-        private const val SHARED_TEXT_TYPE = "text/plain"
-        private const val KEY_INSERT_FORM_OPEN = "insert_form_open"
-        private const val KEY_LAUNCHED_FOR_INSERT = "launched_for_insert"
 
         private const val EXTRA_EVENT_ID = "de.jeanlucmakiola.calendula.extra.EVENT_ID"
         private const val EXTRA_BEGIN_MILLIS = "de.jeanlucmakiola.calendula.extra.BEGIN"

app/src/main/java/de/jeanlucmakiola/calendula/data/backup/AutoBackup.kt

@@ -5,10 +5,12 @@ import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.PendingIntent
 import android.content.Context
+import android.content.pm.PackageManager
 import android.os.Build
 import android.util.Log
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.ContextCompat
 import androidx.core.net.toUri
 import androidx.work.CoroutineWorker
 import androidx.work.ExistingPeriodicWorkPolicy
@@ -26,7 +28,6 @@ import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
 import de.jeanlucmakiola.calendula.data.ics.IcsExporter
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
-import de.jeanlucmakiola.floret.android.hasPermission
 import kotlinx.coroutines.flow.first
 import java.util.concurrent.TimeUnit
 import kotlin.time.Clock
@@ -132,7 +133,8 @@ class BackupWorker(
 
     private fun notifyFailure(context: Context) {
         val canPost = Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU ||
-            context.hasPermission(Manifest.permission.POST_NOTIFICATIONS)
+            ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) ==
+            PackageManager.PERMISSION_GRANTED
         if (!canPost) return
         val manager = NotificationManagerCompat.from(context)
         manager.createNotificationChannel(

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

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

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

@@ -1,35 +1,22 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
 /**
- * The colours offered when creating or editing a calendar; ARGB ints for a raw
+ * Google-Calendar-style palette; ARGB ints for a raw `CALENDAR_COLOR` /
- * `CALENDAR_COLOR` / `EVENT_COLOR`.
+ * `EVENT_COLOR`. The named entries exist for callers that need one specific
- *
+ * hue (the managed special-dates calendars), so they can't drift from the
- * Hues rather than final fills: every surface that draws a calendar colour runs
+ * swatches offered in the colour picker.
- * it through the app's own tone pass first, so these are chosen to stay
- * distinguishable after it. Shared with Agendula, whose list palette these are —
- * the two apps are the same family and a calendar and a task list picked from
- * different-looking sets read as different products.
- *
- * The named entries exist for callers that need one specific hue (the managed
- * special-dates calendars), so they can't drift from the swatches on offer.
  */
 object CalendarColorPalette {
-    val Mauve = 0xFF7A5C6B.toInt()
+    val Red = 0xFFD50000.toInt()
-    val Red = 0xFFD7484A.toInt()
+    val Orange = 0xFFE67C00.toInt()
-    val Orange = 0xFFE8743B.toInt()
+    val Amber = 0xFFF6BF26.toInt()
-    val Amber = 0xFFE0A32E.toInt()
+    val Green = 0xFF33B679.toInt()
-    val Olive = 0xFF7CA83E.toInt()
+    val DarkGreen = 0xFF0B8043.toInt()
-    val Green = 0xFF35A06A.toInt()
+    val Blue = 0xFF039BE5.toInt()
-    val Teal = 0xFF19938C.toInt()
+    val Indigo = 0xFF3F51B5.toInt()
-    val Cyan = 0xFF2A9BC4.toInt()
+    val Purple = 0xFF8E24AA.toInt()
-    val Blue = 0xFF3C74C8.toInt()
+    val Graphite = 0xFF616161.toInt()
-    val Indigo = 0xFF6A5CC0.toInt()
-    val Purple = 0xFF9455B8.toInt()
-    val Pink = 0xFFC94F8E.toInt()
 
-    /** The full palette, in swatch-grid order. */
+    /** The full palette, in swatch-row order. */
-    val all: List<Int> = listOf(
+    val all: List<Int> = listOf(Red, Orange, Amber, Green, DarkGreen, Blue, Indigo, Purple, Graphite)
-        Mauve, Red, Orange, Amber, Olive, Green,
-        Teal, Cyan, Blue, Indigo, Purple, Pink,
-    )
 }

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

@@ -8,9 +8,8 @@ internal fun ColumnReader.toCalendarSource(): CalendarSource {
     val isLocal = accountType == CalendarContract.ACCOUNT_TYPE_LOCAL
     return CalendarSource(
         id = getLong(CalendarProjection.IDX_ID),
-        // Blank when the provider row has no name: the placeholder is a display
+        displayName = getString(CalendarProjection.IDX_DISPLAY_NAME)
-        // string and belongs to the UI, where it can be localised (#329).
+            ?: Fallbacks.UNNAMED_CALENDAR,
-        displayName = getString(CalendarProjection.IDX_DISPLAY_NAME).orEmpty(),
         accountName = getString(CalendarProjection.IDX_ACCOUNT_NAME).orEmpty(),
         accountType = accountType,
         color = getInt(CalendarProjection.IDX_COLOR),

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

@@ -15,9 +15,6 @@ import kotlin.time.Instant
 interface CalendarRepository {
     fun calendars(): Flow<List<CalendarSource>>
     fun instances(range: ClosedRange<Instant>): Flow<List<EventInstance>>
-
-    /** Re-query every open [calendars] / [instances] flow. */
-    fun refresh()
     suspend fun eventDetail(eventId: Long): EventDetail
 
     /**
@@ -29,7 +26,7 @@ interface CalendarRepository {
 
     /**
      * The event-colour palette a calendar's account publishes; empty when it
-     * exposes none (see [CalendarDataSource.publishedEventColors]).
+     * exposes none (see [CalendarDataSource.eventColorPalette]).
      */
     suspend fun eventColorPalette(calendarId: Long): List<EventColorOption>
 
@@ -91,15 +88,9 @@ interface CalendarRepository {
 
     /**
      * Change a single occurrence of a recurring event (exception row with the
-     * form's values); returns the exception's `Events._ID`. [original] is what
+     * form's values); returns the exception's `Events._ID`.
-     * the row holds now, for the case where it turns out not to recur.
      */
-    suspend fun updateOccurrence(
+    suspend fun updateOccurrence(eventId: Long, beginMillis: Long, form: EventForm): Long
-        eventId: Long,
-        beginMillis: Long,
-        original: EventForm,
-        form: EventForm,
-    ): Long
 
     /**
      * Change a recurring event from [beginMillis] onwards (series split);

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

@@ -1,11 +1,9 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
-import android.util.Log
-import de.jeanlucmakiola.floret.di.IoDispatcher
 import de.jeanlucmakiola.floret.time.toEpochMillis
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
-import de.jeanlucmakiola.calendula.domain.curatedForPicker
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventDetail
@@ -15,7 +13,6 @@ import de.jeanlucmakiola.calendula.domain.SearchCandidate
 import de.jeanlucmakiola.calendula.domain.ics.IcsImportSummary
 import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
 import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.combine
@@ -29,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
@@ -53,37 +49,21 @@ class CalendarRepositoryImpl @Inject constructor(
     private suspend fun allDayReminderTimeMinutes(): Int =
         settingsPrefs.allDayReminderTimeMinutes.first()
 
-    // DROP_OLDEST: tryEmit never fails, so a tick that lands while a subscriber
-    // still holds the previous one is never lost (#364).
     private val ticks = MutableSharedFlow<Unit>(
         replay = 0,
         extraBufferCapacity = 1,
-        onBufferOverflow = BufferOverflow.DROP_OLDEST,
     )
 
     /**
-     * Bumped on every [refresh], so one tick's calendar read can be
+     * Bumped on every provider notification, so one tick's calendar read can be
      * shared by everything that needs it (see [calendarsSnapshot]).
      */
     private val generation = AtomicLong(0L)
 
     init {
-        dataSource.registerChangeListener(::refresh)
+        dataSource.registerChangeListener {
-    }
+            generation.incrementAndGet()
-
+            ticks.tryEmit(Unit)
-    // Writes re-query on their own too: some providers never notify the
-    // observer, which left every view stale until a restart (#364).
-    override fun refresh() {
-        generation.incrementAndGet()
-        ticks.tryEmit(Unit)
-    }
-
-    /** Run a provider write on [io], then re-query whether or not it threw. */
-    private suspend fun <T> write(block: suspend () -> T): T = withContext(io) {
-        try {
-            block()
-        } finally {
-            refresh()
         }
     }
 
@@ -126,7 +106,8 @@ class CalendarRepositoryImpl @Inject constructor(
                         beginMillis = range.start.toEpochMillis(),
                         endMillis = range.endInclusive.toEpochMillis(),
                     ),
-                    switchedOffCalendarIds = switchedOffCalendarIds(),
+                    switchedOffCalendarIds = invisibleCalendarIds() +
+                        prefs.pendingDisabledCalendarIds.first(),
                 )
             },
             prefs.hiddenCalendarIds,
@@ -151,10 +132,6 @@ class CalendarRepositoryImpl @Inject constructor(
         .filterNot { it.isVisibleInSystem }
         .mapTo(mutableSetOf()) { it.id }
 
-    /** [invisibleCalendarIds] plus the switch-offs still waiting to be written. */
-    private suspend fun switchedOffCalendarIds(): Set<Long> =
-        invisibleCalendarIds() + prefs.pendingDisabledCalendarIds.first()
-
     private val calendarsLock = Mutex()
     private var cachedGeneration = -1L
     private var cachedPending: Set<Long>? = null
@@ -188,19 +165,21 @@ class CalendarRepositoryImpl @Inject constructor(
 
     override suspend fun searchEvents(query: String): List<SearchCandidate> = withContext(io) {
         if (query.isBlank()) return@withContext emptyList()
-        val excluded = prefs.hiddenCalendarIds.first() + switchedOffCalendarIds()
+        val excluded = prefs.hiddenCalendarIds.first() +
+            prefs.pendingDisabledCalendarIds.first() +
+            invisibleCalendarIds()
         dataSource.searchEvents(query)
             .let { if (excluded.isEmpty()) it else it.filterNot { c -> c.event.calendarId in excluded } }
     }
 
     override suspend fun eventColorPalette(calendarId: Long): List<EventColorOption> =
-        withContext(io) { dataSource.publishedEventColors(calendarId).curatedForPicker() }
+        withContext(io) { dataSource.eventColorPalette(calendarId) }
 
     override suspend fun createLocalCalendar(
         displayName: String,
         color: Int,
         description: String?,
-    ): Long = write {
+    ): Long = withContext(io) {
         dataSource.createLocalCalendar(displayName, color, description)
     }
 
@@ -209,84 +188,51 @@ class CalendarRepositoryImpl @Inject constructor(
         displayName: String,
         color: Int,
         description: String?,
-    ) = write { dataSource.updateCalendar(id, displayName, color, description) }
+    ) = withContext(io) { dataSource.updateCalendar(id, displayName, color, description) }
 
     override suspend fun deleteCalendar(id: Long) =
-        write { dataSource.deleteCalendar(id) }
+        withContext(io) { dataSource.deleteCalendar(id) }
 
     override suspend fun setCalendarsVisible(ids: Collection<Long>, visible: Boolean) =
-        write {
+        withContext(io) {
-            val canWrite = dataSource.canWriteCalendars()
+            if (dataSource.canWriteCalendars()) {
-            if (canWrite) ids.forEach { dataSource.setCalendarVisible(it, visible) }
+                ids.forEach { dataSource.setCalendarVisible(it, visible) }
-            // Nothing of ours is left waiting for the provider once the write
+                // Nothing of ours is left waiting for the provider once the
-            // lands, and switching one back on retires its entry. With read-only
+                // write lands (and switching one back on retires its entry).
-            // permission a switch-off still works, app-side, and the reconciler
+                prefs.removePendingDisabledCalendarIds(ids)
-            // flushes it if WRITE_CALENDAR ever arrives.
+            } else if (visible) {
-            if (canWrite || visible) {
                 prefs.removePendingDisabledCalendarIds(ids)
             } else {
+                // Read-only permission: the switch still works, app-side, and
+                // the reconciler flushes it if WRITE_CALENDAR ever arrives.
                 prefs.addPendingDisabledCalendarIds(ids)
             }
         }
 
     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 = write {
+    ): 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) {
-        var notAttempted = 0
-        for ((index, event) in events.withIndex()) {
             // 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
+            } else {
-            }
+                dataSource.insertImportedEvent(event, targetCalendarId)
-            try {
-                dataSource.insertImportedEvent(event, targetCalendarId, allDayMinutes, palette)
                 imported++
-            } catch (e: CancellationException) {
-                throw e
-            } catch (e: SecurityException) {
-                // Not this event's fault: the permission or the target calendar is
-                // gone, so every remaining insert would fail the same way.
-                Log.w(TAG, "Import stopped: the calendar is no longer writable", e)
-                // A known UID would have been skipped whatever happened, so it is
-                // no part of what a retry still has to import.
-                val remaining = events.drop(index)
-                val duplicates = remaining.count { it.uid?.let { uid -> uid in existing } == true }
-                skipped += duplicates
-                notAttempted = remaining.size - duplicates
-                break
-            } catch (e: Exception) {
-                // One event the provider won't take must not cost the user the
-                // rest of the file — foreign exports do carry rows it rejects
-                // outright (a malformed RRULE throws straight out of insert).
-                failed++
-                Log.w(TAG, "Skipped an unimportable event", e)
             }
         }
-        IcsImportSummary(
+        IcsImportSummary(imported = imported, skippedDuplicate = skipped)
-            imported = imported,
-            skippedDuplicate = skipped,
-            failed = failed,
-            notAttempted = notAttempted,
-        )
     }
 
-    override suspend fun createEvent(form: EventForm): Long = write {
+    override suspend fun createEvent(form: EventForm): Long = withContext(io) {
         dataSource.insertEvent(form, allDayReminderTimeMinutes())
     }
 
@@ -294,11 +240,11 @@ class CalendarRepositoryImpl @Inject constructor(
         eventId: Long,
         original: EventForm,
         updated: EventForm,
-    ) = write {
+    ) = withContext(io) {
         dataSource.updateEvent(eventId, original, updated, allDayReminderTimeMinutes())
     }
 
-    override suspend fun deleteEvent(eventId: Long) = write {
+    override suspend fun deleteEvent(eventId: Long) = withContext(io) {
         dataSource.deleteEvent(eventId)
     }
 
@@ -307,7 +253,7 @@ class CalendarRepositoryImpl @Inject constructor(
         targetCalendarId: Long,
         original: EventForm,
         updated: EventForm,
-    ): Long = write {
+    ): Long = withContext(io) {
         dataSource.moveEvent(
             eventId, targetCalendarId, original, updated, allDayReminderTimeMinutes(),
         )
@@ -316,12 +262,9 @@ class CalendarRepositoryImpl @Inject constructor(
     override suspend fun updateOccurrence(
         eventId: Long,
         beginMillis: Long,
-        original: EventForm,
         form: EventForm,
-    ): Long = write {
+    ): Long = withContext(io) {
-        dataSource.updateOccurrence(
+        dataSource.updateOccurrence(eventId, beginMillis, form, allDayReminderTimeMinutes())
-            eventId, beginMillis, original, form, allDayReminderTimeMinutes(),
-        )
     }
 
     override suspend fun updateEventFromOccurrence(
@@ -329,26 +272,22 @@ class CalendarRepositoryImpl @Inject constructor(
         beginMillis: Long,
         original: EventForm,
         updated: EventForm,
-    ): Long = write {
+    ): Long = withContext(io) {
         dataSource.updateEventFromOccurrence(
             eventId, beginMillis, original, updated, allDayReminderTimeMinutes(),
         )
     }
 
-    override suspend fun deleteOccurrence(eventId: Long, beginMillis: Long) = write {
+    override suspend fun deleteOccurrence(eventId: Long, beginMillis: Long) = withContext(io) {
         dataSource.deleteOccurrence(eventId, beginMillis)
     }
 
     override suspend fun deleteEventFromOccurrence(
         eventId: Long,
         beginMillis: Long,
-    ) = write {
+    ) = withContext(io) {
         dataSource.deleteEventFromOccurrence(eventId, beginMillis)
     }
-
-    private companion object {
-        const val TAG = "CalendarRepository"
-    }
 }
 
 private fun <T> Flow<Unit>.reQuery(block: suspend () -> T): Flow<T> = flow {

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

@@ -4,15 +4,15 @@ import android.Manifest
 import android.content.Context
 import android.content.pm.PackageManager
 import android.util.Log
+import androidx.core.content.ContextCompat
 import dagger.hilt.EntryPoint
 import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.domain.calendarVisibilityPlan
 import de.jeanlucmakiola.calendula.domain.hasSystemHiddenCalendars
-import de.jeanlucmakiola.floret.android.hasPermission
-import de.jeanlucmakiola.floret.di.IoDispatcher
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.withContext
@@ -47,7 +47,7 @@ class CalendarVisibilityReconciler @Inject constructor(
             // Settled ahead of the permission gate, so an update installed
             // before the first grant can't later look like an upgrade.
             if (!isUpgradeInstall()) settleNoticeOnce(pending = false)
-            if (!context.hasPermission(Manifest.permission.READ_CALENDAR)) return@withContext
+            if (!hasPermission(Manifest.permission.READ_CALENDAR)) return@withContext
             val pending = prefs.pendingDisabledCalendarIds.first()
             val noticeSettled = prefs.visibilityNoticePending.first() != null
             if (pending.isEmpty() && noticeSettled) return@withContext
@@ -56,7 +56,7 @@ class CalendarVisibilityReconciler @Inject constructor(
             // Both decisions below are one-way, so leave them to the next run.
             if (calendars.isEmpty()) return@withContext
             settleNoticeOnce(hasSystemHiddenCalendars(calendars, pending))
-            if (pending.isEmpty() || !context.hasPermission(Manifest.permission.WRITE_CALENDAR)) {
+            if (pending.isEmpty() || !hasPermission(Manifest.permission.WRITE_CALENDAR)) {
                 return@withContext
             }
             val plan = calendarVisibilityPlan(calendars, pending)
@@ -97,6 +97,9 @@ class CalendarVisibilityReconciler @Inject constructor(
         false
     }
 
+    private fun hasPermission(permission: String): Boolean =
+        ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED
+
     /** Lets non-injectable entry points (the Application) reach the reconciler. */
     @EntryPoint
     @InstallIn(SingletonComponent::class)

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

@@ -1,11 +1,6 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
 import android.database.Cursor
-import de.jeanlucmakiola.calendula.domain.EventStatus
-import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
-import java.time.Instant
-import java.time.LocalDate
-import java.time.ZoneOffset
 
 /**
  * Read-only view over a single row's columns by index. Lets the mappers work
@@ -25,33 +20,3 @@ internal class CursorColumnReader(private val cursor: Cursor) : ColumnReader {
     override fun getInt(index: Int): Int = cursor.getInt(index)
     override fun isNull(index: Int): Boolean = cursor.isNull(index)
 }
-
-internal fun ColumnReader.getIntOrNull(index: Int): Int? = if (isNull(index)) null else getInt(index)
-
-internal fun ColumnReader.getLongOrNull(index: Int): Long? = if (isNull(index)) null else getLong(index)
-
-/**
- * The row's end: DTEND, or DTSTART + DURATION for a recurring row, which stores
- * no DTEND. Unclamped; a missing/blank both means a zero-length event.
- */
-internal fun ColumnReader.endMillis(dtStartMillis: Long, dtEndIndex: Int, durationIndex: Int): Long =
-    getLongOrNull(dtEndIndex) ?: (dtStartMillis + parseRfc2445DurationMillis(getString(durationIndex)))
-
-/** STATUS shares value 0 with TENTATIVE, so an absent column must read as Confirmed. */
-internal fun ColumnReader.eventStatus(index: Int): EventStatus =
-    getIntOrNull(index)?.let(::mapEventStatus) ?: EventStatus.Confirmed
-
-/** Map every row, reading each through one [CursorColumnReader]. */
-internal inline fun <T> Cursor.mapRows(map: ColumnReader.() -> T): List<T> {
-    val reader = CursorColumnReader(this)
-    return buildList { while (moveToNext()) add(reader.map()) }
-}
-
-/** [mapRows], dropping the rows [map] returns null for. */
-internal inline fun <T : Any> Cursor.mapRowsNotNull(map: ColumnReader.() -> T?): List<T> {
-    val reader = CursorColumnReader(this)
-    return buildList { while (moveToNext()) reader.map()?.let(::add) }
-}
-
-/** The UTC calendar day of [millis] — an all-day row's date, since it sits at UTC midnight. */
-internal fun utcDate(millis: Long): LocalDate = Instant.ofEpochMilli(millis).atZone(ZoneOffset.UTC).toLocalDate()

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

@@ -15,7 +15,9 @@ import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.Reminder
 import de.jeanlucmakiola.calendula.domain.ReminderMethod
 import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
+import java.time.Instant
 import java.time.ZoneId
+import java.time.ZoneOffset
 
 private const val TAG = "EventDetailMapper"
 
@@ -46,8 +48,11 @@ internal fun ColumnReader.toEventDetailCore(
     // — the same trap as the pre-1970 DTSTART bug above (issue #34): it would
     // surface as the generic error screen with no way to open the event and fix
     // it. Clamp to a zero-length event instead (matching SearchMapper).
-    val end = getLongOrNull(EventDetailProjection.IDX_DTEND)?.coerceAtLeast(begin)
+    val end = if (isNull(EventDetailProjection.IDX_DTEND)) {
-        ?: (begin + parseRfc2445DurationMillis(getString(EventDetailProjection.IDX_DURATION)))
+        begin + parseRfc2445DurationMillis(getString(EventDetailProjection.IDX_DURATION))
+    } else {
+        getLong(EventDetailProjection.IDX_DTEND).coerceAtLeast(begin)
+    }
 
     // Kept raw (no untitled fallback): the detail screen substitutes its own
     // localized placeholder, and the edit form must prefill the true value.
@@ -56,7 +61,11 @@ internal fun ColumnReader.toEventDetailCore(
     // The event's own colour (null = inherits the calendar's) is kept apart
     // from the resolved display colour: the edit form needs to tell the two
     // cases apart, while the instance carries the calendar fallback for display.
-    val eventColor = getIntOrNull(EventDetailProjection.IDX_EVENT_COLOR)
+    val eventColor = if (isNull(EventDetailProjection.IDX_EVENT_COLOR)) {
+        null
+    } else {
+        getInt(EventDetailProjection.IDX_EVENT_COLOR)
+    }
     val eventColorKey = getString(EventDetailProjection.IDX_EVENT_COLOR_KEY)
     val color = eventColor ?: getInt(EventDetailProjection.IDX_CALENDAR_COLOR)
 
@@ -79,7 +88,7 @@ internal fun ColumnReader.toEventDetailCore(
     // and detail screen speak. DTSTART is UTC midnight for all-day events, so the
     // event's date is its UTC date.
     val displayReminders = if (isAllDay) {
-        val startDate = utcDate(begin)
+        val startDate = Instant.ofEpochMilli(begin).atZone(ZoneOffset.UTC).toLocalDate()
         val zone = ZoneId.systemDefault()
         reminders.map {
             it.copy(
@@ -92,6 +101,14 @@ internal fun ColumnReader.toEventDetailCore(
         reminders
     }
 
+    // STATUS shares its 0 value with STATUS_TENTATIVE, so a missing column must
+    // be distinguished from a present 0 — an absent status means "just confirmed".
+    val status = if (isNull(EventDetailProjection.IDX_STATUS)) {
+        EventStatus.Confirmed
+    } else {
+        mapEventStatus(getInt(EventDetailProjection.IDX_STATUS))
+    }
+
     return EventDetail(
         instance = instance,
         description = getString(EventDetailProjection.IDX_DESCRIPTION),
@@ -99,7 +116,7 @@ internal fun ColumnReader.toEventDetailCore(
         attendees = attendees,
         rrule = getString(EventDetailProjection.IDX_RRULE),
         reminders = displayReminders,
-        status = eventStatus(EventDetailProjection.IDX_STATUS),
+        status = status,
         // BUSY and DEFAULT are both 0, so a null column folds into the same
         // default these mappers already return — no isNull guard needed.
         availability = mapAvailability(getInt(EventDetailProjection.IDX_AVAILABILITY)),

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

@@ -1,29 +1,16 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
-import de.jeanlucmakiola.calendula.domain.instantIn
-import kotlinx.datetime.toKotlinTimeZone
 import android.provider.CalendarContract
 import de.jeanlucmakiola.calendula.domain.AccessLevel
 import de.jeanlucmakiola.calendula.domain.Availability
-import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventForm
-import de.jeanlucmakiola.calendula.domain.FormTime
-import de.jeanlucmakiola.calendula.domain.EventStatus
-import de.jeanlucmakiola.calendula.domain.ics.ParsedIcsEvent
-import de.jeanlucmakiola.calendula.domain.nearestTo
 import kotlinx.datetime.toJavaLocalDate
 import kotlinx.datetime.toJavaLocalDateTime
-import kotlinx.datetime.toJavaZoneOffset
 import java.time.Duration
 import java.time.Instant
 import java.time.ZoneId
 import java.time.ZoneOffset
-import java.time.ZonedDateTime
-import java.time.format.DateTimeFormatter
-import java.time.format.ResolverStyle
-import java.time.LocalDate as JavaLocalDate
 import java.time.LocalDateTime as JavaLocalDateTime
-import java.time.LocalTime as JavaLocalTime
 
 /** Provider-ready DTSTART / DTEND / EVENT_TIMEZONE for an event write. */
 internal data class EventWriteTimes(
@@ -52,8 +39,8 @@ internal fun EventForm.toWriteTimes(zone: ZoneId): EventWriteTimes = if (isAllDa
 } else {
     val writeZone = writeZone(zone)
     EventWriteTimes(
-        dtStartMillis = start.instantIn(writeZone.toKotlinTimeZone()).toEpochMilliseconds(),
+        dtStartMillis = start.toJavaLocalDateTime().atZone(writeZone).toInstant().toEpochMilli(),
-        dtEndMillis = end.instantIn(writeZone.toKotlinTimeZone()).toEpochMilliseconds(),
+        dtEndMillis = end.toJavaLocalDateTime().atZone(writeZone).toInstant().toEpochMilli(),
         timezone = writeZone.id,
     )
 }
@@ -79,7 +66,7 @@ private fun EventForm.writeZone(deviceZone: ZoneId): ZoneId = if (isAllDay) {
 private fun EventForm.anchorLocal(): JavaLocalDateTime = if (isAllDay) {
     start.date.toJavaLocalDate().atStartOfDay()
 } else {
-    start.dateTime.toJavaLocalDateTime()
+    start.toJavaLocalDateTime()
 }
 
 /**
@@ -147,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
+ *   replaces DTEND, RRULE is written. This keeps past occurrences intact when
- *   ([seriesExdate], the current EXDATE) travel with the anchor. This keeps past
+ *   someone edits a later occurrence's time, and keeps the anchor's time-of-day
- *   occurrences intact when someone edits a later occurrence's time, and keeps
+ *   stable across a DST boundary or a zone change between the two.
- *   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()) {
@@ -185,8 +169,7 @@ internal fun buildEventUpdateValues(
 
     // A zone change counts as a time change even when the wall-clock is
     // untouched: the same 09:00 in another zone is a different instant, so
-    // DTSTART has to move with it. So does a switch between the two passes of
+    // DTSTART has to move with it.
-    // the fall-back hour, which each [FormTime] carries (#387).
     val timesChanged = updated.start != original.start ||
         updated.end != original.end ||
         updated.isAllDay != original.isAllDay ||
@@ -202,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)
@@ -214,35 +193,19 @@ internal fun buildEventUpdateValues(
         // is a different offset from the series anchor's whenever a DST boundary
         // sits between them, or whenever the zone itself changed. Working in wall
         // clock keeps "09:00" meaning 09:00 at both ends.
-        val seriesZoned = Instant.ofEpochMilli(seriesDtStartMillis).atZone(original.writeZone(zone))
+        val seriesLocal = Instant.ofEpochMilli(seriesDtStartMillis)
-        val seriesLocal = seriesZoned.toLocalDateTime()
+            .atZone(original.writeZone(zone)).toLocalDateTime()
         val wallClockShift = Duration.between(original.anchorLocal(), updated.anchorLocal())
         val shifted = seriesLocal.plus(wallClockShift)
         // An all-day series anchor must sit on a UTC midnight. A pure day move
         // already lands there (both ends are midnights), but *switching* a
         // recurring event to all-day shifts by a time-of-day too, so snap.
         val newSeriesLocal = if (updated.isAllDay) shifted.toLocalDate().atStartOfDay() else shifted
-        // A wall clock the fall-back hour repeats keeps the anchor's own pass, or,
+        val newSeriesStart = newSeriesLocal.atZone(updated.writeZone(zone))
-        // when the anchor is the edited occurrence itself, the pass the form now
-        // holds: a bare wall clock would always take the earlier one (#387).
-        val pass = if (seriesLocal == original.anchorLocal()) {
-            updated.start.offset?.toJavaZoneOffset()
-        } else {
-            seriesZoned.offset
-        }
-        val newSeriesStart = ZonedDateTime.ofLocal(newSeriesLocal, updated.writeZone(zone), pass)
         put(CalendarContract.Events.DTSTART, newSeriesStart.toInstant().toEpochMilli())
         put(CalendarContract.Events.DTEND, null)
         put(CalendarContract.Events.RRULE, updated.rrule)
         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) }
     }
 }
 
@@ -260,10 +223,6 @@ internal fun buildEventUpdateValues(
  * DTSTART + DURATION itself, clearing the inherited RRULE in the process. This
  * matches how AOSP Calendar/Etar write exceptions; sending DTEND is what made
  * "only this event" fail on-device (Codeberg #16).
- *
- * A palette key is left out: the provider crashes on an exception insert that
- * carries `EVENT_COLOR_KEY` (Codeberg #338), so the caller sets it with a plain
- * update once the row exists.
  */
 internal fun buildOccurrenceExceptionValues(
     form: EventForm,
@@ -281,24 +240,9 @@ internal fun buildOccurrenceExceptionValues(
     put(CalendarContract.Events.ACCESS_LEVEL, form.accessLevel.toProviderValue())
     put(CalendarContract.Events.EVENT_LOCATION, form.location.trim().ifEmpty { null })
     put(CalendarContract.Events.DESCRIPTION, form.description.trim().ifEmpty { null })
-    if (form.colorKey == null) putAll(eventColorColumns(null, form.color))
+    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`
@@ -372,11 +316,48 @@ internal data class ExceptionRowSnapshot(
     val exceptionEventId: Long,
     val originalInstanceMillis: Long,
     val isCancelled: Boolean,
+    val status: Int?,
+    val title: String,
+    val isAllDay: Boolean,
     val dtStartMillis: Long,
     val dtEndMillis: Long?,
     val duration: String?,
+    val timezone: String?,
+    val availability: Int,
+    val accessLevel: Int,
+    val location: String?,
+    val description: String?,
 )
 
+/**
+ * Column values replaying a *modified* occurrence [snapshot] against the moved
+ * series via `CONTENT_EXCEPTION_URI`. Like [buildOccurrenceExceptionValues] the
+ * length travels as DURATION (the provider rejects DTEND on an exception). A
+ * cancelled occurrence is written separately (ORIGINAL_INSTANCE_TIME +
+ * STATUS_CANCELED) — this builder is only for the modified case.
+ */
+internal fun buildCopiedExceptionValues(snapshot: ExceptionRowSnapshot): Map<String, Any?> =
+    buildMap {
+        put(CalendarContract.Events.ORIGINAL_INSTANCE_TIME, snapshot.originalInstanceMillis)
+        put(CalendarContract.Events.TITLE, snapshot.title)
+        put(CalendarContract.Events.ALL_DAY, if (snapshot.isAllDay) 1 else 0)
+        put(CalendarContract.Events.DTSTART, snapshot.dtStartMillis)
+        put(
+            CalendarContract.Events.DURATION,
+            snapshot.duration?.takeIf { it.isNotBlank() }
+                ?: rfc2445Duration(
+                    (snapshot.dtEndMillis ?: snapshot.dtStartMillis) - snapshot.dtStartMillis,
+                    snapshot.isAllDay,
+                ),
+        )
+        put(CalendarContract.Events.EVENT_TIMEZONE, snapshot.timezone ?: "UTC")
+        put(CalendarContract.Events.AVAILABILITY, snapshot.availability)
+        put(CalendarContract.Events.ACCESS_LEVEL, snapshot.accessLevel)
+        put(CalendarContract.Events.EVENT_LOCATION, snapshot.location?.ifEmpty { null })
+        put(CalendarContract.Events.DESCRIPTION, snapshot.description?.ifEmpty { null })
+        snapshot.status?.let { put(CalendarContract.Events.STATUS, it) }
+    }
+
 /**
  * Column values for a *cancelled*-occurrence exception row ("delete only this
  * event"): inserting them at `Events.CONTENT_EXCEPTION_URI/<id>` makes the
@@ -425,351 +406,52 @@ internal fun buildOccurrenceCancelValues(
  * first occurrence. Passing DTSTART + DURATION + RRULE + zone together is what
  * re-expands it correctly. All observed on a Pixel; see the #47 notes.
  *
- * [rdate] travels with [rrule]: a sync adapter may list a series' occurrences
- * instead of naming a rule, and rewriting the recurrence set without it would
- * leave the provider nothing but DTSTART to re-expand from — the collapse this
- * values map exists to avoid.
- *
  * EXDATE is a comma-separated list, so an existing one is appended to (a repeat
- * of the same occurrence is folded away — [mergedExdate]).
+ * of the same occurrence is folded away). All-day series take the `VALUE=DATE`
+ * form (`yyyyMMdd`), timed ones the UTC date-time form (`yyyyMMddTHHmmssZ`).
  */
 internal fun buildOccurrenceExdateValues(
     existingExdate: String?,
     occurrenceMillis: Long,
     dtStartMillis: Long,
     rrule: String?,
-    rdate: String?,
     duration: String?,
     timezone: String?,
     allDay: Int,
-): Map<String, Any?> = buildOccurrencesExdateValues(
+): Map<String, Any?> {
-    existingExdate, listOf(occurrenceMillis), dtStartMillis, rrule, rdate, duration, timezone, allDay,
+    val stamp = formatExdateStamp(occurrenceMillis, isAllDay = allDay != 0)
-)
+    val existing = existingExdate?.split(',')
-
+        ?.map { it.trim() }
-/** [buildOccurrenceExdateValues] excluding every one of [occurrences] in one write. */
+        ?.filter { it.isNotEmpty() }
-internal fun buildOccurrencesExdateValues(
+        .orEmpty()
-    existingExdate: String?,
+    val merged = (existing + stamp).distinct().joinToString(",")
-    occurrences: List<Long>,
+    return mapOf(
-    dtStartMillis: Long,
+        CalendarContract.Events.EXDATE to merged,
-    rrule: String?,
+        CalendarContract.Events.DTSTART to dtStartMillis,
-    rdate: String?,
+        CalendarContract.Events.RRULE to rrule,
-    duration: String?,
+        CalendarContract.Events.DURATION to duration,
-    timezone: String?,
+        CalendarContract.Events.EVENT_TIMEZONE to timezone,
-    allDay: Int,
+        CalendarContract.Events.ALL_DAY to allDay,
-): Map<String, Any?> = mapOf(
+    )
-    CalendarContract.Events.EXDATE to occurrences.fold(existingExdate) { exdate, millis ->
-        mergedExdate(exdate, millis, allDay != 0, timezone)
-    },
-    CalendarContract.Events.DTSTART to dtStartMillis,
-    CalendarContract.Events.RRULE to rrule,
-    CalendarContract.Events.RDATE to rdate,
-    CalendarContract.Events.DURATION to duration,
-    CalendarContract.Events.EVENT_TIMEZONE to timezone,
-    CalendarContract.Events.ALL_DAY to allDay,
-)
-
-/**
- * [existingExdate] with the occurrence at [occurrenceMillis] excluded as well.
- *
- * Existing stamps are canonicalised first — all-day series take the `VALUE=DATE`
- * form (`yyyyMMdd`), timed ones the UTC date-time form (`yyyyMMddTHHmmssZ`) — so
- * appending to a list a sync adapter wrote in the other accepted form folds the
- * repeat away instead of leaving the same day excluded twice in two spellings.
- *
- * A stamp in no form Calendula reads makes the whole list untouchable: it is kept
- * exactly as it is, behind the parameter prefix that tells a reader how to
- * resolve it, and the new exclusion joins it in the list's own form.
- * Canonicalising the readable stamps around it would leave absolute stamps under
- * a prefix claiming a zone for all of them — which is how the unreadable one
- * quietly changes instant.
- */
-private fun mergedExdate(
-    existingExdate: String?,
-    occurrenceMillis: Long,
-    isAllDay: Boolean,
-    timezone: String?,
-): String {
-    val listZone = exdateListZone(existingExdate, timezone)
-    val stamps = exdateStamps(existingExdate)
-    val canonical = stamps.map { canonicalExdateStamp(it, isAllDay, listZone) }
-    if (canonical.all { it != null }) {
-        val stamp = formatExdateStamp(occurrenceMillis, isAllDay)
-        return (canonical.filterNotNull() + stamp).distinct().joinToString(",")
-    }
-    val prefix = existingExdate?.exdateParameterPrefix().orEmpty()
-    val stamp = if (isAllDay || prefix.isEmpty()) {
-        formatExdateStamp(occurrenceMillis, isAllDay)
-    } else {
-        Instant.ofEpochMilli(occurrenceMillis).atZone(listZone).format(FLOATING_EXDATE)
-    }
-    return prefix + (stamps + stamp).distinct().joinToString(",")
 }
 
-/**
- * Whether [existingExdate] already excludes the occurrence at [occurrenceMillis]
- * — i.e. it has already been dropped from the series, deleted or detached.
- *
- * Guards the detach path against running twice from a stale screen: the EXDATE
- * merge folds the repeat away silently and the update still reports one row
- * changed, so a second save would leave a second standalone copy.
- */
-internal fun exdateContains(
-    existingExdate: String?,
-    occurrenceMillis: Long,
-    isAllDay: Boolean,
-    timezone: String?,
-): Boolean {
-    val stamp = formatExdateStamp(occurrenceMillis, isAllDay)
-    val listZone = exdateListZone(existingExdate, timezone)
-    // Canonicalised rather than compared verbatim: a sync adapter may spell the
-    // same exclusion differently to Calendula, and a guard that misses it lets
-    // the detach run a second time and leave a second standalone copy.
-    return exdateStamps(existingExdate)
-        .any { canonicalExdateStamp(it, isAllDay, listZone) == stamp }
-}
-
-/**
- * [existingExdate] with every stamp re-timed by the same **wall-clock** shift the
- * series anchor takes from [original] to [updated] — the exclusions' half of the
- * anchor move [buildEventUpdateValues] performs, and what carries them onto the
- * new series when "this and following" splits one.
- *
- * A stamp is an absolute instant, so it keeps naming its occurrence only if it
- * moves exactly as the occurrence does: shifted in wall clock and re-resolved in
- * the event's (possibly new) zone. A millisecond delta would instead bake in the
- * offset that happened to apply at the edited occurrence — an hour off for any
- * exclusion on the far side of a DST boundary. All-day-ness is read from
- * [original] and written from [updated], so the `VALUE=DATE` and date-time forms
- * convert into each other when the event switches.
- *
- * A zoned list is read in the zone its prefix names ([exdateListZone]). Null
- * when there is nothing to carry: no stamps, or a stamp in a form Calendula
- * cannot read at all. Those are left exactly as they are rather than guessed at —
- * a stale stamp excludes nothing, but a mangled one could exclude the wrong
- * occurrence.
- */
-internal fun shiftedExdate(
-    existingExdate: String?,
-    original: EventForm,
-    updated: EventForm,
-    zone: ZoneId,
-): String? {
-    val stamps = exdateStamps(existingExdate)
-    if (stamps.isEmpty()) return null
-    val fromZone = original.writeZone(zone)
-    val toZone = updated.writeZone(zone)
-    val listZone = exdateListZone(existingExdate, fromZone.id)
-    val wallClockShift = Duration.between(original.anchorLocal(), updated.anchorLocal())
-    return stamps
-        .map { stamp ->
-            val local = parseExdateStamp(stamp, original.isAllDay, fromZone, listZone)
-                ?: return null
-            formatExdateStamp(local.plus(wallClockShift), updated.isAllDay, toZone)
-        }
-        .distinct()
-        .joinToString(",")
-}
-
-/**
- * The stamps of [existingExdate] naming occurrences after [beginMillis] — the ones
- * that belong to the *new* series once "this and following" splits a recurring
- * event there. The parent keeps the full list; its stamps past the split point are
- * simply inert once it stops generating those occurrences.
- *
- * The occurrence at [beginMillis] itself is never carried. It is the one the user
- * is editing, so it exists by definition, and honouring a stale exclusion for it
- * would swallow the edit whole.
- *
- * The stamps that qualify come back canonicalised, since the zone prefix that
- * told the reader how to resolve them does not survive the filter.
- *
- * Null when nothing qualifies, or when a stamp can't be read (see [shiftedExdate]).
- */
-internal fun exdateAfter(
-    existingExdate: String?,
-    beginMillis: Long,
-    isAllDay: Boolean,
-    timezone: String?,
-): String? {
-    val stamps = exdateStamps(existingExdate)
-    if (stamps.isEmpty()) return null
-    val listZone = exdateListZone(existingExdate, timezone)
-    return stamps
-        .mapNotNull { stamp ->
-            val utc = parseExdateStamp(stamp, isAllDay, ZoneOffset.UTC, listZone) ?: return null
-            utc.takeIf { it.toInstant(ZoneOffset.UTC).toEpochMilli() > beginMillis }
-        }
-        .map { formatExdateStamp(it, isAllDay, ZoneOffset.UTC) }
-        .takeIf { it.isNotEmpty() }
-        ?.joinToString(",")
-}
-
-/**
- * The individual stamps of an EXDATE column value; it is a comma-separated list,
- * optionally behind the parameter prefix AOSP's `RecurrenceSet` puts in front of
- * a zoned one ([exdateListZone] reads that half).
- */
-internal fun exdateStamps(exdate: String?): List<String> = exdate
-    ?.withoutExdateParameters()
-    ?.split(',')
-    ?.map { it.trim() }
-    ?.filter { it.isNotEmpty() }
-    .orEmpty()
-
-/**
- * An EXDATE column value with the parameter section its stamps sit behind taken
- * off.
- */
-internal fun String.withoutExdateParameters(): String = substring(exdateParameterPrefix().length)
-
-/**
- * The parameter section an EXDATE list's stamps sit behind, its `;` included, or
- * empty when it has none. Only a `;` before the first stamp separator is one —
- * anything later belongs to a stamp, and cutting there would drop every stamp in
- * front of it.
- */
-private fun String.exdateParameterPrefix(): String {
-    val semicolon = indexOf(';')
-    val comma = indexOf(',')
-    return if (semicolon >= 0 && (comma < 0 || semicolon < comma)) {
-        substring(0, semicolon + 1)
-    } else {
-        ""
-    }
-}
-
-/**
- * The zone the floating stamps of [exdate] are wall clock in: the one its
- * parameter prefix names, or [fallback] — the event's own `EVENT_TIMEZONE` —
- * when there is no prefix, or the device's tz database doesn't know the name it
- * uses (Exchange spells zones its own way). The series' own zone is the right
- * guess, since a zoned exclusion list is written in it. UTC last, for a row that
- * carries no zone either. Stamps already written as UTC instants ignore all this.
- *
- * Both spellings of the prefix are read. AOSP's `RecurrenceSet` stores the TZID
- * parameter's *value* alone (`Europe/Berlin;<stamps>`), and so does DAVx5; the
- * iCalendar `TZID=<zone>;` some writers keep is the other one. Only matching the
- * second would miss every list the provider itself wrote.
- */
-internal fun exdateListZone(exdate: String?, fallback: String?): ZoneId =
-    exdate?.exdateZoneName()?.toZoneIdOrNull()
-        ?: fallback?.toZoneIdOrNull()
-        ?: ZoneOffset.UTC
-
-/** The zone id an EXDATE list's parameter prefix names, with or without `TZID=`. */
-private fun String.exdateZoneName(): String {
-    val prefix = exdateParameterPrefix().dropLast(1)
-    return if (prefix.startsWith(TZID_PREFIX, ignoreCase = true)) {
-        prefix.drop(TZID_PREFIX.length)
-    } else {
-        prefix
-    }
-}
-
-private fun String.toZoneIdOrNull(): ZoneId? = runCatching { ZoneId.of(this) }.getOrNull()
-
-/** The optional `TZID=` a zoned EXDATE list's zone id may sit behind. */
-private const val TZID_PREFIX = "TZID="
-
 /**
  * One EXDATE entry for the occurrence starting at [occurrenceMillis]. Both forms
  * are UTC: the provider stores an all-day DTSTART at UTC midnight, so its date
  * reads off the UTC calendar day.
  */
-private fun formatExdateStamp(occurrenceMillis: Long, isAllDay: Boolean): String =
+private fun formatExdateStamp(occurrenceMillis: Long, isAllDay: Boolean): String {
-    formatExdateStamp(
+    val utc = Instant.ofEpochMilli(occurrenceMillis).atZone(ZoneOffset.UTC)
-        local = Instant.ofEpochMilli(occurrenceMillis).atZone(ZoneOffset.UTC).toLocalDateTime(),
+    return if (isAllDay) {
-        isAllDay = isAllDay,
+        "%04d%02d%02d".format(utc.year, utc.monthValue, utc.dayOfMonth)
-        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)
     } else {
-        local.atZone(zone).withZoneSameInstant(ZoneOffset.UTC).format(TIMED_EXDATE)
+        "%04d%02d%02dT%02d%02d%02dZ".format(
+            utc.year, utc.monthValue, utc.dayOfMonth,
+            utc.hour, utc.minute, utc.second,
+        )
     }
-
-/**
- * [stamp] as the wall clock it names in [zone] — the inverse of
- * [formatExdateStamp]. Null for anything Calendula cannot read, so a caller can
- * tell "not ours, leave it alone" from a value it may safely re-time.
- *
- * A timed exclusion is read both as the UTC instant Calendula writes and as a
- * floating stamp, which [listZone] then resolves. An all-day one is read both
- * bare (`yyyyMMdd`, what Calendula writes) and padded to a midnight stamp, in
- * either spelling: sync adapters are inconsistent about which they store — the
- * same forms [exportExDates] reshapes on the way out — and refusing one would
- * drop every exclusion of a foreign all-day series the moment it is re-timed.
- */
-private fun parseExdateStamp(
-    stamp: String,
-    isAllDay: Boolean,
-    zone: ZoneId,
-    listZone: ZoneId,
-): JavaLocalDateTime? =
-    if (isAllDay) {
-        parseAllDayExdate(stamp)?.atStartOfDay()
-    } else {
-        parseTimedExdate(stamp, listZone)?.withZoneSameInstant(zone)?.toLocalDateTime()
-    }
-
-/**
- * A timed EXDATE stamp as the instant it names: the trailing `Z` form resolved in
- * UTC, or the floating one resolved in [listZone].
- */
-private fun parseTimedExdate(stamp: String, listZone: ZoneId): ZonedDateTime? =
-    runCatching { JavaLocalDateTime.parse(stamp, TIMED_EXDATE).atZone(ZoneOffset.UTC) }.getOrNull()
-        ?: runCatching {
-            JavaLocalDateTime.parse(stamp, FLOATING_EXDATE).atZone(listZone)
-        }.getOrNull()
-
-/**
- * The calendar day an all-day EXDATE stamp names, bare or padded to a midnight
- * stamp. A padded stamp naming any other time of day is refused rather than
- * rounded: it is not a form an all-day series is written in, so it could be
- * naming something else entirely. Midnight is midnight in any zone, so the
- * padding's own spelling — trailing `Z` or floating — makes no difference.
- */
-private fun parseAllDayExdate(stamp: String): JavaLocalDate? {
-    runCatching { JavaLocalDate.parse(stamp, ALL_DAY_EXDATE) }.getOrNull()?.let { return it }
-    val padded = parsePaddedExdate(stamp) ?: return null
-    return padded.toLocalDate().takeIf { padded.toLocalTime() == JavaLocalTime.MIDNIGHT }
 }
 
-/** An `uuuuMMddTHHmmss` stamp, with or without the trailing `Z`, as its own wall clock. */
-private fun parsePaddedExdate(stamp: String): JavaLocalDateTime? =
-    runCatching { JavaLocalDateTime.parse(stamp, TIMED_EXDATE) }.getOrNull()
-        ?: runCatching { JavaLocalDateTime.parse(stamp, FLOATING_EXDATE) }.getOrNull()
-
-/**
- * [stamp] in the form Calendula writes, so two spellings of the same exclusion
- * compare equal. Null for a stamp in no form it reads.
- */
-internal fun canonicalExdateStamp(
-    stamp: String,
-    isAllDay: Boolean,
-    listZone: ZoneId,
-): String? = parseExdateStamp(stamp, isAllDay, ZoneOffset.UTC, listZone)
-    ?.let { formatExdateStamp(it, isAllDay, ZoneOffset.UTC) }
-
-/** `VALUE=DATE` EXDATE form, for an all-day series. */
-private val ALL_DAY_EXDATE: DateTimeFormatter =
-    DateTimeFormatter.ofPattern("uuuuMMdd").withResolverStyle(ResolverStyle.STRICT)
-
-/** UTC date-time EXDATE form, for a timed series. */
-private val TIMED_EXDATE: DateTimeFormatter =
-    DateTimeFormatter.ofPattern("uuuuMMdd'T'HHmmss'Z'").withResolverStyle(ResolverStyle.STRICT)
-
-/** The same form without the `Z`, wall clock in the list's zone rather than UTC. */
-private val FLOATING_EXDATE: DateTimeFormatter =
-    DateTimeFormatter.ofPattern("uuuuMMdd'T'HHmmss").withResolverStyle(ResolverStyle.STRICT)
-
 /**
  * The `EVENT_COLOR` / `EVENT_COLOR_KEY` columns for a colour selection. A
  * [colorKey] writes the key alone (the provider derives `EVENT_COLOR` from the
@@ -817,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 rfc2445Duration(if (isAllDay) span.coerceAtLeast(MILLIS_PER_DAY) else span, isAllDay)
-}
-
-private fun EventStatus.toProviderStatus(): Int = when (this) {
-    EventStatus.Confirmed -> CalendarContract.Events.STATUS_CONFIRMED
-    EventStatus.Tentative -> CalendarContract.Events.STATUS_TENTATIVE
-    EventStatus.Cancelled -> CalendarContract.Events.STATUS_CANCELED
-}

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

@@ -1,9 +1,10 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
 import de.jeanlucmakiola.floret.time.toKotlinInstantFromEpochMillis
+import de.jeanlucmakiola.calendula.domain.EventStatus
 import de.jeanlucmakiola.calendula.domain.ics.IcsEvent
 import de.jeanlucmakiola.calendula.domain.ics.deriveIcsUid
-import java.time.ZoneId
+import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
 
 /**
  * Map one Events row (read through [EventExportProjection]) into an [IcsEvent]
@@ -11,99 +12,44 @@ import java.time.ZoneId
  * [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
 
-    // Unclamped: the writer renders DTEND as stored.
+    // Recurring rows store DURATION instead of DTEND; reconstruct the end from it
-    val end = endMillis(dtStart, EventExportProjection.IDX_DTEND, EventExportProjection.IDX_DURATION)
+    // so the writer can render DTEND. A missing/blank both means a zero-length event.
+    val end = when {
+        !isNull(EventExportProjection.IDX_DTEND) -> getLong(EventExportProjection.IDX_DTEND)
+        else -> dtStart + parseRfc2445DurationMillis(getString(EventExportProjection.IDX_DURATION))
+    }
+
+    // STATUS shares value 0 with TENTATIVE, so an absent column must read as Confirmed.
+    val status = if (isNull(EventExportProjection.IDX_STATUS)) {
+        EventStatus.Confirmed
+    } else {
+        mapEventStatus(getInt(EventExportProjection.IDX_STATUS))
+    }
 
     return IcsEvent(
         uid = deriveIcsUid(getString(EventExportProjection.IDX_UID), eventId, dtStart),
         summary = getString(EventExportProjection.IDX_TITLE).orEmpty(),
         start = dtStart.toKotlinInstantFromEpochMillis(),
         end = end.toKotlinInstantFromEpochMillis(),
-        isAllDay = isAllDay,
+        isAllDay = getInt(EventExportProjection.IDX_ALL_DAY) != 0,
         zoneId = getString(EventExportProjection.IDX_EVENT_TIMEZONE)?.takeIf { it.isNotBlank() }
             ?: "UTC",
         recurrenceRule = rrule,
-        exDates = if (rrule == null) {
-            emptyList()
-        } else {
-            exportExDates(
-                getString(EventExportProjection.IDX_EXDATE),
-                isAllDay,
-                getString(EventExportProjection.IDX_EVENT_TIMEZONE),
-            )
-        },
         location = getString(EventExportProjection.IDX_LOCATION),
         description = getString(EventExportProjection.IDX_DESCRIPTION),
-        reminderMinutes = if (isAllDay) {
+        reminderMinutes = reminderMinutes,
-            val startDate = utcDate(dtStart)
+        status = status,
-            reminderMinutes.map {
-                fromProviderAllDayMinutes(it, startDate, zone, allDayReminderTimeMinutes)
-            }
-        } else {
-            reminderMinutes
-        },
-        status = eventStatus(EventExportProjection.IDX_STATUS),
         availability = mapAvailability(getInt(EventExportProjection.IDX_AVAILABILITY)),
         calendarName = calendarName,
     )
 }
 
-/**
- * The row's `EXDATE` as the writer wants it: one stamp per entry, empties
- * dropped.
- *
- * An all-day exclusion names a calendar day, and sync adapters are inconsistent
- * about whether they write it as a bare `yyyyMMdd` or pad it to a midnight
- * stamp; the time part is dropped so the exported value is the day either way.
- * Calendula's own writes ([buildOccurrenceExdateValues]) are already bare.
- *
- * A zoned exclusion arrives in AOSP's `RecurrenceSet` form, `<zone>;<stamps>`,
- * where the prefix names the zone the whole list is wall clock in. [IcsWriter]
- * emits one bare `EXDATE:` line, and a parameter belongs before that colon, not
- * inside the value — passed on as-is it would make the line unparseable. The
- * prefix is therefore taken off and its stamps resolved to UTC instants
- * ([canonicalExdateStamp], the same reading the write path does), the form every
- * reader accepts.
- *
- * Which zone that resolution uses is [exdateListZone]'s call, the same one the
- * write path makes: the `TZID=` when this device's tz database knows the name,
- * else the row's own [eventTimezone]. A stamp is never emitted floating just
- * because the prefix named a zone we couldn't place — against a `DTSTART;TZID=…`
- * line every reader would resolve it in its own zone and the exclusion would stop
- * matching its occurrence.
- */
-internal fun exportExDates(
-    exdate: String?,
-    isAllDay: Boolean,
-    eventTimezone: String? = null,
-): List<String> {
-    if (exdate.isNullOrBlank()) return emptyList()
-    val zone = exdateListZone(exdate, eventTimezone)
-    return exdateStamps(exdate)
-        .map { stamp ->
-            if (isAllDay) {
-                stamp.substringBefore('T')
-            } else {
-                canonicalExdateStamp(stamp, isAllDay = false, listZone = zone) ?: stamp
-            }
-        }
-        .distinct()
-}

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

@@ -1,10 +1,8 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
 import de.jeanlucmakiola.floret.time.toKotlinInstantFromEpochMillis
-import android.provider.CalendarContract
 import android.util.Log
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.domain.EventResponse
 
 private const val TAG = "InstanceMapper"
 
@@ -21,11 +19,14 @@ internal fun ColumnReader.toEventInstance(): EventInstance? {
         return null
     }
 
-    // Left blank when the event has no title: the placeholder is a display
+    val rawTitle = getString(InstanceProjection.IDX_TITLE)
-    // string, so it belongs to the UI layer where it can be localised (#321).
+    val title = if (rawTitle.isNullOrEmpty()) Fallbacks.UNTITLED_EVENT else rawTitle
-    val title = getString(InstanceProjection.IDX_TITLE).orEmpty()
 
-    val color = getIntOrNull(InstanceProjection.IDX_EVENT_COLOR) ?: getInt(InstanceProjection.IDX_CALENDAR_COLOR)
+    val color = if (isNull(InstanceProjection.IDX_EVENT_COLOR)) {
+        getInt(InstanceProjection.IDX_CALENDAR_COLOR)
+    } else {
+        getInt(InstanceProjection.IDX_EVENT_COLOR)
+    }
 
     return EventInstance(
         instanceId = getLong(InstanceProjection.IDX_INSTANCE_ID),
@@ -37,17 +38,5 @@ internal fun ColumnReader.toEventInstance(): EventInstance? {
         isAllDay = getInt(InstanceProjection.IDX_ALL_DAY) != 0,
         color = color,
         location = getString(InstanceProjection.IDX_LOCATION),
-        response = mapEventResponse(getInt(InstanceProjection.IDX_SELF_ATTENDEE_STATUS)),
     )
 }
-
-/**
- * `SELF_ATTENDEE_STATUS` as the calendar surfaces read it: a tentative "maybe"
- * counts as going, and everything that is not an open or refused invitation —
- * your own events included — falls through to [EventResponse.Going].
- */
-internal fun mapEventResponse(raw: Int): EventResponse = when (raw) {
-    CalendarContract.Attendees.ATTENDEE_STATUS_DECLINED -> EventResponse.Declined
-    CalendarContract.Attendees.ATTENDEE_STATUS_INVITED -> EventResponse.Invited
-    else -> EventResponse.Going
-}

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

@@ -1,16 +1,7 @@
 package de.jeanlucmakiola.calendula.data.calendar
 
-import android.content.ContentUris
-import android.net.Uri
 import android.provider.CalendarContract
 
-/** The `Instances` table over the window [beginMillis]..[endMillis]. */
-internal fun instancesUri(beginMillis: Long, endMillis: Long): Uri =
-    CalendarContract.Instances.CONTENT_URI.buildUpon().apply {
-        ContentUris.appendId(this, beginMillis)
-        ContentUris.appendId(this, endMillis)
-    }.build()
-
 internal object CalendarProjection {
     val COLUMNS: Array<String> = arrayOf(
         CalendarContract.Calendars._ID,
@@ -61,7 +52,6 @@ internal object InstanceProjection {
         CalendarContract.Instances.EVENT_COLOR,
         CalendarContract.Instances.CALENDAR_COLOR,
         CalendarContract.Instances.EVENT_LOCATION,
-        CalendarContract.Instances.SELF_ATTENDEE_STATUS,
     )
 
     const val IDX_INSTANCE_ID = 0
@@ -74,7 +64,6 @@ internal object InstanceProjection {
     const val IDX_EVENT_COLOR = 7
     const val IDX_CALENDAR_COLOR = 8
     const val IDX_LOCATION = 9
-    const val IDX_SELF_ATTENDEE_STATUS = 10
 }
 
 internal object EventDetailProjection {
@@ -130,12 +119,10 @@ internal object EventDetailProjection {
 /**
  * Master/one-off Events rows for a whole-calendar backup. Unlike
  * [EventDetailProjection] this reads `UID_2445` (to keep a row's identity across
- * backups) and `DURATION` (recurring rows carry it instead of DTEND), plus
+ * backups) and `DURATION` (recurring rows carry it instead of DTEND). Modified-
- * `EXDATE` so a series exports the occurrences deleted from it. Modified-
  * occurrence and cancelled-exception rows are filtered out by the query
- * (`ORIGINAL_ID IS NULL`), so RECURRENCE-ID overrides aren't exported — a
+ * (`ORIGINAL_ID IS NULL`), so RECURRENCE-ID overrides and EXDATEs aren't
- * documented v1 limit (import skips them too). EXDATE is unaffected by that
+ * exported yet — a documented v1 limit (import skips them too).
- * filter: it lives on the master row, not on an exception of its own.
  */
 internal object EventExportProjection {
     val COLUMNS: Array<String> = arrayOf(
@@ -148,7 +135,6 @@ internal object EventExportProjection {
         CalendarContract.Events.ALL_DAY,
         CalendarContract.Events.EVENT_TIMEZONE,
         CalendarContract.Events.RRULE,
-        CalendarContract.Events.EXDATE,
         CalendarContract.Events.EVENT_LOCATION,
         CalendarContract.Events.DESCRIPTION,
         CalendarContract.Events.STATUS,
@@ -165,12 +151,11 @@ internal object EventExportProjection {
     const val IDX_ALL_DAY = 6
     const val IDX_EVENT_TIMEZONE = 7
     const val IDX_RRULE = 8
-    const val IDX_EXDATE = 9
+    const val IDX_LOCATION = 9
-    const val IDX_LOCATION = 10
+    const val IDX_DESCRIPTION = 10
-    const val IDX_DESCRIPTION = 11
+    const val IDX_STATUS = 11
-    const val IDX_STATUS = 12
+    const val IDX_AVAILABILITY = 12
-    const val IDX_AVAILABILITY = 13
+    const val IDX_CALENDAR_ID = 13
-    const val IDX_CALENDAR_ID = 14
 }
 
 /**
@@ -197,7 +182,6 @@ internal object SearchProjection {
         CalendarContract.Events.RDATE,
         // Excerpted, not just filtered on: a hit has to show what it matched.
         CalendarContract.Events.DESCRIPTION,
-        CalendarContract.Events.SELF_ATTENDEE_STATUS,
     )
 
     const val IDX_ID = 0
@@ -213,7 +197,6 @@ internal object SearchProjection {
     const val IDX_RRULE = 10
     const val IDX_RDATE = 11
     const val IDX_DESCRIPTION = 12
-    const val IDX_SELF_ATTENDEE_STATUS = 13
 }
 
 /**
@@ -260,26 +243,40 @@ internal object MoveMasterProjection {
 
 /**
  * The exception rows of a recurring series (`ORIGINAL_ID` = the series), read to
- * carry them over to a moved copy (see [ExceptionRowSnapshot]). Both modified
+ * replay them against a moved copy (see [ExceptionRowSnapshot]). Both modified
  * occurrences and cancellations (`STATUS_CANCELED`) are read; the query filters
- * `DELETED = 0` so provider tombstones aren't carried over.
+ * `DELETED = 0` so provider tombstones aren't replayed.
  */
 internal object ExceptionProjection {
     val COLUMNS: Array<String> = arrayOf(
         CalendarContract.Events._ID,
         CalendarContract.Events.ORIGINAL_INSTANCE_TIME,
         CalendarContract.Events.STATUS,
+        CalendarContract.Events.TITLE,
+        CalendarContract.Events.ALL_DAY,
         CalendarContract.Events.DTSTART,
         CalendarContract.Events.DTEND,
         CalendarContract.Events.DURATION,
+        CalendarContract.Events.EVENT_TIMEZONE,
+        CalendarContract.Events.AVAILABILITY,
+        CalendarContract.Events.ACCESS_LEVEL,
+        CalendarContract.Events.EVENT_LOCATION,
+        CalendarContract.Events.DESCRIPTION,
     )
 
     const val IDX_ID = 0
     const val IDX_ORIGINAL_INSTANCE_TIME = 1
     const val IDX_STATUS = 2
-    const val IDX_DTSTART = 3
+    const val IDX_TITLE = 3
-    const val IDX_DTEND = 4
+    const val IDX_ALL_DAY = 4
-    const val IDX_DURATION = 5
+    const val IDX_DTSTART = 5
+    const val IDX_DTEND = 6
+    const val IDX_DURATION = 7
+    const val IDX_EVENT_TIMEZONE = 8
+    const val IDX_AVAILABILITY = 9
+    const val IDX_ACCESS_LEVEL = 10
+    const val IDX_LOCATION = 11
+    const val IDX_DESCRIPTION = 12
 }
 
 internal object AttendeeProjection {
@@ -307,3 +304,8 @@ internal object ReminderProjection {
     const val IDX_MINUTES = 0
     const val IDX_METHOD = 1
 }
+
+internal object Fallbacks {
+    const val UNNAMED_CALENDAR = "(Unbenannter Kalender)"
+    const val UNTITLED_EVENT = "(Ohne Titel)"
+}

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

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

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

@@ -2,6 +2,7 @@ package de.jeanlucmakiola.calendula.data.calendar
 
 import de.jeanlucmakiola.floret.time.toKotlinInstantFromEpochMillis
 import de.jeanlucmakiola.calendula.domain.EventInstance
+import de.jeanlucmakiola.calendula.domain.ics.parseRfc2445DurationMillis
 
 /**
  * Map an Events-table row (a search hit) to an [EventInstance]. Unlike the
@@ -15,11 +16,18 @@ internal fun ColumnReader.toSearchResult(): EventInstance? {
     // long-running birthdays/anniversaries still surface in search.
     if (isNull(SearchProjection.IDX_DTSTART)) return null
     val dtStart = getLong(SearchProjection.IDX_DTSTART)
-    val end = endMillis(dtStart, SearchProjection.IDX_DTEND, SearchProjection.IDX_DURATION)
+    val end = when {
-        .coerceAtLeast(dtStart)
+        !isNull(SearchProjection.IDX_DTEND) -> getLong(SearchProjection.IDX_DTEND)
+        else -> dtStart + parseRfc2445DurationMillis(getString(SearchProjection.IDX_DURATION))
+    }.coerceAtLeast(dtStart)
 
-    val title = getString(SearchProjection.IDX_TITLE).orEmpty()
+    val rawTitle = getString(SearchProjection.IDX_TITLE)
-    val color = getIntOrNull(SearchProjection.IDX_EVENT_COLOR) ?: getInt(SearchProjection.IDX_CALENDAR_COLOR)
+    val title = if (rawTitle.isNullOrEmpty()) Fallbacks.UNTITLED_EVENT else rawTitle
+    val color = if (isNull(SearchProjection.IDX_EVENT_COLOR)) {
+        getInt(SearchProjection.IDX_CALENDAR_COLOR)
+    } else {
+        getInt(SearchProjection.IDX_EVENT_COLOR)
+    }
     val eventId = getLong(SearchProjection.IDX_ID)
 
     return EventInstance(
@@ -34,6 +42,5 @@ internal fun ColumnReader.toSearchResult(): EventInstance? {
         location = getString(SearchProjection.IDX_LOCATION),
         isRecurring = !getString(SearchProjection.IDX_RRULE).isNullOrEmpty() ||
             !getString(SearchProjection.IDX_RDATE).isNullOrEmpty(),
-        response = mapEventResponse(getInt(SearchProjection.IDX_SELF_ATTENDEE_STATUS)),
     )
 }

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

@@ -2,15 +2,16 @@ package de.jeanlucmakiola.calendula.data.contacts
 
 import android.Manifest
 import android.content.Context
+import android.content.pm.PackageManager
 import android.provider.ContactsContract
 import android.provider.ContactsContract.CommonDataKinds.Event
 import android.util.Log
+import androidx.core.content.ContextCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.domain.contacts.ContactSpecialDate
 import de.jeanlucmakiola.calendula.domain.contacts.SpecialDateType
 import de.jeanlucmakiola.calendula.domain.contacts.managedUid
 import de.jeanlucmakiola.calendula.domain.contacts.parseContactEventDate
-import de.jeanlucmakiola.floret.android.hasPermission
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -30,7 +31,8 @@ interface ContactSpecialDatesDataSource {
 
 /** Whether `READ_CONTACTS` is granted — the gate for every contacts read. */
 fun Context.hasContactsPermission(): Boolean =
-    hasPermission(Manifest.permission.READ_CONTACTS)
+    ContextCompat.checkSelfPermission(this, Manifest.permission.READ_CONTACTS) ==
+        PackageManager.PERMISSION_GRANTED
 
 /** Map a `ContactsContract` event `TYPE` to our calendar bucket. */
 internal fun specialDateTypeForRawEventType(type: Int): SpecialDateType = when (type) {

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

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

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

@@ -20,10 +20,8 @@ import de.jeanlucmakiola.calendula.data.contacts.ContactSpecialDatesDataSource
 import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesCalendarSpec
 import de.jeanlucmakiola.calendula.data.reminders.ProviderReminderInstanceSource
 import de.jeanlucmakiola.calendula.data.reminders.ReminderInstanceSource
-import de.jeanlucmakiola.calendula.data.time.AndroidTodaySource
+import kotlinx.coroutines.CoroutineDispatcher
-import de.jeanlucmakiola.calendula.data.time.AndroidZoneSource
+import kotlinx.coroutines.Dispatchers
-import de.jeanlucmakiola.calendula.data.time.TodaySource
-import de.jeanlucmakiola.calendula.data.time.ZoneSource
 import javax.inject.Singleton
 
 private val Context.calendulaDataStore: DataStore<Preferences> by preferencesDataStore(
@@ -63,18 +61,6 @@ abstract class DataBindModule {
     abstract fun bindSpecialDatesCalendarSpec(
         impl: AndroidSpecialDatesCalendarSpec,
     ): SpecialDatesCalendarSpec
-
-    @Binds
-    @Singleton
-    abstract fun bindTodaySource(
-        impl: AndroidTodaySource,
-    ): TodaySource
-
-    @Binds
-    @Singleton
-    abstract fun bindZoneSource(
-        impl: AndroidZoneSource,
-    ): ZoneSource
 }
 
 @Module
@@ -85,4 +71,8 @@ object DataProvideModule {
     @Singleton
     fun provideDataStore(@ApplicationContext context: Context): DataStore<Preferences> =
         context.calendulaDataStore
+
+    @Provides
+    @IoDispatcher
+    fun provideIoDispatcher(): CoroutineDispatcher = Dispatchers.IO
 }

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

@@ -0,0 +1,7 @@
+package de.jeanlucmakiola.calendula.data.di
+
+import javax.inject.Qualifier
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class IoDispatcher

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

@@ -1,13 +1,15 @@
 package de.jeanlucmakiola.calendula.data.prefs
 
 import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.MutablePreferences
 import androidx.datastore.preferences.core.Preferences
-import de.jeanlucmakiola.floret.prefs.Pref
+import androidx.datastore.preferences.core.booleanPreferencesKey
-import de.jeanlucmakiola.floret.prefs.PrefStore
+import androidx.datastore.preferences.core.edit
-import de.jeanlucmakiola.floret.prefs.nullableBooleanPref
+import androidx.datastore.preferences.core.longPreferencesKey
-import de.jeanlucmakiola.floret.prefs.nullableLongPref
+import androidx.datastore.preferences.core.stringPreferencesKey
-import de.jeanlucmakiola.floret.prefs.nullableStringPref
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -24,13 +26,18 @@ import javax.inject.Singleton
  */
 @Singleton
 class CalendarPrefs @Inject constructor(
-    store: DataStore<Preferences>,
+    private val store: DataStore<Preferences>,
 ) {
-    private val prefs = PrefStore(store)
 
-    val hiddenCalendarIds: Flow<Set<Long>> = prefs.flow(HIDDEN_IDS)
+    // Both id sets are deduped: the store is shared with SettingsPrefs, so any
+    // unrelated write would otherwise re-emit an identical set.
+    val hiddenCalendarIds: Flow<Set<Long>> = store.data
+        .map { prefs -> prefs[HIDDEN_IDS_KEY].parseIds() }
+        .distinctUntilChanged()
 
-    suspend fun setHiddenCalendarIds(ids: Set<Long>) = prefs.set(HIDDEN_IDS, ids)
+    suspend fun setHiddenCalendarIds(ids: Set<Long>) {
+        store.edit { prefs -> prefs.writeIds(HIDDEN_IDS_KEY, ids) }
+    }
 
     /**
      * Switch-offs the provider does not know about yet, because writing
@@ -41,18 +48,24 @@ class CalendarPrefs @Inject constructor(
      * second visibility model: `CalendarVisibilityReconciler` drains it entry by
      * entry as soon as the app may write, and nothing adds to it while it may.
      */
-    val pendingDisabledCalendarIds: Flow<Set<Long>> = prefs.flow(DISABLED_IDS)
+    val pendingDisabledCalendarIds: Flow<Set<Long>> = store.data
+        .map { prefs -> prefs[DISABLED_IDS_KEY].parseIds() }
+        .distinctUntilChanged()
 
-    suspend fun addPendingDisabledCalendarIds(ids: Collection<Long>) {
+    suspend fun addPendingDisabledCalendarIds(ids: Collection<Long>) =
-        prefs.update(DISABLED_IDS) { it + ids }
+        editPendingDisabled { it + ids }
-    }
 
     /**
      * Drop [ids] from the pending set, one at a time as the reconciler flushes
      * them, so a run that fails part-way never re-applies what already landed.
      */
-    suspend fun removePendingDisabledCalendarIds(ids: Collection<Long>) {
+    suspend fun removePendingDisabledCalendarIds(ids: Collection<Long>) =
-        prefs.update(DISABLED_IDS) { it - ids.toSet() }
+        editPendingDisabled { it - ids.toSet() }
+
+    private suspend fun editPendingDisabled(transform: (Set<Long>) -> Set<Long>) {
+        store.edit { prefs ->
+            prefs.writeIds(DISABLED_IDS_KEY, transform(prefs[DISABLED_IDS_KEY].parseIds()))
+        }
     }
 
     /**
@@ -60,28 +73,39 @@ class CalendarPrefs @Inject constructor(
      * owed. Null until the reconciler has evaluated it (which needs the calendar
      * permission), false once it has been shown or was never needed.
      */
-    val visibilityNoticePending: Flow<Boolean?> = prefs.flow(VISIBILITY_NOTICE)
+    val visibilityNoticePending: Flow<Boolean?> = store.data.map { prefs ->
+        prefs[VISIBILITY_NOTICE_KEY]
+    }
 
-    suspend fun setVisibilityNoticePending(pending: Boolean) = prefs.set(VISIBILITY_NOTICE, pending)
+    suspend fun setVisibilityNoticePending(pending: Boolean) {
+        store.edit { prefs -> prefs[VISIBILITY_NOTICE_KEY] = pending }
+    }
 
     /**
      * The calendar the user last created an event in; preselected in the
      * event form. Null until the first event is created.
      */
-    val lastUsedCalendarId: Flow<Long?> = prefs.flow(LAST_USED_CALENDAR)
+    val lastUsedCalendarId: Flow<Long?> = store.data.map { prefs ->
+        prefs[LAST_USED_CALENDAR_KEY]
+    }
 
-    suspend fun setLastUsedCalendarId(id: Long) = prefs.set(LAST_USED_CALENDAR, id)
+    suspend fun setLastUsedCalendarId(id: Long) {
+        store.edit { prefs -> prefs[LAST_USED_CALENDAR_KEY] = id }
+    }
 
-    private companion object {
+    companion object {
-        val HIDDEN_IDS = idSetPref("hidden_calendar_ids")
+        internal val HIDDEN_IDS_KEY = stringPreferencesKey("hidden_calendar_ids")
-        val DISABLED_IDS = idSetPref("disabled_calendar_ids")
+        internal val DISABLED_IDS_KEY = stringPreferencesKey("disabled_calendar_ids")
-        val VISIBILITY_NOTICE = nullableBooleanPref("visibility_notice_pending")
+        internal val VISIBILITY_NOTICE_KEY = booleanPreferencesKey("visibility_notice_pending")
-        val LAST_USED_CALENDAR = nullableLongPref("last_used_calendar_id")
+        internal val LAST_USED_CALENDAR_KEY = longPreferencesKey("last_used_calendar_id")
     }
 }
 
-/** A comma-joined id set; non-numeric tokens are dropped, and an empty set removes the key. */
+private fun String?.parseIds(): Set<Long> = orEmpty()
-private fun idSetPref(name: String): Pref<Set<Long>> = nullableStringPref(name).map(
+    .split(',')
-    { stored -> stored.orEmpty().split(',').mapNotNull { it.trim().toLongOrNull() }.toSet() },
+    .mapNotNull { it.trim().toLongOrNull() }
-    { ids -> if (ids.isEmpty()) null else ids.sorted().joinToString(",") },
+    .toSet()
-)
+
+private fun MutablePreferences.writeIds(key: Preferences.Key<String>, ids: Set<Long>) {
+    if (ids.isEmpty()) remove(key) else set(key, ids.sorted().joinToString(","))
+}

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

@@ -2,8 +2,10 @@ package de.jeanlucmakiola.calendula.data.prefs
 
 import androidx.datastore.core.DataStore
 import androidx.datastore.preferences.core.Preferences
-import de.jeanlucmakiola.floret.prefs.PrefStore
+import androidx.datastore.preferences.core.edit
-import de.jeanlucmakiola.floret.prefs.nullableLongPref
+import androidx.datastore.preferences.core.longPreferencesKey
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -18,16 +20,17 @@ import javax.inject.Singleton
  */
 @Singleton
 class ReminderStatePrefs @Inject constructor(
-    store: DataStore<Preferences>,
+    private val store: DataStore<Preferences>,
 ) {
-    private val prefs = PrefStore(store)
 
     /** The watermark, or `null` before the first scan has ever run. */
-    suspend fun lastScanMillis(): Long? = prefs.get(LAST_SCAN)
+    suspend fun lastScanMillis(): Long? = store.data.map { it[LAST_SCAN_KEY] }.first()
 
-    suspend fun setLastScanMillis(millis: Long) = prefs.set(LAST_SCAN, millis)
+    suspend fun setLastScanMillis(millis: Long) {
+        store.edit { prefs -> prefs[LAST_SCAN_KEY] = millis }
+    }
 
     private companion object {
-        val LAST_SCAN = nullableLongPref("reminder_last_scan_millis")
+        val LAST_SCAN_KEY = longPreferencesKey("reminder_last_scan_millis")
     }
 }

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

@@ -6,8 +6,11 @@ import android.content.Intent
 import androidx.core.net.toUri
 import dagger.hilt.android.AndroidEntryPoint
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
-import de.jeanlucmakiola.floret.android.goAsync
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 /**
@@ -41,17 +44,27 @@ class ReminderActionReceiver : BroadcastReceiver() {
                 // Cancel now so the notification doesn't linger until the alarm;
                 // the snooze delay read is the only async work.
                 notifier.cancel(alert)
-                goAsync {
+                val pendingResult = goAsync()
-                    val minutes = settingsPrefs.snoozeMinutes.first()
+                CoroutineScope(SupervisorJob() + Dispatchers.IO).launch {
-                    val triggerAt = System.currentTimeMillis() + minutes * 60_000L
+                    try {
-                    scheduler.schedule(alert, triggerAt)
+                        val minutes = settingsPrefs.snoozeMinutes.first()
+                        val triggerAt = System.currentTimeMillis() + minutes * 60_000L
+                        scheduler.schedule(alert, triggerAt)
+                    } finally {
+                        pendingResult.finish()
+                    }
                 }
             }
 
             ACTION_SHOW -> {
-                goAsync {
+                val pendingResult = goAsync()
-                    if (settingsPrefs.remindersEnabled.first() && notifier.canPost()) {
+                CoroutineScope(SupervisorJob() + Dispatchers.IO).launch {
-                        notifier.post(alert)
+                    try {
+                        if (settingsPrefs.remindersEnabled.first() && notifier.canPost()) {
+                            notifier.post(alert)
+                        }
+                    } finally {
+                        pendingResult.finish()
                     }
                 }
             }

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

@@ -4,12 +4,20 @@ import android.app.AlarmManager
 import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
+import android.os.Build
 import androidx.core.content.getSystemService
 import dagger.hilt.android.qualifiers.ApplicationContext
-import de.jeanlucmakiola.floret.android.setWakeup
 import javax.inject.Inject
 import javax.inject.Singleton
 
+/**
+ * True on API < 31 (no restriction), and on 31+ when the exact-alarm capability
+ * is held — auto-granted via `USE_EXACT_ALARM` on API 33+ (Calendula is a
+ * calendar app), user-revocable on 31–32.
+ */
+internal fun AlarmManager.canScheduleExactCompat(): Boolean =
+    Build.VERSION.SDK_INT < Build.VERSION_CODES.S || canScheduleExactAlarms()
+
 /**
  * Holds the app's own wake-up for the next reminder (#75). Exactly one alarm
  * exists at a time, for the earliest reminder ahead; every firing re-scans and
@@ -23,7 +31,16 @@ class ReminderAlarmScheduler @Inject constructor(
 
     fun scheduleScan(triggerAtMillis: Long) {
         val alarmManager = context.getSystemService<AlarmManager>() ?: return
-        alarmManager.setWakeup(triggerAtMillis, scanPendingIntent(PendingIntent.FLAG_UPDATE_CURRENT))
+        val pendingIntent = scanPendingIntent(PendingIntent.FLAG_UPDATE_CURRENT)
+        if (alarmManager.canScheduleExactCompat()) {
+            alarmManager.setExactAndAllowWhileIdle(
+                AlarmManager.RTC_WAKEUP, triggerAtMillis, pendingIntent,
+            )
+        } else {
+            alarmManager.setAndAllowWhileIdle(
+                AlarmManager.RTC_WAKEUP, triggerAtMillis, pendingIntent,
+            )
+        }
     }
 
     /** Drop the pending wake-up — reminders are off, or there is nothing to wait for. */

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

@@ -1,9 +1,9 @@
 package de.jeanlucmakiola.calendula.data.reminders
 
 import android.content.Context
+import android.content.ContentUris
 import android.provider.CalendarContract
 import dagger.hilt.android.qualifiers.ApplicationContext
-import de.jeanlucmakiola.calendula.data.calendar.instancesUri
 import de.jeanlucmakiola.calendula.domain.reminders.ReminderEventInstance
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -37,20 +37,16 @@ class ProviderReminderInstanceSource @Inject constructor(
 ) : ReminderInstanceSource {
 
     override fun occurrences(fromMillis: Long, toMillis: Long): List<ReminderEventInstance> {
-        val uri = instancesUri(fromMillis, toMillis)
+        val uri = CalendarContract.Instances.CONTENT_URI.buildUpon().apply {
+            ContentUris.appendId(this, fromMillis)
+            ContentUris.appendId(this, toMillis)
+        }.build()
         // `visible` is the flag the app's one visibility model writes (#75).
         // The status clause mirrors CalendarDataSource.instances: NULL means
         // "normal", so a bare `!= CANCELED` would drop every ordinary event.
-        // An invitation the user declined is answered — it stays on the calendar
-        // struck through, but it plans nothing (#180). NULL again means "no
-        // answer recorded", which is not a "no".
         val selection = "${CalendarContract.Calendars.VISIBLE} = 1 AND " +
             "(${CalendarContract.Instances.STATUS} IS NULL OR " +
-            "${CalendarContract.Instances.STATUS} != " +
+            "${CalendarContract.Instances.STATUS} != ${CalendarContract.Events.STATUS_CANCELED})"
-            "${CalendarContract.Events.STATUS_CANCELED}) AND " +
-            "(${CalendarContract.Instances.SELF_ATTENDEE_STATUS} IS NULL OR " +
-            "${CalendarContract.Instances.SELF_ATTENDEE_STATUS} != " +
-            "${CalendarContract.Attendees.ATTENDEE_STATUS_DECLINED})"
         return context.contentResolver.query(
             uri, OCCURRENCE_PROJECTION, selection, null, null,
         )?.use { c ->

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

@@ -5,10 +5,12 @@ import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.PendingIntent
 import android.content.Context
+import android.content.pm.PackageManager
 import android.os.Build
 import android.util.Log
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.ContextCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.MainActivity
 import de.jeanlucmakiola.calendula.R
@@ -17,7 +19,6 @@ import de.jeanlucmakiola.calendula.data.prefs.CalendarPrefs
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.is24Hour
 import de.jeanlucmakiola.calendula.data.prefs.resolveFirstDay
-import de.jeanlucmakiola.floret.android.hasPermission
 import kotlinx.coroutines.flow.first
 import kotlinx.datetime.isoDayNumber
 import java.time.DayOfWeek
@@ -47,7 +48,8 @@ class ReminderNotifier @Inject constructor(
     /** False when the user declined `POST_NOTIFICATIONS` or muted the app. */
     fun canPost(): Boolean {
         val granted = Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU ||
-            context.hasPermission(Manifest.permission.POST_NOTIFICATIONS)
+            ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) ==
+            PackageManager.PERMISSION_GRANTED
         return granted && NotificationManagerCompat.from(context).areNotificationsEnabled()
     }
 
@@ -61,9 +63,13 @@ class ReminderNotifier @Inject constructor(
         calendarId in calendarPrefs.pendingDisabledCalendarIds.first() ||
             calendarDataSource.isCalendarVisible(calendarId) == false
 
-    /** Post [alert], unless its calendar is switched off. */
+    /**
-    suspend fun post(alert: ReminderAlert) {
+     * Post [alert], unless its calendar is switched off. Returns whether the
-        if (isSilenced(alert.calendarId)) return
+     * notification was put up, which the snooze re-show path uses to tell a
+     * silenced reminder from a delivered one.
+     */
+    suspend fun post(alert: ReminderAlert): Boolean {
+        if (isSilenced(alert.calendarId)) return false
         ensureChannel()
         val title = alert.title.ifBlank { context.getString(R.string.event_untitled) }
         val is24Hour = settingsPrefs.timeFormat.first()
@@ -82,7 +88,6 @@ class ReminderNotifier @Inject constructor(
             is24Hour = is24Hour,
             today = Instant.now().atZone(zone).toLocalDate(),
             firstDayOfWeek = firstDayOfWeek,
-            todayLabel = context.getString(R.string.reminder_day_today),
             tomorrowLabel = context.getString(R.string.reminder_day_tomorrow),
             yesterdayLabel = context.getString(R.string.reminder_day_yesterday),
         )
@@ -116,6 +121,8 @@ class ReminderNotifier @Inject constructor(
             // POST_NOTIFICATIONS was revoked between canPost() and here.
             Log.w(TAG, "Could not post reminder for event ${alert.eventId}", e)
         }
+        // Handled either way — a retry hits the same revoked permission.
+        return true
     }
 
     /** Remove a posted reminder (snooze re-shows it later; dismiss is final). */

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

@@ -2,18 +2,18 @@ package de.jeanlucmakiola.calendula.data.reminders
 
 import android.Manifest
 import android.content.Context
+import android.content.pm.PackageManager
 import android.util.Log
+import androidx.core.content.ContextCompat
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.data.calendar.CalendarDataSource
-import de.jeanlucmakiola.calendula.data.calendar.withoutProviderDefaults
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.ReminderStatePrefs
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.reminders.planReminders
 import de.jeanlucmakiola.calendula.domain.reminders.reminderQueryHorizon
 import de.jeanlucmakiola.calendula.domain.reminders.reminderWatermark
 import de.jeanlucmakiola.calendula.domain.reminders.scheduleReminders
-import de.jeanlucmakiola.floret.android.hasPermission
-import de.jeanlucmakiola.floret.di.IoDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.CoroutineStart
 import kotlinx.coroutines.SupervisorJob
@@ -90,8 +90,7 @@ class ReminderScanner @Inject constructor(
         val occurrences = source.occurrences(now - PAST_WINDOW_MILLIS, now + lookahead)
         val planned = planReminders(
             instances = occurrences,
-            minutesByEvent = source.reminderMinutes(occurrences.map { it.eventId })
+            minutesByEvent = source.reminderMinutes(occurrences.map { it.eventId }),
-                .withoutProviderDefaults(),
             zone = ZoneId.systemDefault(),
             allDayTimeMinutes = settingsPrefs.allDayReminderTimeMinutes.first(),
         )
@@ -112,7 +111,9 @@ class ReminderScanner @Inject constructor(
         alarms.scheduleScan(schedule.nextAlarmMillis)
     }
 
-    private fun hasReadCalendar(): Boolean = context.hasPermission(Manifest.permission.READ_CALENDAR)
+    private fun hasReadCalendar(): Boolean = ContextCompat.checkSelfPermission(
+        context, Manifest.permission.READ_CALENDAR,
+    ) == PackageManager.PERMISSION_GRANTED
 
     /**
      * Re-scan when the provider changes, so a saved or deleted event re-arms the

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

@@ -4,7 +4,10 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import dagger.hilt.android.AndroidEntryPoint
-import de.jeanlucmakiola.floret.android.goAsync
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 /**
@@ -26,7 +29,14 @@ class ReminderScheduleReceiver : BroadcastReceiver() {
         // exported and the broadcasts it takes are protected, so any other
         // action did not come from where it claims to.
         if (intent.action !in HANDLED_ACTIONS) return
-        goAsync { scanner.scan() }
+        val pendingResult = goAsync()
+        CoroutineScope(SupervisorJob() + Dispatchers.IO).launch {
+            try {
+                scanner.scan()
+            } finally {
+                pendingResult.finish()
+            }
+        }
     }
 
     companion object {

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

@@ -3,9 +3,9 @@ package de.jeanlucmakiola.calendula.data.reminders
 import android.app.AlarmManager
 import android.app.PendingIntent
 import android.content.Context
+import android.os.Build
 import androidx.core.content.getSystemService
 import dagger.hilt.android.qualifiers.ApplicationContext
-import de.jeanlucmakiola.floret.android.setWakeup
 import javax.inject.Inject
 import javax.inject.Singleton
 
@@ -31,6 +31,24 @@ class ReminderSnoozeScheduler @Inject constructor(
             ReminderActionReceiver.intent(context, ReminderActionReceiver.ACTION_SHOW, alert),
             PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
         )
-        alarmManager.setWakeup(triggerAtMillis, pendingIntent)
+        if (canScheduleExact(alarmManager)) {
+            alarmManager.setExactAndAllowWhileIdle(
+                AlarmManager.RTC_WAKEUP, triggerAtMillis, pendingIntent,
+            )
+        } else {
+            // Exact alarms revoked (API 31–32); an inexact wake is the best
+            // available without nagging for SCHEDULE_EXACT_ALARM.
+            alarmManager.setAndAllowWhileIdle(
+                AlarmManager.RTC_WAKEUP, triggerAtMillis, pendingIntent,
+            )
+        }
     }
+
+    /**
+     * True on API < 31 (no restriction), and on 31+ when the exact-alarm
+     * capability is held — auto-granted via `USE_EXACT_ALARM` on API 33+
+     * (Calendula is a calendar app), user-revocable on 31–32.
+     */
+    private fun canScheduleExact(alarmManager: AlarmManager): Boolean =
+        Build.VERSION.SDK_INT < Build.VERSION_CODES.S || alarmManager.canScheduleExactAlarms()
 }

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

@@ -27,12 +27,12 @@ import java.util.Locale
  *                                                          alone would be ambiguous)
  * - timed, crossing days: "11 Jun, 23:30 – 12 Jun, 00:30" (medium date + short time,
  *                                                          already unambiguous)
- * - all-day, one day:     "Tomorrow" / "Thu" / "11 Jun 2026" (same relative rules,
+ * - all-day, one day:     "11 Jun 2026"
- *                                                          plus [todayLabel] — no time range to lean on)
+ * - all-day, multi-day:   "11 Jun 2026 – 12 Jun 2026"
- * - all-day, multi-day:   "Tomorrow – 12 Jun 2026"        (relative start, explicit end)
  *
- * All-day instances store UTC midnights with an exclusive end, so they are read
+ * All-day instances already carry an explicit date, so they never gain a
- * in UTC and the end day is the last *covered* day (issue #308).
+ * relative prefix. They store UTC midnights with an exclusive end, so they are
+ * read in UTC and the end day is the last *covered* day.
  */
 fun reminderTimeText(
     beginMillis: Long,
@@ -43,7 +43,6 @@ fun reminderTimeText(
     is24Hour: Boolean,
     today: LocalDate,
     firstDayOfWeek: DayOfWeek,
-    todayLabel: String,
     tomorrowLabel: String,
     yesterdayLabel: String,
 ): String {
@@ -54,16 +53,11 @@ fun reminderTimeText(
         val lastDay = Instant.ofEpochMilli(endMillis).atZone(ZoneOffset.UTC).toLocalDate()
             .minusDays(1)
             .coerceAtLeast(firstDay)
-        val start = relativeDayPrefix(
+        return if (lastDay == firstDay) {
-            day = firstDay,
+            dateFormat.format(firstDay)
-            today = today,
+        } else {
-            firstDayOfWeek = firstDayOfWeek,
+            dateFormat.format(firstDay) + RANGE + dateFormat.format(lastDay)
-            locale = locale,
+        }
-            dateFormat = dateFormat,
-            tomorrowLabel = tomorrowLabel,
-            yesterdayLabel = yesterdayLabel,
-        ) ?: todayLabel
-        return if (lastDay == firstDay) start else start + RANGE + dateFormat.format(lastDay)
     }
 
     val timeFormat = timeOfDayFormatter(is24Hour, locale)

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

@@ -1,67 +0,0 @@
-package de.jeanlucmakiola.calendula.data.time
-
-import android.content.Context
-import android.content.Intent
-import dagger.hilt.android.qualifiers.ApplicationContext
-import de.jeanlucmakiola.floret.android.broadcastTicks
-import de.jeanlucmakiola.floret.android.stateWhileSubscribed
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.onEach
-import kotlinx.coroutines.flow.transformLatest
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.toLocalDateTime
-import javax.inject.Inject
-import kotlin.time.Clock
-
-/** The current local date, re-emitted whenever it changes (#373). */
-interface TodaySource {
-    val today: Flow<LocalDate>
-}
-
-/**
- * Re-reads the date on every minute boundary while collected, and at once on the
- * system's date, time and zone broadcasts, which can arrive late or not at all.
- */
-@OptIn(ExperimentalCoroutinesApi::class)
-class AndroidTodaySource @Inject constructor(
-    @ApplicationContext private val context: Context,
-) : TodaySource {
-
-    override val today: Flow<LocalDate> = context
-        .broadcastTicks(Intent.ACTION_DATE_CHANGED, Intent.ACTION_TIME_CHANGED, Intent.ACTION_TIMEZONE_CHANGED)
-        .transformLatest {
-            while (true) {
-                emit(currentDate())
-                delay(MINUTE_MILLIS - Clock.System.now().toEpochMilliseconds() % MINUTE_MILLIS)
-            }
-        }
-        .distinctUntilChanged()
-}
-
-private const val MINUTE_MILLIS = 60_000L
-
-fun currentDate(): LocalDate = Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()).date
-
-/**
- * Today as a hot flow seeded with [initial]. [onRollover] runs with the previous
- * and the new date each time the day changes while collected, so a screen left
- * open over midnight can move off yesterday (#373).
- */
-fun Flow<LocalDate>.stateFollowingDays(
-    scope: CoroutineScope,
-    initial: LocalDate,
-    onRollover: (old: LocalDate, new: LocalDate) -> Unit,
-): StateFlow<LocalDate> {
-    var last = initial
-    return onEach { date ->
-        val old = last
-        last = date
-        if (old != date) onRollover(old, date)
-    }.stateWhileSubscribed(scope, initial)
-}

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

@@ -1,36 +0,0 @@
-package de.jeanlucmakiola.calendula.data.time
-
-import android.content.Context
-import android.content.Intent
-import dagger.hilt.android.qualifiers.ApplicationContext
-import de.jeanlucmakiola.floret.android.broadcastTicks
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.map
-import kotlinx.datetime.TimeZone
-import javax.inject.Inject
-
-/**
- * The zone the device is in. Every screen that turns wall clock into instants
- * reads it from here, so the timeline, the event form and a saved move use the
- * same zone (#387).
- */
-interface ZoneSource {
-    /** The device's zone, re-emitted whenever it changes. */
-    val zone: Flow<TimeZone>
-
-    /** The device's zone right now. */
-    fun current(): TimeZone
-}
-
-/** Follows the system's zone broadcast. */
-class AndroidZoneSource @Inject constructor(
-    @ApplicationContext private val context: Context,
-) : ZoneSource {
-
-    override val zone: Flow<TimeZone> = context.broadcastTicks(Intent.ACTION_TIMEZONE_CHANGED)
-        .map { current() }
-        .distinctUntilChanged()
-
-    override fun current(): TimeZone = TimeZone.currentSystemDefault()
-}

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

@@ -46,19 +46,3 @@ fun hasSystemHiddenCalendars(
     calendars: List<CalendarSource>,
     pendingDisabledIds: Set<Long>,
 ): Boolean = calendars.any { !it.isVisibleInSystem && it.id !in pendingDisabledIds }
-
-/**
- * The failure a calendar list implies, or null when there is something to show.
- * Distinguishes "the device has no calendars" from "every one of them is
- * switched off" (#239) — both leave the grid empty, but only the second is
- * fixed from Settings → Calendars.
- *
- * The filter sheet's own hidden set is deliberately not folded in: emptying it
- * is a deliberate act taken moments earlier, in a sheet that is still one tap
- * away.
- */
-fun calendarListFailure(calendars: List<CalendarSource>): FailureReason? = when {
-    calendars.isEmpty() -> FailureReason.NoCalendarsConfigured
-    calendars.none { it.isVisibleInSystem } -> FailureReason.AllCalendarsHidden
-    else -> null
-}

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

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

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

@@ -1,18 +0,0 @@
-package de.jeanlucmakiola.calendula.domain
-
-import kotlinx.datetime.TimeZone
-
-/** Lower values appear first in lists and get the upper visible lanes in grids. */
-fun EventInstance.displayPriority(zone: TimeZone): Int = when {
-    isDeclined -> 3
-    spansMultipleDays(zone) -> 0
-    isAllDay -> 1
-    else -> 2
-}
-
-/** Shared order for agenda and split day lists. Grid bars add their lane geometry. */
-fun eventDisplayComparator(zone: TimeZone): Comparator<EventInstance> =
-    compareBy<EventInstance> { it.displayPriority(zone) }
-        .thenBy { it.start }
-        .thenBy { it.title }
-        .thenBy { it.instanceId }

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

@@ -4,7 +4,7 @@ import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
-import kotlinx.datetime.UtcOffset
+import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Instant
 
@@ -17,8 +17,8 @@ data class EventForm(
     val calendarId: Long?,
     val title: String = "",
     val isAllDay: Boolean = false,
-    val start: FormTime,
+    val start: LocalDateTime,
-    val end: FormTime,
+    val end: LocalDateTime,
     /**
      * The zone [start]/[end] are wall-clock values in, or null to follow the
      * device — null is not "no zone", it is "whichever zone the device is in
@@ -70,19 +70,6 @@ data class EventForm(
     val attendees: List<EventAttendee> = emptyList(),
 )
 
-/**
- * One end of a form's span: a wall-clock [dateTime] in the form's zone, and the
- * [offset] it was read at when the fall-back hour repeats that wall clock — both
- * of the hour's instants share one [LocalDateTime] (#387). Null everywhere else,
- * so a time changed and changed back compares equal again. A time picked by hand
- * gets its pass from [repicked]; one without an offset reads as the earlier
- * pass. One value, so a time never changes without its pass. See [toFormTime].
- */
-data class FormTime(val dateTime: LocalDateTime, val offset: UtcOffset? = null) {
-    val date: LocalDate get() = dateTime.date
-    val time: LocalTime get() = dateTime.time
-}
-
 /**
  * One editable guest: the user controls the [email] (the identity we dedup and
  * write on), an optional display [name], and whether they're [optional] rather
@@ -148,23 +135,26 @@ enum class EventFormProblem {
 fun EventDetail.toEditForm(beginMillis: Long, endMillis: Long, zone: TimeZone): EventForm {
     // All-day events are date-anchored and carry a nominal "UTC" that is an
     // anchor, not a location, so they never pin a zone.
-    val pinned = if (instance.isAllDay) {
+    val pinnedZone = if (instance.isAllDay) {
         null
     } else {
         eventTimezone
             ?.takeIf { it != zone.id }
             // An unparseable id (a malformed sync row) can't be honoured or
             // shown; fall back to the device zone rather than failing the open.
-            ?.let { id -> zoneOrNull(id)?.let { id to it } }
+            ?.takeIf { runCatching { TimeZone.of(it) }.isSuccess }
     }
-    val pinnedZone = pinned?.first
+    val formZone = pinnedZone?.let { TimeZone.of(it) } ?: zone
-    val formZone = pinned?.second ?: zone
-    val begin = Instant.fromEpochMilliseconds(beginMillis)
-    val finish = Instant.fromEpochMilliseconds(endMillis)
     val (start, end) = if (instance.isAllDay) {
-        allDayFormTimes(begin.toLocalDateTime(TimeZone.UTC).date, finish.toLocalDateTime(TimeZone.UTC).date)
+        val startDate = Instant.fromEpochMilliseconds(beginMillis)
+            .toLocalDateTime(TimeZone.UTC).date
+        val endExclusive = Instant.fromEpochMilliseconds(endMillis)
+            .toLocalDateTime(TimeZone.UTC).date
+        val endDate = maxOf(startDate, LocalDate.fromEpochDays(endExclusive.toEpochDays() - 1))
+        LocalDateTime(startDate, LocalTime(9, 0)) to LocalDateTime(endDate, LocalTime(10, 0))
     } else {
-        begin.toFormTime(formZone) to finish.toFormTime(formZone)
+        Instant.fromEpochMilliseconds(beginMillis).toLocalDateTime(formZone) to
+            Instant.fromEpochMilliseconds(endMillis).toLocalDateTime(formZone)
     }
     return EventForm(
         calendarId = instance.calendarId,
@@ -178,7 +168,7 @@ fun EventDetail.toEditForm(beginMillis: Long, endMillis: Long, zone: TimeZone):
         reminders = reminders.map { it.minutes }.distinct().sorted(),
         availability = availability,
         accessLevel = accessLevel,
-        rrule = rrule.normalizedRrule(),
+        rrule = rrule?.removePrefix("RRULE:")?.takeIf { it.isNotBlank() },
         // The provider fills EVENT_COLOR from the key, so [color] is the
         // swatch either way; a null colour means the event inherits its
         // calendar's colour.
@@ -231,30 +221,20 @@ fun EventDetail.toEditSnapshot(beginMillis: Long, endMillis: Long, zone: TimeZon
     )
 
 /**
- * Form times for an all-day span stored as UTC midnights with an exclusive
+ * The form's times as they land in [target] — what a pinned event's wall-clock
- * end: the last covered day (never before [start]), with placeholder
+ * actually means where the user is standing. Null when there's nothing to
- * wall-clock times kept in case the user switches the event to timed.
+ * disambiguate: an unpinned event (already in [target]), one pinned to [target]
- */
+ * itself, an all-day event (no zone), or an unparseable pinned zone.
-internal fun allDayFormTimes(start: LocalDate, endExclusive: LocalDate?): Pair<FormTime, FormTime> {
-    val end = endExclusive?.let { maxOf(start, LocalDate.fromEpochDays(it.toEpochDays() - 1)) } ?: start
-    return FormTime(LocalDateTime(start, LocalTime(9, 0))) to FormTime(LocalDateTime(end, LocalTime(10, 0)))
-}
-
-/** The bare RRULE value the form edits; blank means none. */
-internal fun String?.normalizedRrule(): String? = this?.removePrefix("RRULE:")?.takeIf { it.isNotBlank() }
-
-/**
- * Whether this form's times mean something else in [target] — a timed event
- * pinned to another zone. False when there's nothing to disambiguate: an
- * unpinned event (already in [target]), one pinned to [target] itself, an
- * all-day event (no zone), or an unparseable pinned zone.
  *
- * The form edits a pinned event in its own zone, so this is what tells the UI
+ * The form edits a pinned event in its own zone, so this is what lets the UI
- * to show the other side of the pair rather than making the user do the arithmetic.
+ * show the other side of the pair rather than making the user do the arithmetic.
  */
-fun EventForm.isPinnedAwayFrom(target: TimeZone): Boolean {
+fun EventForm.timesIn(target: TimeZone): Pair<LocalDateTime, LocalDateTime>? {
-    if (isAllDay) return false
+    if (isAllDay) return null
-    return resolvedZone(target).id != target.id
+    val pinned = timezone?.let { runCatching { TimeZone.of(it) }.getOrNull() } ?: return null
+    if (pinned.id == target.id) return null
+    return start.toInstant(pinned).toLocalDateTime(target) to
+        end.toInstant(pinned).toLocalDateTime(target)
 }
 
 /**
@@ -274,19 +254,9 @@ fun EventForm.populatedFields(): Set<EventFormField> = buildSet {
     if (attendees.isNotEmpty()) add(EventFormField.Attendees)
 }
 
-/**
+fun EventForm.problems(): Set<EventFormProblem> = buildSet {
- * What stops this form from saving. A timed span is checked as instants in the
- * form's zone (else [deviceZone]): one ending in the fall-back hour's repeat can
- * end on an earlier wall clock than it starts (#387).
- */
-fun EventForm.problems(deviceZone: TimeZone): Set<EventFormProblem> = buildSet {
     if (calendarId == null) add(EventFormProblem.NoCalendar)
-    val endsTooEarly = if (isAllDay) {
+    val endsTooEarly = if (isAllDay) end.date < start.date else end < start
-        end.date < start.date
-    } else {
-        val zone = resolvedZone(deviceZone)
-        endInstant(zone) < startInstant(zone)
-    }
     if (endsTooEarly) add(EventFormProblem.EndBeforeStart)
     // An UNTIL before the first day would make the provider generate zero
     // occurrences — the event would silently vanish from every view.
@@ -295,20 +265,3 @@ fun EventForm.problems(deviceZone: TimeZone): Set<EventFormProblem> = buildSet {
         add(EventFormProblem.RecurrenceEndsBeforeStart)
     }
 }
-
-/**
- * A create form seeded from this occurrence, to save a copy as a new,
- * independent event (#52). The recurrence is dropped — a duplicate is a single
- * event. The source calendar is kept only when [canModify], otherwise the id is
- * cleared so the create resolves to a writable calendar, which lets a read-only
- * event be copied into an editable one. [instance]'s own times carry over.
- */
-fun EventDetail.toDuplicateForm(canModify: Boolean, zone: TimeZone): EventForm =
-    toEditForm(
-        beginMillis = instance.start.toEpochMilliseconds(),
-        endMillis = instance.end.toEpochMilliseconds(),
-        zone = zone,
-    ).copy(
-        rrule = null,
-        calendarId = instance.calendarId.takeIf { canModify },
-    )

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

@@ -1,8 +1,8 @@
 package de.jeanlucmakiola.calendula.domain
 
 import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
-import kotlinx.datetime.YearMonth
 import kotlinx.datetime.atStartOfDayIn
 import kotlinx.datetime.number
 import kotlinx.datetime.plus
@@ -101,13 +101,19 @@ object EventSearch {
 
         val today = todayStart.toLocalDateTime(zone).date
         val matched = candidates.mapNotNull { candidate -> match(candidate, tokens, now, zone) }
-        val (upcoming, past) = matched.partition { it.event.spanLastDay(zone) >= today }
+        val upcoming = { m: Matched -> m.event.spanLastDay(zone) >= today }
-        // What is left reads forwards; what is behind us reads backwards from
+        val order = compareBy<Matched> { if (upcoming(it)) 0 else 1 }
-        // today, nearest first.
+            .thenComparator { a, b ->
-        val ordered = upcoming.sortedBy { it.event.dayStart(zone) } +
+                // What is left reads forwards; what is behind us reads backwards
-            past.sortedByDescending { it.event.dayStart(zone) }
+                // from today, nearest first.
+                if (upcoming(a)) {
+                    a.event.dayStart(zone).compareTo(b.event.dayStart(zone))
+                } else {
+                    b.event.dayStart(zone).compareTo(a.event.dayStart(zone))
+                }
+            }
 
-        val (inDescriptions, dated) = ordered.partition { it.descriptionOnly }
+        val (inDescriptions, dated) = matched.sortedWith(order).partition { it.descriptionOnly }
         return SearchResults(
             months = groupByMonth(dated, zone, todayStart),
             inDescriptions = inDescriptions.map { it.hit },
@@ -120,18 +126,33 @@ object EventSearch {
         zone: TimeZone,
         todayStart: Instant,
     ): List<SearchMonth> {
-        val current = todayStart.toLocalDateTime(zone).date.let { YearMonth(it.year, it.month) }
+        val currentKey = monthKey(todayStart.toLocalDateTime(zone).date)
-        val groups = dated.groupBy { m -> m.event.spanFirstDay(zone).let { YearMonth(it.year, it.month) } }
+        return dated
-        val (behind, ahead) = groups.keys.partition { it < current }
+            .groupBy { monthKey(it.event.spanFirstDay(zone)) }
-        return (ahead.sorted() + behind.sortedDescending()).map { month ->
+            .entries
-            SearchMonth(
+            .sortedWith(
-                year = month.year,
+                compareBy<Map.Entry<Int, List<Matched>>> {
-                monthNumber = month.month.number,
+                    when {
-                hits = groups.getValue(month).map { it.hit },
+                        it.key == currentKey -> 0
+                        it.key > currentKey -> 1
+                        else -> 2
+                    }
+                }.thenComparator { a, b ->
+                    if (a.key > currentKey) a.key.compareTo(b.key) else b.key.compareTo(a.key)
+                },
             )
-        }
+            .map { (key, entries) ->
+                SearchMonth(
+                    year = key / 12,
+                    monthNumber = key % 12 + 1,
+                    hits = entries.map { it.hit },
+                )
+            }
     }
 
+    /** Year and month as one comparable number. */
+    private fun monthKey(date: LocalDate): Int = date.year * 12 + (date.month.number - 1)
+
     private fun match(
         candidate: SearchCandidate,
         tokens: List<String>,
@@ -141,20 +162,16 @@ object EventSearch {
         val title = candidate.title?.takeIf { it.isNotBlank() }
         val location = candidate.event.location?.takeIf { it.isNotBlank() }
         // Collapsed so a multi-line description matches the way it is drawn.
-        val rich = candidate.description?.let(::descriptionRichText)
+        val description = candidate.description
-        val description = rich?.text
             ?.replace(WHITESPACE, " ")
             ?.trim()
             ?.takeIf { it.isNotEmpty() }
-        // A link's address isn't in the drawn text, but "zoom.us" should still find the invite.
-        val linkUrls = rich?.links.orEmpty().map { it.url }
 
         // Mid-word counts: "termin" has to keep finding "Zahnarzttermin".
         val present = { token: String ->
             title?.contains(token, ignoreCase = true) == true ||
                 location?.contains(token, ignoreCase = true) == true ||
-                description?.contains(token, ignoreCase = true) == true ||
+                description?.contains(token, ignoreCase = true) == true
-                linkUrls.any { it.contains(token, ignoreCase = true) }
         }
         if (!tokens.all(present)) return null
 

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

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

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

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

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

@@ -1,6 +1,10 @@
 package de.jeanlucmakiola.calendula.domain
 
+import kotlinx.datetime.LocalDate
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toInstant
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Duration.Companion.hours
 import kotlin.time.Instant
@@ -21,27 +25,37 @@ import kotlin.time.Instant
  * the extras lives in `MainActivity.insertFormOrNull`.
  */
 fun buildInsertEventForm(
-    beginMillis: Long? = null,
+    beginMillis: Long?,
-    endMillis: Long? = null,
+    endMillis: Long?,
-    isAllDay: Boolean = false,
+    isAllDay: Boolean,
     title: String?,
     description: String?,
-    location: String? = null,
+    location: String?,
-    rrule: String? = null,
+    rrule: String?,
     zone: TimeZone,
     now: Instant,
 ): EventForm {
     val (start, end) = if (isAllDay) {
+        // All-day provider times are UTC midnights with an exclusive end; show
+        // the last covered day and keep placeholder wall-clock times in case the
+        // user switches the event to timed (mirrors EventDetail.toEditForm).
         val startDate = beginMillis
             ?.let { Instant.fromEpochMilliseconds(it).toLocalDateTime(TimeZone.UTC).date }
             ?: now.toLocalDateTime(zone).date
-        val endExclusive = endMillis?.let { Instant.fromEpochMilliseconds(it).toLocalDateTime(TimeZone.UTC).date }
+        val endDate = endMillis
-        allDayFormTimes(startDate, endExclusive)
+            ?.let { Instant.fromEpochMilliseconds(it).toLocalDateTime(TimeZone.UTC).date }
+            ?.let { exclusive -> maxOf(startDate, LocalDate.fromEpochDays(exclusive.toEpochDays() - 1)) }
+            ?: startDate
+        LocalDateTime(startDate, LocalTime(9, 0)) to LocalDateTime(endDate, LocalTime(10, 0))
     } else {
-        val startAt = beginMillis?.let(Instant::fromEpochMilliseconds) ?: nextFullHour(now)
+        val startTime = beginMillis
-        val endAt = endMillis?.let(Instant::fromEpochMilliseconds)?.takeIf { it >= startAt }
+            ?.let { Instant.fromEpochMilliseconds(it).toLocalDateTime(zone) }
-            ?: (startAt + 1.hours)
+            ?: nextFullHour(now, zone)
-        startAt.toFormTime(zone) to endAt.toFormTime(zone)
+        val endTime = endMillis
+            ?.let { Instant.fromEpochMilliseconds(it).toLocalDateTime(zone) }
+            ?.takeIf { it >= startTime }
+            ?: (startTime.toInstant(zone) + 1.hours).toLocalDateTime(zone)
+        startTime to endTime
     }
     return EventForm(
         calendarId = null,
@@ -53,38 +67,12 @@ fun buildInsertEventForm(
         description = description.orEmpty(),
         // Bare RRULE value (Events.RRULE convention); tolerate a leading "RRULE:"
         // some callers include.
-        rrule = rrule.normalizedRrule(),
+        rrule = rrule?.removePrefix("RRULE:")?.takeIf { it.isNotBlank() },
     )
 }
 
-/** The first full hour after [now]: may roll into the next day before midnight. */
+private fun nextFullHour(now: Instant, zone: TimeZone): LocalDateTime {
-internal fun nextFullHour(now: Instant): Instant {
     val hourMillis = 3_600_000L
-    return Instant.fromEpochMilliseconds((now.toEpochMilliseconds() / hourMillis + 1) * hourMillis)
+    val rounded = (now.toEpochMilliseconds() / hourMillis + 1) * hourMillis
-}
+    return Instant.fromEpochMilliseconds(rounded).toLocalDateTime(zone)
-
-/** Title and description for text shared or selected into the app (#306). */
-data class SharedText(val title: String, val description: String)
-
-/**
- * Split shared text into an event title and description: the share's subject
- * becomes the title and the text the description. Without a subject the text's
- * first non-blank line is the title and the rest the description. A title longer
- * than [maxTitle] is cut, and the full text then stays in the description.
- * Null when there is nothing to use.
- */
-fun sharedTextOrNull(subject: String?, text: String?, maxTitle: Int = 255): SharedText? {
-    val body = text?.trim().orEmpty()
-    val given = subject?.trim()?.takeIf { it.isNotEmpty() }
-    val (title, rest) = if (given != null) {
-        given to body
-    } else {
-        val lines = body.lines()
-        val first = lines.firstOrNull()?.trim()?.takeIf { it.isNotEmpty() } ?: return null
-        first to lines.drop(1).joinToString("\n").trim()
-    }
-    if (title.length <= maxTitle) return SharedText(title, rest)
-    val cut = title.take(maxTitle).let { if (it.last().isHighSurrogate()) it.dropLast(1) else it }
-    val full = if (given != null) listOf(given, body).filter { it.isNotEmpty() }.joinToString("\n\n") else body
-    return SharedText(cut.trimEnd(), full)
 }

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

@@ -67,36 +67,8 @@ data class EventInstance(
      * Instances query already yields one row per occurrence.
      */
     val isRecurring: Boolean = false,
-    /**
-     * This device user's own answer to the invitation, as far as the grids care
-     * (#180, #230).
-     */
-    val response: EventResponse = EventResponse.Going,
 )
 
-/**
- * How this device user stands towards an event's invitation
- * (`Events.SELF_ATTENDEE_STATUS`), reduced to the three cases the calendar
- * surfaces draw differently (#230).
- */
-enum class EventResponse {
-    /** Your own event, or one you accepted — including a tentative "maybe". */
-    Going,
-
-    /** Invited, no answer given yet: drawn as an outline so it reads as still open. */
-    Invited,
-
-    /**
-     * You answered "no". The event stays on the calendar — it is still an
-     * appointment someone expects an answer about — but every surface strikes it
-     * through, and it plans no reminders (#180).
-     */
-    Declined,
-}
-
-/** Shorthand for the declined case, which most surfaces test on its own (#180). */
-val EventInstance.isDeclined: Boolean get() = response == EventResponse.Declined
-
 /**
  * Whether this event has finished relative to [now] — its end is at or before
  * the current instant. An in-progress event (already started but not yet ended)
@@ -165,17 +137,6 @@ data class EventDetail(
     val isException: Boolean = false,
 )
 
-/**
- * This event on one occurrence's times. The Events row holds the series start,
- * so a recurring event needs the tapped occurrence pinned to render and share right.
- */
-fun EventDetail.atOccurrence(beginMillis: Long, endMillis: Long): EventDetail = copy(
-    instance = instance.copy(
-        start = Instant.fromEpochMilliseconds(beginMillis),
-        end = Instant.fromEpochMilliseconds(endMillis),
-    ),
-)
-
 /**
  * One selectable event colour published by a calendar's account
  * (`CalendarContract.Colors`, `TYPE_EVENT`): [key] is the account-scoped
@@ -263,14 +224,6 @@ enum class RecurringWriteScope {
 enum class FailureReason {
     PermissionRevoked,
     NoCalendarsConfigured,
-    AllCalendarsHidden,
-
-    /**
-     * Calendars exist and are switched on, but none can receive an event: every
-     * one is read-only, app-managed, or not synced to this device. Distinct from
-     * [AllCalendarsHidden], which a visibility switch fixes.
-     */
-    NoImportTarget,
     ProviderUnavailable,
     EventNotFound,
     Unknown,

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

@@ -1,8 +1,5 @@
 package de.jeanlucmakiola.calendula.domain
 
-import de.jeanlucmakiola.calendula.domain.ics.parseBasicDate
-import de.jeanlucmakiola.calendula.domain.ics.parseBasicDateTime
-import de.jeanlucmakiola.calendula.domain.ics.toUtcBasic
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
@@ -60,13 +57,24 @@ fun parseSimpleRecurrence(
     rrule: String,
     zone: TimeZone = TimeZone.currentSystemDefault(),
 ): SimpleRecurrence? {
-    val parts = rruleParts(rrule).associate { part -> (part.key ?: return null) to part.value }
+    val parts = rrule.removePrefix("RRULE:").split(';')
+        .filter { it.isNotBlank() }
+        .associate { token ->
+            val eq = token.indexOf('=')
+            if (eq <= 0) return null
+            token.substring(0, eq).uppercase() to token.substring(eq + 1)
+        }
     if (parts.keys.any { it !in setOf("FREQ", "INTERVAL", "UNTIL", "COUNT", "WKST", "BYDAY") }) {
         return null
     }
 
-    val freq = RecurrenceFreq.entries.firstOrNull { it.name.equals(parts["FREQ"], ignoreCase = true) }
+    val freq = when (parts["FREQ"]?.uppercase()) {
-        ?: return null
+        "DAILY" -> RecurrenceFreq.Daily
+        "WEEKLY" -> RecurrenceFreq.Weekly
+        "MONTHLY" -> RecurrenceFreq.Monthly
+        "YEARLY" -> RecurrenceFreq.Yearly
+        else -> return null
+    }
     val interval = parts["INTERVAL"]?.let { it.toIntOrNull()?.takeIf { n -> n >= 1 } ?: return null } ?: 1
 
     // BYDAY is simple only as plain weekday picks on a weekly rule; ordinal
@@ -116,27 +124,20 @@ fun SimpleRecurrence.toRRule(zone: TimeZone = TimeZone.currentSystemDefault()):
     when (val e = end) {
         RecurrenceEnd.Never -> Unit
         is RecurrenceEnd.Until -> {
-            append(";UNTIL=")
+            val utc = LocalDateTime(e.date, LocalTime(23, 59, 59))
-            append(LocalDateTime(e.date, LocalTime(23, 59, 59)).toInstant(zone).toUtcBasic())
+                .toInstant(zone)
+                .toLocalDateTime(TimeZone.UTC)
+            append(
+                ";UNTIL=%04d%02d%02dT%02d%02d%02dZ".format(
+                    utc.year, utc.month.number, utc.day,
+                    utc.hour, utc.minute, utc.second,
+                ),
+            )
         }
         is RecurrenceEnd.Count -> append(";COUNT=${e.times}")
     }
 }
 
-/** One `;`-separated part of an RRULE as written; [key] is null when it has no `KEY=`. */
-internal class RrulePart(val raw: String) {
-    private val eq = raw.indexOf('=')
-    val key: String? = if (eq > 0) raw.substring(0, eq).uppercase() else null
-    val value: String = if (eq > 0) raw.substring(eq + 1) else ""
-}
-
-/**
- * [rule]'s non-blank parts, after an optional leading "RRULE:". What to do
- * with a malformed one (reject, repair or skip) is the caller's call.
- */
-internal fun rruleParts(rule: String): List<RrulePart> =
-    rule.removePrefix("RRULE:").split(';').filter { it.isNotBlank() }.map(::RrulePart)
-
 internal val RRULE_DAY_CODES: Map<DayOfWeek, String> = mapOf(
     DayOfWeek.MONDAY to "MO",
     DayOfWeek.TUESDAY to "TU",
@@ -164,7 +165,11 @@ fun rruleTruncatedAt(rrule: String, untilUtcMillis: Long): String {
             val key = part.substringBefore('=').trim().uppercase()
             key == "UNTIL" || key == "COUNT"
         }
-    val untilPart = "UNTIL=" + Instant.fromEpochMilliseconds(untilUtcMillis).toUtcBasic()
+    val until = Instant.fromEpochMilliseconds(untilUtcMillis).toLocalDateTime(TimeZone.UTC)
+    val untilPart = "UNTIL=%04d%02d%02dT%02d%02d%02dZ".format(
+        until.year, until.month.number, until.day,
+        until.hour, until.minute, until.second,
+    )
     return (kept + untilPart).joinToString(";")
 }
 
@@ -173,8 +178,20 @@ fun rruleTruncatedAt(rrule: String, untilUtcMillis: Long): String {
  * forms are UTC (RFC 5545); the date is taken after converting into [zone] so
  * a [toRRule]-rendered value round-trips to the day the user picked.
  */
-private fun parseUntilDate(raw: String, zone: TimeZone): LocalDate? {
+private fun parseUntilDate(raw: String, zone: TimeZone): LocalDate? = runCatching {
-    val date = parseBasicDate(raw) ?: return null
+    val date = LocalDate(
-    if (raw.length < 15 || raw[8] != 'T') return date
+        raw.substring(0, 4).toInt(),
-    return parseBasicDateTime(raw)?.toInstant(TimeZone.UTC)?.toLocalDateTime(zone)?.date
+        raw.substring(4, 6).toInt(),
-}
+        raw.substring(6, 8).toInt(),
+    )
+    if (raw.length >= 15 && raw[8] == 'T') {
+        val time = LocalTime(
+            raw.substring(9, 11).toInt(),
+            raw.substring(11, 13).toInt(),
+            raw.substring(13, 15).toInt(),
+        )
+        LocalDateTime(date, time).toInstant(TimeZone.UTC).toLocalDateTime(zone).date
+    } else {
+        date
+    }
+}.getOrNull()

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

@@ -19,30 +19,30 @@ import kotlinx.datetime.LocalDate
 fun realignRecurrence(rrule: String, oldStart: LocalDate, newStart: LocalDate): String? {
     if (oldStart == newStart) return rrule
     val prefix = if (rrule.startsWith("RRULE:")) "RRULE:" else ""
-    val parts = rruleParts(rrule)
+    val parts = rrule.removePrefix("RRULE:").split(';').filter { it.isNotBlank() }
     if (parts.isEmpty()) return null
-    var freq = false
     var weekly = false
-    var byDay = false
     val rebuilt = parts.map { part ->
-        val value = part.value.trim()
+        val eq = part.indexOf('=')
-        when (part.key) {
+        if (eq <= 0) return null
+        val key = part.substring(0, eq).uppercase()
+        val value = part.substring(eq + 1).trim()
+        when (key) {
             "FREQ" -> {
-                freq = true
                 weekly = value.equals("WEEKLY", ignoreCase = true)
-                part.raw
+                part
             }
             "BYDAY" -> {
-                byDay = true
                 val old = RRULE_DAY_CODES[oldStart.dayOfWeek] ?: return null
                 if (!value.equals(old, ignoreCase = true)) return null
                 "BYDAY=${RRULE_DAY_CODES.getValue(newStart.dayOfWeek)}"
             }
-            "INTERVAL", "COUNT", "UNTIL", "WKST" -> part.raw
+            "INTERVAL", "COUNT", "UNTIL", "WKST" -> part
             else -> return null
         }
     }
     // BYDAY is only simple on a weekly rule, matching parseSimpleRecurrence.
-    if (!freq || (byDay && !weekly)) return null
+    if (!weekly && parts.any { it.substringBefore('=').trim().uppercase() == "BYDAY" }) return null
+    if (parts.none { it.substringBefore('=').trim().uppercase() == "FREQ" }) return null
     return prefix + rebuilt.joinToString(";")
 }

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

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

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

@@ -1,47 +0,0 @@
-package de.jeanlucmakiola.calendula.domain.ics
-
-import kotlinx.datetime.LocalDate
-import kotlinx.datetime.LocalDateTime
-import kotlinx.datetime.LocalTime
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.format
-import kotlinx.datetime.format.char
-import kotlinx.datetime.toLocalDateTime
-import kotlin.time.Instant
-
-/** RFC 5545 basic format, `yyyyMMddTHHmmss`. */
-private val BASIC_DATE_TIME = LocalDateTime.Format {
-    date(LocalDate.Formats.ISO_BASIC)
-    char('T')
-    hour()
-    minute()
-    second()
-}
-
-/** `yyyyMMdd`. */
-internal fun LocalDate.toBasic(): String = format(LocalDate.Formats.ISO_BASIC)
-
-/** `yyyyMMddTHHmmss`, floating. */
-internal fun LocalDateTime.toBasic(): String = format(BASIC_DATE_TIME)
-
-/** `yyyyMMddTHHmmssZ`, the instant in UTC. */
-internal fun Instant.toUtcBasic(): String = toLocalDateTime(TimeZone.UTC).toBasic() + "Z"
-
-/**
- * The date in the first eight characters of a basic-format value; whatever
- * follows (a time, a `Z`) is ignored. Null when those aren't a valid date.
- */
-internal fun parseBasicDate(s: String): LocalDate? = runCatching {
-    LocalDate(s.substring(0, 4).toInt(), s.substring(4, 6).toInt(), s.substring(6, 8).toInt())
-}.getOrNull()
-
-/** `yyyyMMddTHHmm[ss]`; the separator isn't checked and missing seconds read as zero. */
-internal fun parseBasicDateTime(s: String): LocalDateTime? = runCatching {
-    val date = parseBasicDate(s) ?: return null
-    val time = LocalTime(
-        s.substring(9, 11).toInt(),
-        s.substring(11, 13).toInt(),
-        if (s.length >= 15) s.substring(13, 15).toInt() else 0,
-    )
-    LocalDateTime(date, time)
-}.getOrNull()

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

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

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

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

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

@@ -2,28 +2,19 @@ package de.jeanlucmakiola.calendula.domain.ics
 
 import de.jeanlucmakiola.calendula.domain.Availability
 import de.jeanlucmakiola.calendula.domain.EventStatus
-import de.jeanlucmakiola.calendula.domain.zoneOrNull
+import kotlinx.datetime.LocalDate
 import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.atStartOfDayIn
 import kotlinx.datetime.toInstant
-import kotlinx.datetime.toLocalDateTime
-import kotlin.math.ceil
-import kotlin.time.Duration.Companion.days
-import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.Instant
 
-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?,
@@ -39,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). */
@@ -91,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(
@@ -104,28 +52,8 @@ data class IcsParseResult(
     val warnings: Set<IcsParseWarning>,
 )
 
-/**
+/** Outcome of a bulk `.ics` import into one calendar. */
- * Outcome of a bulk `.ics` import into one calendar. [failed] counts events the
+data class IcsImportSummary(val imported: Int, val skippedDuplicate: Int)
- * provider rejected — the import continues past them, so a single unusable
- * event can't cost the user the rest of the file.
- *
- * [notAttempted] counts what a retry still has to import, because the permission
- * or the target calendar went away mid-file and every remaining insert would have
- * failed the same way. Events past that point whose UID is already in the
- * calendar count under [skippedDuplicate] instead — they were never going to be
- * added either way. It travels in the summary rather than as an exception so the
- * counts of what *did* land survive: an import is only idempotent for events that
- * carry a UID, so a retry told "nothing happened" would duplicate the rest.
- */
-data class IcsImportSummary(
-    val imported: Int,
-    val skippedDuplicate: Int,
-    val failed: Int = 0,
-    val notAttempted: Int = 0,
-)
-
-/** The non-standard property most exporters name the whole calendar with. */
-private const val CALENDAR_NAME_PROPERTY = "X-WR-CALNAME"
 
 /**
  * Hand-rolled RFC 5545 reader, the inverse of [IcsWriter]. Pure and
@@ -134,9 +62,6 @@ private const val CALENDAR_NAME_PROPERTY = "X-WR-CALNAME"
  * (`RECURRENCE-ID`, attendees, unresolved `TZID`) are reported as [warnings]
  * rather than silently dropped. `VTIMEZONE` blocks are skipped — a `TZID` is
  * resolved against the OS tz database instead ([deviceZone] is the fallback).
- *
- * `VTODO` components are read as all-day/timed events: Calendula models no
- * tasks, and dropping them would silently lose half of some exports.
  */
 class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault()) {
 
@@ -144,62 +69,42 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
         val lines = unfoldLines(text)
         val events = mutableListOf<ParsedIcsEvent>()
         val warnings = mutableSetOf<IcsParseWarning>()
-        // Scanned up front, not in document order: an X-WR-CALNAME after the
+        var calendarName: String? = null
-        // first VEVENT still names the calendar. The cheap prefix test first,
-        // so a file without one doesn't pay a full parse to find nothing.
-        val calendarName = lines.asSequence()
-            .filter { it.startsWith(CALENDAR_NAME_PROPERTY, ignoreCase = true) }
-            .mapNotNull(::parseContentLine)
-            .firstOrNull { it.name == CALENDAR_NAME_PROPERTY }
-            ?.let { unescapeText(it.value).trim().ifEmpty { null } }
 
         var 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 -> {
+                line.isBegin("VEVENT") -> {
-                    // A component whose END line never arrives ends at the next
+                    val end = indexOfEnd(lines, i + 1, "VEVENT")
-                    // one's BEGIN, not at that one's END: reading to the far END
+                    parseVevent(lines.subList(i + 1, end), calendarName, warnings)
-                    // would fold two events into one body, where the later
+                        ?.let(events::add)
-                    // properties overwrite the earlier and one event is lost.
+                    i = end + 1
-                    val end = indexOfEnd(lines, i + 1, component)
-                    val body = indexOfNextComponent(lines, i + 1, end)
-                    parseComponent(
-                        body = lines.subList(i + 1, body),
-                        fileCalendarName = calendarName,
-                        warnings = warnings,
-                        isTask = component == "VTODO",
-                    )?.let(events::add)
-                    i = if (body < end) body else 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
@@ -207,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
@@ -228,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)
@@ -243,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++
         }
@@ -264,121 +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)
+        val end = dtEnd
-        if (recurrence.repaired) warnings.add(IcsParseWarning.RecurrenceRuleRepaired)
+            ?: duration?.let {
-        val end = resolveEnd(start, dtEnd, duration)
+                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,
+            calendarName = calendarName,
-            color = eventColor ?: calendarColor,
-            exDates = if (recurrence.rule == null) {
-                emptyList()
-            } else {
-                normalizeExDates(exDateLines, start)
-            },
-            isTask = isTask,
         )
     }
 
-    /**
+    /** A VALARM's lead time in minutes before start, or null if not a usable relative trigger. */
-     * 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 { start.instant + parseRfc2445DurationMillis(it).milliseconds }
-        if (!start.isAllDay) return explicit ?: start.instant
-        return explicit?.takeIf { it > start.instant } ?: (start.instant + 1.days)
-    }
-
-    /**
-     * `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 = zoneOrNull(start.zoneId) ?: 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'))?.toBasic()
-                    token.contains('T') -> parseExDateTime(token, line, startZone)?.toUtcBasic()
-                    else -> parseBasicDate(token)
-                        ?.let { LocalDateTime(it, startTime).toInstant(startZone).toUtcBasic() }
-                }
-            }
-            .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(::zoneOrNull)
-                ?: 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.
-     */
     private fun parseAlarmMinutes(body: List<String>): Int? {
         val trigger = body.asSequence()
             .mapNotNull { parseContentLine(it) }
@@ -387,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? {
@@ -403,7 +206,7 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
         if (isUtc) return IcsDateTime(ldt.toInstant(TimeZone.UTC), isAllDay = false, zoneId = "UTC")
 
         val tzid = line.params["TZID"]
-        val resolved = tzid?.let { id -> zoneOrNull(id)?.let { id to it } }
+        val resolved = tzid?.let { id -> runCatching { TimeZone.of(id) }.getOrNull()?.let { id to it } }
         if (tzid != null && resolved == null) warnings.add(IcsParseWarning.UnknownTimezone)
         val (zoneId, zone) = resolved ?: (deviceZone.id to deviceZone)
         return IcsDateTime(ldt.toInstant(zone), isAllDay = false, zoneId = zoneId)
@@ -415,44 +218,42 @@ class IcsParser(private val deviceZone: TimeZone = TimeZone.currentSystemDefault
         fun IcsContentLine.isBegin(component: String) =
             name == "BEGIN" && value.trim().equals(component, true)
 
-        /**
+        /** Index of the matching `END:<component>` at/after [from], or list end. */
-         * A single-valued `CATEGORIES`, which is what the Fossify family writes
+        fun indexOfEnd(lines: List<String>, from: Int, component: String): Int {
-         * for the source calendar's name. A multi-item list is a tag list and
+            var i = from
-         * names no calendar, so it is ignored.
+            while (i < lines.size) {
-         */
+                val line = parseContentLine(lines[i])
-        fun singleCategory(raw: String): String? {
+                if (line != null && line.name == "END" &&
-            var escaped = false
+                    line.value.trim().equals(component, true)
-            for (c in raw) {
+                ) {
-                when {
+                    return i
-                    escaped -> escaped = false
-                    c == '\\' -> escaped = true
-                    c == ',' -> return null
                 }
+                i++
             }
-            return unescapeText(raw).trim()
+            return lines.size
-                .takeIf { it.isNotEmpty() && !it.equals("null", true) }
         }
 
-        /**
+        fun mapIcsStatus(value: String): EventStatus = when (value.trim().uppercase()) {
-         * Where an unterminated component's body has to stop: the next top-level
+            "TENTATIVE" -> EventStatus.Tentative
-         * `VEVENT` / `VTODO` in `[from, end)`, or [end] when there is none. A
+            "CANCELLED" -> EventStatus.Cancelled
-         * nested `VALARM` is part of the body and is not a boundary.
+            else -> EventStatus.Confirmed
-         */
+        }
-        fun indexOfNextComponent(lines: List<String>, from: Int, end: Int): Int =
-            (from until end).firstOrNull { i ->
-                val line = parseContentLine(lines[i])
-                line != null && (line.isBegin("VEVENT") || line.isBegin("VTODO"))
-            } ?: end
 
-        /** Index of the matching `END:<component>` at/after [from], or list end. */
+        fun parseBasicDate(s: String): LocalDate? = runCatching {
-        fun indexOfEnd(lines: List<String>, from: Int, component: String): Int =
+            LocalDate(s.substring(0, 4).toInt(), s.substring(4, 6).toInt(), s.substring(6, 8).toInt())
-            (from until lines.size).firstOrNull { i ->
+        }.getOrNull()
-                val line = parseContentLine(lines[i])
-                line != null && line.name == "END" && line.value.trim().equals(component, true)
-            } ?: lines.size
 
-        fun mapIcsStatus(value: String): EventStatus =
+        fun parseBasicDateTime(s: String): LocalDateTime? = runCatching {
-            EventStatus.entries.firstOrNull { it.name.equals(value.trim(), ignoreCase = true) }
+            val date = LocalDate(
-                ?: EventStatus.Confirmed
+                s.substring(0, 4).toInt(), s.substring(4, 6).toInt(), s.substring(6, 8).toInt(),
+            )
+            // Format is YYYYMMDD 'T' HHMMSS; seconds optional.
+            val time = LocalTime(
+                s.substring(9, 11).toInt(),
+                s.substring(11, 13).toInt(),
+                if (s.length >= 15) s.substring(13, 15).toInt() else 0,
+            )
+            LocalDateTime(date, time)
+        }.getOrNull()
     }
 }

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

@@ -1,133 +0,0 @@
-package de.jeanlucmakiola.calendula.domain.ics
-
-import de.jeanlucmakiola.calendula.domain.rruleParts
-
-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(",")
-    }
-
-    // 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.
-    for (part in rruleParts(raw.orEmpty().trim())) {
-        val key = part.key?.trim().orEmpty()
-        val value = part.value.trim()
-        val kept = when {
-            key.isEmpty() || value.isEmpty() -> null
-            key == "FREQ" ->
-                value.uppercase().takeIf { it in VALID_FREQ }
-                    ?.also { freqSeen = true }
-                    ?.let { "FREQ=$it" }
-            // A non-positive or non-numeric INTERVAL/COUNT is rejected by the
-            // provider, and a COUNT of zero would expand to no occurrences.
-            key == "INTERVAL" -> value.toIntOrNull()?.takeIf { it > 0 }?.let { "INTERVAL=$it" }
-            key == "COUNT" -> value.toIntOrNull()?.takeIf { it > 0 }?.let { "COUNT=$it" }
-            key == "UNTIL" ->
-                value.uppercase().takeIf { UNTIL_SHAPE.matches(it) }?.let { "UNTIL=$it" }
-            key == "WKST" ->
-                value.uppercase().takeIf { it in VALID_WEEKDAYS }?.let { "WKST=$it" }
-            key == "BYDAY" -> keepItems(value, ::isWeekdayItem)?.let { "BYDAY=$it" }
-            key in NUMERIC_LIST_PARTS ->
-                keepItems(value, NUMERIC_LIST_PARTS.getValue(key)::accepts)?.let { "$key=$it" }
-            else -> null
-        }
-        if (kept == null) repaired = true else parts += kept
-    }
-    // `EventRecurrence.parse` ends with *two* global checks, not one: a missing
-    // FREQ throws, and so does an UNTIL that arrives together with a COUNT. A
-    // rule carrying both is malformed per RFC 5545 §3.3.10 but real producers
-    // emit it, and left alone it would throw straight out of `insert` — the very
-    // failure this function exists to prevent. UNTIL is kept: it bounds the
-    // series at an absolute date, so a stale COUNT can't over-generate past it.
-    if (parts.any { it.startsWith("UNTIL=") }) {
-        if (parts.removeAll { it.startsWith("COUNT=") }) repaired = true
-    }
-    return if (freqSeen) {
-        SanitizedRrule(rule = parts.joinToString(";"), repaired = repaired)
-    } else {
-        SanitizedRrule(rule = null, repaired = true)
-    }
-}
-
-/** A `BYDAY` item: a two-letter weekday, optionally preceded by an ordinal. */
-private fun isWeekdayItem(item: String): Boolean {
-    if (item.length < 2) return false
-    val ordinal = item.dropLast(2)
-    return item.takeLast(2) in VALID_WEEKDAYS &&
-        (ordinal.isEmpty() || ordinal.toIntOrNull() != null)
-}

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

@@ -2,8 +2,9 @@ package de.jeanlucmakiola.calendula.domain.ics
 
 import de.jeanlucmakiola.calendula.domain.Availability
 import de.jeanlucmakiola.calendula.domain.EventStatus
-import de.jeanlucmakiola.calendula.domain.zoneOrNull
+import kotlinx.datetime.LocalDateTime
 import kotlinx.datetime.TimeZone
+import kotlinx.datetime.number
 import kotlinx.datetime.toLocalDateTime
 import kotlin.time.Instant
 
@@ -40,12 +41,11 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) {
     private fun MutableList<String>.appendEvent(event: IcsEvent, dtStamp: Instant) {
         add("BEGIN:VEVENT")
         add("UID:${event.uid}")
-        add("DTSTAMP:${dtStamp.toUtcBasic()}")
+        add("DTSTAMP:${utcStamp(dtStamp)}")
         add("SUMMARY:${escapeText(event.summary)}")
         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() }
@@ -62,41 +62,27 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) {
 
     private fun MutableList<String>.appendTimes(event: IcsEvent) = when {
         event.isAllDay -> {
-            add("DTSTART;VALUE=DATE:${event.start.toLocalDateTime(TimeZone.UTC).date.toBasic()}")
+            add("DTSTART;VALUE=DATE:${utcDate(event.start)}")
-            add("DTEND;VALUE=DATE:${event.end.toLocalDateTime(TimeZone.UTC).date.toBasic()}")
+            add("DTEND;VALUE=DATE:${utcDate(event.end)}")
         }
         // Recurring: anchor to wall-clock in the event's own zone.
         event.recurrenceRule?.isNotBlank() == true -> {
-            val zone = zoneOrNull(event.zoneId)
+            val zone = runCatching { TimeZone.of(event.zoneId) }.getOrNull()
             if (zone != null) {
-                add("DTSTART;TZID=${event.zoneId}:${event.start.toLocalDateTime(zone).toBasic()}")
+                add("DTSTART;TZID=${event.zoneId}:${localStamp(event.start, zone)}")
-                add("DTEND;TZID=${event.zoneId}:${event.end.toLocalDateTime(zone).toBasic()}")
+                add("DTEND;TZID=${event.zoneId}:${localStamp(event.end, zone)}")
             } else {
                 // Unknown zone id → fall back to plain UTC instants.
-                add("DTSTART:${event.start.toUtcBasic()}")
+                add("DTSTART:${utcStamp(event.start)}")
-                add("DTEND:${event.end.toUtcBasic()}")
+                add("DTEND:${utcStamp(event.end)}")
             }
         }
         else -> {
-            add("DTSTART:${event.start.toUtcBasic()}")
+            add("DTSTART:${utcStamp(event.start)}")
-            add("DTEND:${event.end.toUtcBasic()}")
+            add("DTEND:${utcStamp(event.end)}")
         }
     }
 
-    /**
-     * 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")
@@ -119,5 +105,20 @@ class IcsWriter(private val prodId: String = ICS_PROD_ID) {
         // A lead time of 0 fires at start (PT0M); anything positive is "before".
         fun triggerValue(minutes: Int): String =
             if (minutes <= 0) "PT0M" else "-PT${minutes}M"
+
+        fun utcStamp(instant: Instant): String =
+            basic(instant.toLocalDateTime(TimeZone.UTC)) + "Z"
+
+        fun localStamp(instant: Instant, zone: TimeZone): String =
+            basic(instant.toLocalDateTime(zone))
+
+        fun utcDate(instant: Instant): String {
+            val dt = instant.toLocalDateTime(TimeZone.UTC)
+            return "%04d%02d%02d".format(dt.year, dt.month.number, dt.day)
+        }
+
+        fun basic(dt: LocalDateTime): String = "%04d%02d%02dT%02d%02d%02d".format(
+            dt.year, dt.month.number, dt.day, dt.hour, dt.minute, dt.second,
+        )
     }
 }

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

@@ -1,9 +1,9 @@
 package de.jeanlucmakiola.calendula.domain.ics
 
 import de.jeanlucmakiola.calendula.domain.EventForm
-import de.jeanlucmakiola.calendula.domain.allDayFormTimes
+import kotlinx.datetime.LocalDate
-import de.jeanlucmakiola.calendula.domain.normalizedRrule
+import kotlinx.datetime.LocalDateTime
-import de.jeanlucmakiola.calendula.domain.toFormTime
+import kotlinx.datetime.LocalTime
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toLocalDateTime
 
@@ -13,17 +13,15 @@ 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) {
-        allDayFormTimes(this.start.toLocalDateTime(TimeZone.UTC).date, this.end.toLocalDateTime(TimeZone.UTC).date)
+        val startDate = this.start.toLocalDateTime(TimeZone.UTC).date
+        val endExclusive = this.end.toLocalDateTime(TimeZone.UTC).date
+        val endDate = maxOf(startDate, LocalDate.fromEpochDays(endExclusive.toEpochDays() - 1))
+        LocalDateTime(startDate, LocalTime(9, 0)) to LocalDateTime(endDate, LocalTime(10, 0))
     } else {
-        this.start.toFormTime(zone) to this.end.toFormTime(zone)
+        this.start.toLocalDateTime(zone) to this.end.toLocalDateTime(zone)
     }
     return EventForm(
         calendarId = null,
@@ -33,8 +31,8 @@ fun ParsedIcsEvent.toEventForm(zone: TimeZone): EventForm {
         end = end,
         location = location.orEmpty(),
         description = description.orEmpty(),
-        reminders = semanticReminderMinutes(),
+        reminders = reminderMinutes.distinct().sorted(),
         availability = availability,
-        rrule = recurrenceRule.normalizedRrule(),
+        rrule = recurrenceRule?.removePrefix("RRULE:")?.takeIf { it.isNotBlank() },
     )
 }

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

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

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

@@ -4,15 +4,12 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
-import de.jeanlucmakiola.calendula.data.time.TodaySource
-import de.jeanlucmakiola.calendula.data.time.currentDate
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
-import de.jeanlucmakiola.floret.android.stateWhileSubscribed
+import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.stateIn
-import kotlinx.datetime.LocalDate
 import javax.inject.Inject
 
 /**
@@ -24,39 +21,36 @@ import javax.inject.Inject
 @HiltViewModel
 class CalendarHostViewModel @Inject constructor(
     prefs: SettingsPrefs,
-    todaySource: TodaySource,
 ) : ViewModel() {
 
-    /** Today, kept current across midnight so the shared focus can follow it (#373). */
+    val defaultView: StateFlow<CalendarView?> = prefs.defaultView.stateIn(
-    val today: StateFlow<LocalDate> = todaySource.today.stateWhileSubscribed(
-        scope = viewModelScope,
-        initialValue = currentDate(),
-    )
-
-    val defaultView: StateFlow<CalendarView?> = prefs.defaultView.stateWhileSubscribed(
         scope = viewModelScope,
+        started = SharingStarted.WhileSubscribed(5_000L),
         initialValue = null,
     )
 
     /** Views the top-bar quick-switch pill cycles through, in the user's order (#24). */
     val quickSwitchViews: StateFlow<List<CalendarView>> = prefs.quickSwitchConfig
         .map { it.cycle }
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = IMPLEMENTED_VIEWS,
         )
 
     /** Order of the views in the navigation drawer (#24); every view always shown. */
     val drawerViewOrder: StateFlow<List<CalendarView>> = prefs.drawerViewOrder
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = IMPLEMENTED_VIEWS,
         )
 
     /** Whether each view's jump-to-today control lives in the top bar, not the FAB (#60). */
     val todayButtonInToolbar: StateFlow<Boolean> = prefs.todayButtonInToolbar
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = false,
         )
 
@@ -68,13 +62,9 @@ class CalendarHostViewModel @Inject constructor(
      * switched off to be rid of.
      */
     val dragToReschedule: StateFlow<Boolean> = prefs.dragToReschedule
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = false,
         )
-
-    private val tapOpensEditorPref = prefs.tapOpensEditor
-
-    /** Whether tapping an event opens the edit form rather than the detail screen (#178). */
-    suspend fun tapOpensEditor(): Boolean = tapOpensEditorPref.first()
 }

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

@@ -1,42 +0,0 @@
-package de.jeanlucmakiola.calendula.ui
-
-import android.net.Uri
-import androidx.compose.runtime.Stable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.setValue
-import de.jeanlucmakiola.calendula.domain.EventForm
-import de.jeanlucmakiola.calendula.ui.edit.ImportSource
-
-/**
- * What a notification, widget, shortcut or another app asked the running app to
- * open. MainActivity fills it from each intent (singleTop + onNewIntent route a
- * new one into the running activity); CalendarHost acts on a request and clears
- * it, so a later recomposition can't act on it twice.
- *
- * [onExternalFormClosed] runs when a form opened for [insert] closes, so the
- * activity can hand control back to the app that asked.
- */
-@Stable
-class ExternalRequests(val onExternalFormClosed: () -> Unit = {}) {
-    /** A tapped reminder notification's occurrence (eventId, begin, end), for the detail screen. */
-    var detailKey by mutableStateOf<LongArray?>(null)
-
-    /** A home-screen widget, shortcut or tile navigation (open a date, an event, a view, or create). */
-    var nav by mutableStateOf<WidgetNavRequest?>(null)
-
-    /** An .ics file opened or shared into the app (ACTION_VIEW/SEND). */
-    var importUri by mutableStateOf<Uri?>(null)
-
-    /**
-     * A prefilled new-event form from an external ACTION_INSERT launch (#30) or
-     * shared text (#306), opened in the create form for review.
-     */
-    var insert by mutableStateOf<InsertRequest?>(null)
-
-    /** An external "edit this event" (ACTION_EDIT), in the detail key's shape. */
-    var editKey by mutableStateOf<LongArray?>(null)
-}
-
-/** A prefilled create form from an external launch, with the source it came from. */
-data class InsertRequest(val form: EventForm, val source: ImportSource)

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

@@ -1,5 +1,7 @@
 package de.jeanlucmakiola.calendula.ui
 
+import android.Manifest
+import android.content.pm.PackageManager
 import androidx.compose.animation.AnimatedContent
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
@@ -18,11 +20,11 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.LocalLifecycleOwner
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.core.content.ContextCompat
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
 import de.jeanlucmakiola.calendula.data.contacts.SpecialDatesScheduler
 import de.jeanlucmakiola.calendula.data.contacts.hasContactsPermission
-import de.jeanlucmakiola.calendula.ui.common.canReadCalendar
 import de.jeanlucmakiola.calendula.ui.common.rememberCalendarFadeSpec
 import de.jeanlucmakiola.calendula.ui.onboarding.OnboardingStep
 import de.jeanlucmakiola.calendula.ui.onboarding.OnboardingSteps
@@ -41,12 +43,26 @@ private sealed interface RootTarget {
 
 @Composable
 fun RootScreen(
-    requests: ExternalRequests,
     modifier: Modifier = Modifier,
+    requestedDetailKey: LongArray? = null,
+    onDetailKeyConsumed: () -> Unit = {},
+    widgetNavRequest: WidgetNavRequest? = null,
+    onWidgetNavConsumed: () -> Unit = {},
+    requestedImportUri: android.net.Uri? = null,
+    onImportConsumed: () -> Unit = {},
+    requestedInsertForm: de.jeanlucmakiola.calendula.domain.EventForm? = null,
+    requestedInsertSource: de.jeanlucmakiola.calendula.ui.edit.ImportSource =
+        de.jeanlucmakiola.calendula.ui.edit.ImportSource.Insert,
+    onInsertConsumed: () -> Unit = {},
+    requestedEditKey: LongArray? = null,
+    onEditKeyConsumed: () -> Unit = {},
 ) {
     val context = LocalContext.current
     var hasPermission by remember {
-        mutableStateOf(context.canReadCalendar())
+        mutableStateOf(
+            ContextCompat.checkSelfPermission(context, Manifest.permission.READ_CALENDAR)
+                == PackageManager.PERMISSION_GRANTED
+        )
     }
 
     // A launch scan already covers the app coming up with the permission, so
@@ -57,7 +73,9 @@ fun RootScreen(
     DisposableEffect(lifecycle) {
         val obs = LifecycleEventObserver { _, event ->
             if (event == Lifecycle.Event.ON_RESUME) {
-                hasPermission = context.canReadCalendar()
+                hasPermission = ContextCompat.checkSelfPermission(
+                    context, Manifest.permission.READ_CALENDAR
+                ) == PackageManager.PERMISSION_GRANTED
                 // Refresh the contact special-dates mirror on foreground (the
                 // worker is debounced and no-ops when the feature is off). Gated
                 // on the permission so users without the opt-in never enqueue it.
@@ -127,8 +145,18 @@ fun RootScreen(
         when (shown) {
             RootTarget.Loading -> Unit
             RootTarget.App -> CalendarHost(
-                requests = requests,
                 modifier = modifier,
+                requestedDetailKey = requestedDetailKey,
+                onDetailKeyConsumed = onDetailKeyConsumed,
+                widgetNavRequest = widgetNavRequest,
+                onWidgetNavConsumed = onWidgetNavConsumed,
+                requestedImportUri = requestedImportUri,
+                onImportConsumed = onImportConsumed,
+                requestedInsertForm = requestedInsertForm,
+                requestedInsertSource = requestedInsertSource,
+                onInsertConsumed = onInsertConsumed,
+                requestedEditKey = requestedEditKey,
+                onEditKeyConsumed = onEditKeyConsumed,
             )
             // Both halves of a transition read their position out of the live
             // plan; the one the outgoing step was drawn with is already gone.

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

@@ -3,9 +3,8 @@ package de.jeanlucmakiola.calendula.ui.agenda
 import de.jeanlucmakiola.floret.locale.localizedDateFormatter
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
+import java.time.YearMonth
 import java.util.Locale
-import kotlinx.datetime.toJavaLocalDate
-import kotlinx.datetime.yearMonth
 
 /**
  * How far ahead the agenda (screen or widget) shows events, starting at today.
@@ -51,7 +50,7 @@ fun AgendaRange.dayCount(anchor: LocalDate, weekStart: DayOfWeek): Int = when (t
         DAYS_PER_WEEK - sinceWeekStart
     }
     AgendaRange.ThisMonth -> {
-        val daysInMonth = anchor.yearMonth.numberOfDays
+        val daysInMonth = YearMonth.of(anchor.year, anchor.month.ordinal + 1).lengthOfMonth()
         daysInMonth - anchor.day + 1
     }
     is AgendaRange.Custom -> days.coerceIn(AgendaRange.MIN_CUSTOM_DAYS, AgendaRange.MAX_CUSTOM_DAYS)
@@ -106,8 +105,8 @@ fun agendaRangeWindowSummary(
     locale: Locale,
     monthAsSpan: Boolean = false,
 ): String {
-    val javaStart = start.toJavaLocalDate()
+    val javaStart = java.time.LocalDate.of(start.year, start.month.ordinal + 1, start.day)
-    val javaEnd = end.toJavaLocalDate()
+    val javaEnd = java.time.LocalDate.of(end.year, end.month.ordinal + 1, end.day)
     val dayMonth = localizedDateFormatter(locale, "dMMM")
     val dayMonthYear = localizedDateFormatter(locale, "dMMMy")
     return when {

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

@@ -1,9 +1,8 @@
 package de.jeanlucmakiola.calendula.ui.agenda
 
-import androidx.annotation.StringRes
-import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
@@ -11,8 +10,6 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.lazy.LazyListScope
-import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Coffee
@@ -27,32 +24,26 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.domain.isDeclined
 import de.jeanlucmakiola.calendula.ui.common.EventDimAlpha
-import de.jeanlucmakiola.calendula.ui.common.ViewMorphKey
-import de.jeanlucmakiola.calendula.ui.common.declinedTitle
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.LocalUse24HourFormat
 import de.jeanlucmakiola.calendula.ui.common.eventAccent
+import de.jeanlucmakiola.calendula.ui.common.eventFill
 import de.jeanlucmakiola.calendula.ui.common.formatTimeOfDay
-import de.jeanlucmakiola.calendula.ui.common.morphEvent
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.Position
-import de.jeanlucmakiola.floret.components.positionOf
-import de.jeanlucmakiola.floret.identity.LocalFloretDarkTheme
-import de.jeanlucmakiola.floret.identity.animateItemMotion
 import de.jeanlucmakiola.floret.locale.currentLocale
 import de.jeanlucmakiola.floret.locale.localizedDateFormatter
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.plus
-import kotlinx.datetime.toJavaLocalDate
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Instant
 import java.util.Locale
 
 // The agenda's row vocabulary, split out of AgendaScreen so the month view's
@@ -133,13 +124,13 @@ internal fun AgendaEventRow(
     modifier: Modifier = Modifier,
     onClick: () -> Unit,
 ) {
-    val dark = LocalFloretDarkTheme.current
+    val dark = isSystemInDarkTheme()
     val soften = LocalSoftenColors.current
     val title = event.title.ifBlank { stringResource(R.string.event_untitled) }
     GroupedRow(
         modifier = if (dimmed) modifier.alpha(EventDimAlpha) else modifier,
-        title = declinedTitle(title, event.isDeclined),
+        title = title,
-        summary = AnnotatedString(agendaTimeSummary(event, day, zone)),
+        summary = agendaTimeSummary(event, day, zone),
         position = position,
         minHeight = 64.dp,
         leading = {
@@ -183,74 +174,34 @@ internal fun agendaTimeSummary(event: EventInstance, day: LocalDate, zone: TimeZ
         AgendaTimeLabel.AllDay -> stringResource(R.string.event_detail_all_day)
         is AgendaTimeLabel.Starts -> stringResource(
             R.string.agenda_span_starts,
-            formatTimeOfDay(label.start, zone, is24Hour, locale),
+            formatTime(label.start, zone, is24Hour, locale),
         )
         is AgendaTimeLabel.Ends -> stringResource(
             R.string.agenda_span_ends,
-            formatTimeOfDay(label.end, zone, is24Hour, locale),
+            formatTime(label.end, zone, is24Hour, locale),
         )
-        is AgendaTimeLabel.Range -> "${formatTimeOfDay(label.start, zone, is24Hour, locale)} – " +
+        is AgendaTimeLabel.Range -> "${formatTime(label.start, zone, is24Hour, locale)} – " +
-            formatTimeOfDay(label.end, zone, is24Hour, locale)
+            formatTime(label.end, zone, is24Hour, locale)
     }
 
     val location = event.location?.takeIf { it.isNotBlank() }
     return if (location != null) "$time · $location" else time
 }
 
+private fun formatTime(
+    instant: Instant,
+    zone: TimeZone,
+    is24Hour: Boolean,
+    locale: Locale,
+): String {
+    val t = instant.toLocalDateTime(zone).time
+    return formatTimeOfDay(t.hour, t.minute, is24Hour, locale)
+}
+
 private fun formatAgendaDate(date: LocalDate): String {
     val locale = Locale.getDefault()
-    val java = date.toJavaLocalDate()
+    val java = java.time.LocalDate.of(date.year, date.month.ordinal + 1, date.day)
     // Weekday + date in the locale's own field order (e.g. "Wed, Jun 17, 2026"
     // vs "Mi., 17. Juni 2026") rather than a hardcoded day-month-year layout.
     return localizedDateFormatter(locale, "EEEdMMMy").format(java)
 }
-
-/**
- * The agenda's day-by-day list body: a sticky header per day, its events or a
- * placeholder row for an event-less day, then a gap. Shared by the Agenda screen
- * and the month view's split pane so both lists read the same.
- */
-@OptIn(ExperimentalFoundationApi::class)
-internal fun LazyListScope.agendaDays(
-    days: List<AgendaDay>,
-    today: LocalDate,
-    zone: TimeZone,
-    @StringRes emptyText: Int,
-    onEmptyClick: (LocalDate) -> Unit,
-    dimmed: (EventInstance, LocalDate) -> Boolean,
-    onOpenDay: (LocalDate) -> Unit,
-    onEventClick: (EventInstance) -> Unit,
-) {
-    days.forEach { day ->
-        stickyHeader(key = "header-${day.date}") {
-            AgendaDayHeader(date = day.date, today = today, onOpenDay = onOpenDay)
-        }
-        if (day.events.isEmpty()) {
-            item(key = "placeholder-${day.date}") {
-                AgendaEmptyDayRow(
-                    text = stringResource(emptyText),
-                    onClick = { onEmptyClick(day.date) },
-                )
-            }
-        } else {
-            itemsIndexed(
-                items = day.events,
-                // Scope the key by day: a multi-day event appears under every
-                // day it spans, so its instanceId alone is not unique across
-                // the list (LazyColumn requires unique keys).
-                key = { _, event -> "${day.date}-${event.instanceId}" },
-            ) { index, event ->
-                AgendaEventRow(
-                    event = event,
-                    day = day.date,
-                    zone = zone,
-                    position = positionOf(index, day.events.size),
-                    dimmed = dimmed(event, day.date),
-                    modifier = animateItemMotion().morphEvent(ViewMorphKey.event(event, day.date)),
-                    onClick = { onEventClick(event) },
-                )
-            }
-        }
-        item(key = "gap-${day.date}") { Spacer(Modifier.height(8.dp)) }
-    }
-}

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

@@ -1,15 +1,6 @@
 package de.jeanlucmakiola.calendula.ui.agenda
 
-import de.jeanlucmakiola.calendula.ui.common.PublishChrome
+import androidx.compose.foundation.ExperimentalFoundationApi
-import de.jeanlucmakiola.calendula.ui.common.ScreenActions
-import de.jeanlucmakiola.calendula.ui.common.ScreenBody
-import de.jeanlucmakiola.calendula.ui.common.ScreenChrome
-import de.jeanlucmakiola.calendula.ui.common.LocalViewFocus
-import kotlinx.coroutines.flow.drop
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.setValue
-import androidx.compose.runtime.snapshotFlow
-import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -22,33 +13,34 @@ import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.LazyListState
+import androidx.compose.foundation.lazy.itemsIndexed
-import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Coffee
+import androidx.compose.material.icons.filled.Menu
+import androidx.compose.material.icons.filled.Search
 import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.DrawerValue
 import androidx.compose.material3.FilledTonalButton
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalNavigationDrawer
+import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.TopAppBarScrollBehavior
+import androidx.compose.material3.rememberDrawerState
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.getValue
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.MutableIntState
-import androidx.compose.runtime.SideEffect
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.input.nestedscroll.NestedScrollConnection
-import androidx.compose.ui.input.nestedscroll.NestedScrollSource
-import androidx.compose.ui.input.nestedscroll.nestedScroll
-import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
@@ -57,14 +49,19 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.calendula.domain.EventInstance
-import de.jeanlucmakiola.calendula.ui.common.isPastOn
+import de.jeanlucmakiola.calendula.domain.hasEnded
 import de.jeanlucmakiola.calendula.ui.common.AgendaRangePicker
-import de.jeanlucmakiola.calendula.ui.common.AppBarSpacing
-import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
 import de.jeanlucmakiola.calendula.ui.common.agendaRangeLabel
+import de.jeanlucmakiola.floret.identity.animateItemMotion
+import de.jeanlucmakiola.calendula.ui.common.CalendarDrawer
+import de.jeanlucmakiola.calendula.ui.common.CalendarFabColumn
+import de.jeanlucmakiola.calendula.ui.common.TodayAction
 import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
+import de.jeanlucmakiola.calendula.ui.common.ViewSwitcherPill
+import de.jeanlucmakiola.calendula.ui.common.next
+import de.jeanlucmakiola.floret.components.positionOf
 import de.jeanlucmakiola.calendula.ui.common.rememberCurrentMinute
 import de.jeanlucmakiola.floret.locale.currentLocale
 import kotlinx.coroutines.launch
@@ -79,34 +76,27 @@ import kotlin.time.Instant
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun AgendaScreen(
+    selectedView: CalendarView,
+    onSelectView: (CalendarView) -> Unit,
     onOpenDay: (LocalDate) -> Unit,
     onEventClick: (EventInstance) -> Unit,
+    onOpenSettings: () -> Unit,
+    onOpenSearch: () -> Unit,
     onCreateEvent: (LocalDate, Int?) -> Unit,
     quickSwitchViews: List<CalendarView> = IMPLEMENTED_VIEWS,
+    drawerViewOrder: List<CalendarView> = IMPLEMENTED_VIEWS,
+    todayInToolbar: Boolean = false,
     modifier: Modifier = Modifier,
-    restorePosition: Boolean = false,
     viewModel: AgendaViewModel = hiltViewModel(),
 ) {
-    // Opens on today, not on the day another view was on (#367). Backing out of
-    // a day opened from here, or a recreated screen, returns to the day last at
-    // the top. The top day still goes back to the shared focus.
-    val focus = LocalViewFocus.current
-    val opened = rememberSaveable { mutableStateOf(false) }
-    val restoreTop = remember(viewModel) {
-        if (restorePosition || opened.value) {
-            viewModel.lastTopDate
-        } else {
-            viewModel.goToToday()
-            null
-        }
-    }
-    SideEffect { opened.value = true }
     val state by viewModel.state.collectAsStateWithLifecycle()
     val anchor by viewModel.anchor.collectAsStateWithLifecycle()
     val pastDisplay by viewModel.pastEventDisplay.collectAsStateWithLifecycle()
     val showToday by viewModel.showToday.collectAsStateWithLifecycle()
     val weekStart by viewModel.weekStart.collectAsStateWithLifecycle()
 
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
+    val drawerState = rememberDrawerState(DrawerValue.Closed)
     val scope = rememberCoroutineScope()
     var showRangePicker by remember { mutableStateOf(false) }
 
@@ -116,107 +106,92 @@ fun AgendaScreen(
     }
     val successState = state as? AgendaUiState.Success
 
-    // The agenda window always starts at the anchor, so moving through it is a
+    ModalNavigationDrawer(
-    // list scroll, not an anchor change — "today" has to bring the list back to
+        drawerState = drawerState,
-    // the top as well, and stay offered while it is scrolled away (#305).
+        drawerContent = {
-    val listState = rememberLazyListState()
+            CalendarDrawer(
-    // Past days load above the anchor (#367), so the anchor's row counts as the
+                currentView = selectedView,
-    // start of the list.
+                currentDate = anchor,
-    val anchorIndex = remember { mutableIntStateOf(0) }
+                drawerState = drawerState,
-    val scrolledAway by remember {
+                viewOrder = drawerViewOrder,
-        derivedStateOf {
+                onSelectView = { view ->
-            listState.firstVisibleItemIndex != anchorIndex.intValue ||
+                    onSelectView(view)
-                listState.firstVisibleItemScrollOffset > 0
+                    scope.launch { drawerState.close() }
-        }
+                },
-    }
+                onJumpToDate = { target ->
-    val jumpToToday: () -> Unit = {
+                    viewModel.goToDate(target)
-        // Off today, moving the anchor is what repositions the list; on today
+                    scope.launch { drawerState.close() }
-        // the window doesn't change, so the scroll back is the whole action.
+                },
-        if (isOnToday) scope.launch { listState.animateScrollToItem(anchorIndex.intValue) }
+                onSettings = {
-        viewModel.goToToday()
+                    onOpenSettings()
-        (state as? AgendaUiState.Success)?.today?.let { focus?.date = it }
+                    scope.launch { drawerState.close() }
-    }
+                },
-
-    PublishChrome(
-        ScreenChrome(
-            title = stringResource(R.string.view_agenda),
-            titleDate = null,
-            drawerDate = anchor,
-            awayFromToday = !isOnToday || (scrolledAway && successState != null),
-            todayText = stringResource(R.string.agenda_today_action),
-        ),
-        ScreenActions(
-            onToday = jumpToToday,
-            onJumpToDate = { target ->
-                focus?.date = target
-                viewModel.goToDate(target)
-            },
-            onCreate = { onCreateEvent(anchor, null) },
-        ),
-    )
-
-    ScreenBody(modifier = modifier) { innerPadding ->
-        Column(
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(innerPadding),
-        ) {
-            // One bar at the top: the "showing …" header on the left and the
-            // session range switcher on the right (one settings toggle).
-            successState?.takeIf { it.showRangeBar }?.let { s ->
-                // end lines the selector up with whatever ends the top bar:
-                // the view switcher's background, or — once #150 hides it —
-                // the search icon's glyph.
-                val selectorEnd = if (quickSwitchViews.size >= QuickSwitchConfig.MIN_CYCLE) {
-                    AppBarSpacing.Inset
-                } else {
-                    AppBarSpacing.IconTrailingInset
-                }
-                Row(
-                    verticalAlignment = Alignment.CenterVertically,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(
-                            start = RANGE_BAR_TEXT_INSET,
-                            end = selectorEnd,
-                            top = 8.dp,
-                            bottom = 8.dp,
-                        ),
-                ) {
-                    AgendaRangeBanner(
-                        range = s.range,
-                        start = s.anchor,
-                        end = s.rangeEnd,
-                        modifier = Modifier.weight(1f),
-                    )
-                    AgendaRangePill(
-                        range = s.range,
-                        isOverride = s.rangeIsOverride,
-                        onClick = { showRangePicker = true },
-                    )
-                }
-            }
-            AgendaContent(
-                state = state,
-                pastDisplay = pastDisplay,
-                showToday = showToday,
-                listState = listState,
-                anchorIndex = anchorIndex,
-                initialTopDate = restoreTop,
-                onLoadEarlier = viewModel::loadEarlier,
-                onRetry = viewModel::goToToday,
-                onEventClick = onEventClick,
-                onOpenDay = onOpenDay,
-                onTopDay = if (successState?.anchor == anchor) {
-                    {
-                        focus?.date = it
-                        viewModel.rememberTopDay(it)
-                    }
-                } else null,
-                modifier = Modifier
-                    .weight(1f)
-                    .fillMaxWidth(),
             )
+        },
+    ) {
+        Scaffold(
+            modifier = modifier.nestedScroll(scrollBehavior.nestedScrollConnection),
+            topBar = {
+                AgendaTopBar(
+                    selectedView = selectedView,
+                    onCycleView = { onSelectView(selectedView.next(quickSwitchViews)) },
+                    onOpenDrawer = { scope.launch { drawerState.open() } },
+                    onOpenSearch = onOpenSearch,
+                    showTodayButton = todayInToolbar,
+                    onToday = viewModel::goToToday,
+                    scrollBehavior = scrollBehavior,
+                )
+            },
+            floatingActionButton = {
+                CalendarFabColumn(
+                    todayVisible = !isOnToday && !todayInToolbar,
+                    todayText = stringResource(R.string.agenda_today_action),
+                    onToday = viewModel::goToToday,
+                    onCreate = { onCreateEvent(anchor, null) },
+                )
+            },
+        ) { innerPadding ->
+            Column(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(innerPadding),
+            ) {
+                // One bar at the top: the "showing …" header on the left and the
+                // session range switcher on the right (one settings toggle).
+                successState?.takeIf { it.showRangeBar }?.let { s ->
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        // end aligns the selector's right edge with the top-bar view
+                        // switcher (its 8.dp margin + the app bar's 4.dp inset).
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(start = 28.dp, end = 12.dp, top = 8.dp, bottom = 8.dp),
+                    ) {
+                        AgendaRangeBanner(
+                            range = s.range,
+                            start = s.anchor,
+                            end = s.rangeEnd,
+                            modifier = Modifier.weight(1f),
+                        )
+                        AgendaRangePill(
+                            range = s.range,
+                            isOverride = s.rangeIsOverride,
+                            onClick = { showRangePicker = true },
+                        )
+                    }
+                }
+                AgendaContent(
+                    state = state,
+                    pastDisplay = pastDisplay,
+                    showToday = showToday,
+                    onRetry = viewModel::goToToday,
+                    onEventClick = onEventClick,
+                    onOpenDay = onOpenDay,
+                    modifier = Modifier
+                        .weight(1f)
+                        .fillMaxWidth(),
+                )
+            }
         }
     }
 
@@ -270,9 +245,6 @@ private fun AgendaRangePill(
     }
 }
 
-/** Optical start inset for the range bar's text, set against the title above it. */
-private val RANGE_BAR_TEXT_INSET = 28.dp
-
 /**
  * A header naming the concrete window currently shown under a "showing …" label,
  * e.g. "27 Jun 2026" / "27 Jun – 3 Jul 2026" / "June 2026". The range's name
@@ -312,11 +284,6 @@ internal fun AgendaContent(
     onEventClick: (EventInstance) -> Unit,
     onOpenDay: (LocalDate) -> Unit,
     modifier: Modifier = Modifier,
-    listState: LazyListState = rememberLazyListState(),
-    anchorIndex: MutableIntState = remember { mutableIntStateOf(0) },
-    initialTopDate: LocalDate? = null,
-    onLoadEarlier: () -> Unit = {},
-    onTopDay: ((LocalDate) -> Unit)? = null,
 ) {
     when (state) {
         AgendaUiState.Loading -> Box(modifier)
@@ -330,42 +297,31 @@ internal fun AgendaContent(
             // away (or fade) as they end while the screen stays open.
             val filtered = if (pastDisplay == PastEventDisplay.HIDE) {
                 state.days.mapNotNull { day ->
-                    val remaining = day.events.filterNot { it.isPastOn(day.date, now, state.zone) }
+                    val remaining = day.events.filterNot { it.hasEnded(now) }
                     if (remaining.isEmpty()) null else day.copy(events = remaining)
                 }
             } else {
                 state.days
             }
             // Anchor today with a "nothing left today" placeholder — but only when
-            // the agenda actually opens on today; a jumped-to date has no today
+            // the window actually starts on today; a jumped-to date has no today in
-            // in it, so anchoring there would be misleading (#35).
+            // it, so anchoring there would be misleading (#35).
             val days = anchorTodayIfMissing(
                 days = filtered,
                 today = state.today,
                 enabled = showToday && state.anchor == state.today,
             )
-            // Past days alone don't count as anything coming up.
+            if (days.isEmpty()) {
-            if (days.none { it.date >= state.anchor }) {
-                // Nothing to scroll: drop the position a previous list left, so
-                // the today FAB doesn't linger over an empty screen.
-                LaunchedEffect(Unit) { listState.scrollToItem(0) }
-                SideEffect { anchorIndex.intValue = 0 }
                 AgendaEmpty(modifier)
             } else {
                 AgendaList(
                     days = days,
-                    anchor = state.anchor,
-                    anchorIndex = anchorIndex,
-                    initialTopDate = initialTopDate,
-                    onLoadEarlier = onLoadEarlier,
                     today = state.today,
                     zone = state.zone,
-                    listState = listState,
                     dimPast = pastDisplay == PastEventDisplay.DIM,
                     now = now,
                     onEventClick = onEventClick,
                     onOpenDay = onOpenDay,
-                    onTopDay = onTopDay,
                     modifier = modifier,
                 )
             }
@@ -373,94 +329,59 @@ internal fun AgendaContent(
     }
 }
 
+@OptIn(ExperimentalFoundationApi::class)
 @Composable
 private fun AgendaList(
     days: List<AgendaDay>,
-    anchor: LocalDate,
-    anchorIndex: MutableIntState,
-    initialTopDate: LocalDate?,
-    onLoadEarlier: () -> Unit,
     today: LocalDate,
     zone: TimeZone,
-    listState: LazyListState,
     dimPast: Boolean,
     now: Instant,
     onEventClick: (EventInstance) -> Unit,
     onOpenDay: (LocalDate) -> Unit,
-    onTopDay: ((LocalDate) -> Unit)?,
     modifier: Modifier = Modifier,
 ) {
-    val itemDates = agendaItemDates(days)
-    val anchorRow = itemDates.indexOfFirst { it >= anchor }.coerceAtLeast(0)
-    SideEffect { anchorIndex.intValue = anchorRow }
-    // A new anchor opens the list on its row from the first frame, with past
-    // days above. Keyed on the anchor the days arrived with, not the one just
-    // requested: scrolling before the new rows compose leaves the list keyed to
-    // a row that reappears further down, and it follows it there. The first run
-    // may restore a remembered day instead.
-    val pendingRestore = remember { arrayOf(initialTopDate) }
-    DisposableEffect(anchor) {
-        val target = pendingRestore[0]
-        pendingRestore[0] = null
-        val index = target?.let { date -> itemDates.indexOfFirst { it >= date } }
-            ?.takeIf { it >= 0 }
-            ?: anchorRow
-        listState.requestScrollToItem(index)
-        onDispose {}
-    }
-    // Scrolling up near the first loaded day loads earlier days.
-    val currentLoadEarlier by rememberUpdatedState(onLoadEarlier)
-    val loadOnScrollUp = remember(listState) {
-        object : NestedScrollConnection {
-            override fun onPreScroll(available: Offset, source: NestedScrollSource): Offset {
-                if (available.y > 0 && listState.firstVisibleItemIndex < LOAD_EARLIER_WITHIN) {
-                    currentLoadEarlier()
-                }
-                return Offset.Zero
-            }
-        }
-    }
-    if (onTopDay != null) {
-        val currentItemDates by rememberUpdatedState(itemDates)
-        val currentOnTopDay by rememberUpdatedState(onTopDay)
-        // The day the list opened on is where the view already is; only a
-        // scroll moves it on.
-        LaunchedEffect(listState) {
-            snapshotFlow { listState.firstVisibleItemIndex }
-                .drop(1)
-                .collect { index -> currentItemDates.getOrNull(index)?.let(currentOnTopDay) }
-        }
-    }
     LazyColumn(
-        modifier = modifier.nestedScroll(loadOnScrollUp),
+        modifier = modifier,
-        state = listState,
         // Bottom inset clears the FAB stack so the last row stays tappable.
         contentPadding = PaddingValues(top = 8.dp, bottom = 96.dp),
     ) {
-        agendaDays(
+        days.forEach { day ->
-            days = days,
+            stickyHeader(key = "header-${day.date}") {
-            today = today,
+                AgendaDayHeader(date = day.date, today = today, onOpenDay = onOpenDay)
-            zone = zone,
+            }
-            // An anchored, event-less today (#35) — "nothing left today".
+            if (day.events.isEmpty()) {
-            emptyText = R.string.agenda_no_more_today,
+                // An anchored, event-less today (#35) — "nothing left today".
-            onEmptyClick = onOpenDay,
+                item(key = "placeholder-${day.date}") {
-            dimmed = { event, day -> dimPast && event.isPastOn(day, now, zone) },
+                    AgendaEmptyDayRow(
-            onOpenDay = onOpenDay,
+                        text = stringResource(R.string.agenda_no_more_today),
-            onEventClick = onEventClick,
+                        onClick = { onOpenDay(day.date) },
-        )
+                    )
+                }
+            } else {
+                itemsIndexed(
+                    items = day.events,
+                    // Scope the key by day: a multi-day event appears under every
+                    // day it spans, so its instanceId alone is not unique across
+                    // the list (LazyColumn requires unique keys).
+                    key = { _, event -> "${day.date}-${event.instanceId}" },
+                ) { index, event ->
+                    AgendaEventRow(
+                        event = event,
+                        day = day.date,
+                        zone = zone,
+                        position = positionOf(index, day.events.size),
+                        dimmed = dimPast && event.hasEnded(now),
+                        modifier = animateItemMotion(),
+                        onClick = { onEventClick(event) },
+                    )
+                }
+            }
+            item(key = "gap-${day.date}") { Spacer(Modifier.height(8.dp)) }
+        }
     }
 }
 
-/** How close to the first loaded row an upward scroll starts loading earlier days. */
-private const val LOAD_EARLIER_WITHIN = 10
-
-/** The day of each item [AgendaList] lays out for [days], in its order. */
-internal fun agendaItemDates(days: List<AgendaDay>): List<LocalDate> =
-    days.flatMap { day ->
-        // Header, the placeholder or the events, then the gap.
-        List(2 + day.events.size.coerceAtLeast(1)) { day.date }
-    }
-
 @Composable
 private fun AgendaEmpty(modifier: Modifier = Modifier) {
     Column(
@@ -482,3 +403,51 @@ private fun AgendaEmpty(modifier: Modifier = Modifier) {
         )
     }
 }
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun AgendaTopBar(
+    selectedView: CalendarView,
+    onCycleView: () -> Unit,
+    onOpenDrawer: () -> Unit,
+    onOpenSearch: () -> Unit,
+    showTodayButton: Boolean,
+    onToday: () -> Unit,
+    scrollBehavior: TopAppBarScrollBehavior,
+) {
+    TopAppBar(
+        title = {
+            Text(
+                text = stringResource(R.string.view_agenda),
+                style = MaterialTheme.typography.titleLarge,
+            )
+        },
+        navigationIcon = {
+            IconButton(onClick = onOpenDrawer) {
+                Icon(
+                    imageVector = Icons.Default.Menu,
+                    contentDescription = stringResource(R.string.month_open_menu),
+                )
+            }
+        },
+        actions = {
+            TodayAction(show = showTodayButton, onToday = onToday)
+            IconButton(onClick = onOpenSearch) {
+                Icon(
+                    imageVector = Icons.Default.Search,
+                    contentDescription = stringResource(R.string.search_action),
+                )
+            }
+            ViewSwitcherPill(
+                current = selectedView,
+                onCycle = onCycleView,
+                modifier = Modifier.padding(end = 8.dp),
+            )
+        },
+        colors = TopAppBarDefaults.topAppBarColors(
+            containerColor = MaterialTheme.colorScheme.surface,
+            scrolledContainerColor = MaterialTheme.colorScheme.surfaceContainer,
+        ),
+        scrollBehavior = scrollBehavior,
+    )
+}

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

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

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

@@ -1,22 +1,16 @@
 package de.jeanlucmakiola.calendula.ui.agenda
 
-import de.jeanlucmakiola.calendula.ui.common.dayRange
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.data.prefs.firstDayOfWeek
-import de.jeanlucmakiola.calendula.data.time.TodaySource
-import de.jeanlucmakiola.calendula.data.time.currentDate
-import de.jeanlucmakiola.calendula.data.time.stateFollowingDays
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.FailureReason
-import de.jeanlucmakiola.calendula.domain.calendarListFailure
-import de.jeanlucmakiola.floret.android.stateWhileSubscribed
-import de.jeanlucmakiola.floret.di.IoDispatcher
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -26,14 +20,17 @@ import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
-import kotlinx.datetime.minus
+import kotlinx.datetime.atStartOfDayIn
+import kotlinx.datetime.atTime
 import kotlinx.datetime.plus
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.toLocalDateTime
+import kotlin.time.Clock
 import kotlin.time.Instant
 import javax.inject.Inject
 
@@ -42,7 +39,6 @@ import javax.inject.Inject
 class AgendaViewModel @Inject constructor(
     private val repository: CalendarRepository,
     settingsPrefs: SettingsPrefs,
-    todaySource: TodaySource,
     @IoDispatcher private val io: CoroutineDispatcher,
 ) : ViewModel() {
 
@@ -65,8 +61,9 @@ class AgendaViewModel @Inject constructor(
      * the screen combines it with a per-minute "now" to fade or drop past rows.
      */
     val pastEventDisplay: StateFlow<PastEventDisplay> = settingsPrefs.pastEventDisplay
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = PastEventDisplay.SHOW,
         )
 
@@ -77,35 +74,19 @@ class AgendaViewModel @Inject constructor(
      * alongside the data state like [pastEventDisplay] rather than re-querying.
      */
     val showToday: StateFlow<Boolean> = settingsPrefs.agendaShowToday
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = true,
         )
 
     private val zone = TimeZone.currentSystemDefault()
 
     private val todayDate: LocalDate
-        get() = currentDate()
+        get() = Clock.System.now().toLocalDateTime(zone).date
 
-    // The anchor and how many days before it are loaded, moved together so a
+    private val _anchor = MutableStateFlow(todayDate)
-    // jump never queries a window that pairs the new anchor with the old span.
+    val anchor: StateFlow<LocalDate> = _anchor
-    private val _window = MutableStateFlow(AgendaWindow(todayDate, PAST_CHUNK_DAYS))
-    val anchor: StateFlow<LocalDate> = _window
-        .map { it.anchor }
-        .stateIn(viewModelScope, SharingStarted.Eagerly, todayDate)
-
-    /** The day last scrolled to the top, so a return to the agenda lands back on it. */
-    var lastTopDate: LocalDate? = null
-        private set
-
-    /**
-     * Today, kept current across midnight (#373). An agenda still starting on
-     * yesterday moves on to the new day; one jumped elsewhere stays put.
-     */
-    private val today: StateFlow<LocalDate> =
-        todaySource.today.stateFollowingDays(viewModelScope, todayDate) { old, date ->
-            if (_window.value.anchor == old) _window.value = _window.value.copy(anchor = date)
-        }
 
     // A transient, in-view override of the saved agenda range. Held in memory
     // (not persisted), so it survives view switches and rotation within the
@@ -113,17 +94,9 @@ class AgendaViewModel @Inject constructor(
     private val _rangeOverride = MutableStateFlow<AgendaRange?>(null)
 
     val state: StateFlow<AgendaUiState> =
-        combine(
+        combine(_anchor, agendaSettings, _rangeOverride, weekStart) { anchor, settings, override, weekStart ->
-            _window,
-            agendaSettings,
-            _rangeOverride,
-            weekStart,
-            settingsPrefs.pastEventDisplay,
-        ) { window, settings, override, weekStart, pastDisplay ->
             AgendaParams(
-                anchor = window.anchor,
+                anchor = anchor,
-                // Hidden past events leave nothing to scroll back to (#367).
-                pastDays = if (pastDisplay == PastEventDisplay.HIDE) 0 else window.pastDays,
                 range = override ?: settings.range,
                 rangeIsOverride = override != null && override != settings.range,
                 weekStart = weekStart,
@@ -132,50 +105,32 @@ class AgendaViewModel @Inject constructor(
         }
         .flatMapLatest { params ->
             val window = agendaRange(
-                params.windowStart,
+                params.anchor,
-                params.pastDays + params.range.dayCount(params.anchor, params.weekStart) - 1,
+                params.range.dayCount(params.anchor, params.weekStart) - 1,
                 zone,
             )
             combine(
                 repository.calendars(),
                 repository.instances(window),
-                today,
+            ) { calendars, instances ->
-            ) { calendars, instances, today ->
+                buildState(params, calendars, instances)
-                buildState(params, calendars, instances, today)
             }
         }
         .catch { emit(AgendaUiState.Failure(FailureReason.ProviderUnavailable)) }
         .flowOn(io)
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = AgendaUiState.Loading,
         )
 
     fun goToToday() {
-        goToDate(todayDate)
+        _anchor.value = todayDate
     }
 
     /** Jump the agenda window to start on a specific date (drawer jump-to-date). */
     fun goToDate(date: LocalDate) {
-        if (_window.value.anchor == date) return
+        _anchor.value = date
-        _window.value = AgendaWindow(date, PAST_CHUNK_DAYS)
-        lastTopDate = null
-    }
-
-    /**
-     * Extend the window [PAST_CHUNK_DAYS] further back (#367). Ignored while the
-     * previous extension is still loading, so a scroll that keeps asking only
-     * moves one chunk at a time.
-     */
-    fun loadEarlier() {
-        val loaded = (state.value as? AgendaUiState.Success)?.windowStart ?: return
-        val window = _window.value
-        if (loaded != window.start) return
-        _window.value = window.copy(pastDays = window.pastDays + PAST_CHUNK_DAYS)
-    }
-
-    fun rememberTopDay(date: LocalDate) {
-        lastTopDate = date
     }
 
     /** Temporarily override the agenda range for this session (the bottom-left pill). */
@@ -188,38 +143,31 @@ class AgendaViewModel @Inject constructor(
         val showBar: Boolean,
     )
 
-    private data class AgendaWindow(val anchor: LocalDate, val pastDays: Int) {
-        val start: LocalDate get() = anchor.minus(pastDays, DateTimeUnit.DAY)
-    }
-
     private data class AgendaParams(
         val anchor: LocalDate,
-        val pastDays: Int,
         val range: AgendaRange,
         val rangeIsOverride: Boolean,
         val weekStart: DayOfWeek,
         val showRangeBar: Boolean,
-    ) {
+    )
-        val windowStart: LocalDate get() = anchor.minus(pastDays, DateTimeUnit.DAY)
-    }
 
     private fun buildState(
         params: AgendaParams,
         calendars: List<CalendarSource>,
         instances: List<EventInstance>,
-        today: LocalDate,
     ): AgendaUiState {
-        calendarListFailure(calendars)?.let { return AgendaUiState.Failure(it) }
+        if (calendars.isEmpty()) {
+            return AgendaUiState.Failure(FailureReason.NoCalendarsConfigured)
+        }
         val anchor = params.anchor
         val rangeEnd = anchor.plus(
             params.range.dayCount(anchor, params.weekStart) - 1,
             DateTimeUnit.DAY,
         )
-        val days = groupAgendaDays(params.windowStart, rangeEnd, instances, zone)
+        val days = groupAgendaDays(anchor, rangeEnd, instances, zone)
         return AgendaUiState.Success(
             anchor = anchor,
-            windowStart = params.windowStart,
+            today = todayDate,
-            today = today,
             days = days,
             range = params.range,
             rangeIsOverride = params.rangeIsOverride,
@@ -230,9 +178,9 @@ class AgendaViewModel @Inject constructor(
     }
 }
 
-/** How many days each scroll back into the past loads (#367). */
-internal const val PAST_CHUNK_DAYS = 30
-
 /** Inclusive instant range from the start of [anchor] through [days] days ahead. */
-internal fun agendaRange(anchor: LocalDate, days: Int, zone: TimeZone): ClosedRange<Instant> =
+internal fun agendaRange(anchor: LocalDate, days: Int, zone: TimeZone): ClosedRange<Instant> {
-    dayRange(anchor, anchor.plus(days, DateTimeUnit.DAY), zone)
+    val from = anchor.atStartOfDayIn(zone)
+    val to = anchor.plus(days, DateTimeUnit.DAY).atTime(23, 59, 59).toInstant(zone)
+    return from..to
+}

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

@@ -6,8 +6,8 @@ import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.Dp
 import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
+import de.jeanlucmakiola.calendula.ui.common.ScaledViewPreview
 import de.jeanlucmakiola.calendula.ui.common.sampleAgendaEvents
-import de.jeanlucmakiola.floret.components.ScaledViewPreview
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
@@ -51,7 +51,6 @@ private fun sampleAgendaState(today: LocalDate, zone: TimeZone): AgendaUiState.S
     val windowEnd = today.plus(PREVIEW_WINDOW_DAYS, DateTimeUnit.DAY)
     return AgendaUiState.Success(
         anchor = today,
-        windowStart = today,
         today = today,
         days = groupAgendaDays(today, windowEnd, sampleAgendaEvents(today, zone), zone),
         range = AgendaRange.Custom(PREVIEW_WINDOW_DAYS),

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

@@ -1,13 +1,12 @@
 package de.jeanlucmakiola.calendula.ui.calendars
 
 import android.net.Uri
+import android.text.format.DateUtils
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
@@ -19,7 +18,6 @@ import androidx.compose.material.icons.filled.Schedule
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Button
 import androidx.compose.material3.Checkbox
-import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
@@ -49,21 +47,16 @@ import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.prefs.BackupStatus
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.isEventTarget
 import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
-import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.LeadingAvatar
-import de.jeanlucmakiola.calendula.ui.common.LocalManageCalendars
-import de.jeanlucmakiola.calendula.ui.common.orUnnamed
 import de.jeanlucmakiola.floret.components.CollapsingScaffold
 import de.jeanlucmakiola.floret.components.DialogAmountField
 import de.jeanlucmakiola.floret.components.DialogUnitDropdown
 import de.jeanlucmakiola.floret.components.FullScreenPicker
-import de.jeanlucmakiola.floret.components.GroupedHint
 import de.jeanlucmakiola.floret.components.GroupedRow
-import de.jeanlucmakiola.floret.components.GroupedSectionHeader
 import de.jeanlucmakiola.floret.components.Position
 import de.jeanlucmakiola.floret.components.positionOf
-import de.jeanlucmakiola.floret.locale.relativeTimeAgo
 import java.time.LocalDate
 
 // SAF mime filter for the restore picker. Source apps hand `.ics` files out
@@ -85,16 +78,20 @@ private val RESTORE_MIME_TYPES = arrayOf(
 fun BackupScreen(
     onBack: () -> Unit,
     onImport: (Uri) -> Unit,
-    visible: Boolean = true,
     viewModel: CalendarsViewModel = hiltViewModel(),
 ) {
-    val state by viewModel.backupState.collectAsStateWithLifecycle()
+    val calendars by viewModel.calendars.collectAsStateWithLifecycle()
     val backupResult by viewModel.backupResult.collectAsStateWithLifecycle()
     val autoBackup by viewModel.autoBackup.collectAsStateWithLifecycle()
 
     val context = LocalContext.current
     val snackbarHostState = remember { SnackbarHostState() }
 
+    // Export covers local calendars only; managed special-dates mirrors are
+    // rebuilt from contacts. Restore can target anything the import picker offers.
+    val exportable = calendars.filter { it.isLocal && it.canModifyContents && !it.isManaged }
+    val canImport = calendars.any { it.isEventTarget }
+
     // Exports everything eligible (null); the per-calendar selector owns its
     // own launcher.
     val createBackup = rememberLauncherForActivityResult(
@@ -135,43 +132,78 @@ fun BackupScreen(
     CollapsingScaffold(
         title = stringResource(R.string.settings_section_backup),
         onBack = onBack,
-        // Loading and failure fill the screen and centre themselves, which they
-        // can only do in an unscrolled column — the scrolling one measures them
-        // against an unbounded height and leaves them hanging under the header.
-        scrollable = state is BackupUiState.Ready,
         snackbarHost = { SnackbarHost(snackbarHostState) },
         predictiveBack = true,
-        visible = visible,
     ) {
-        when (val s = state) {
+        HintText(stringResource(R.string.calendars_backup_hint))
-            BackupUiState.Loading -> BackupLoading()
+
-            is BackupUiState.Failure -> CalendarFailure(reason = s.reason, onRetry = onBack)
+        if (exportable.isNotEmpty()) {
-            is BackupUiState.Ready -> BackupContent(
+            GroupedRow(
-                exportable = s.exportable,
+                title = stringResource(R.string.calendars_backup_action),
-                canImport = s.canImport,
+                position = Position.Top,
-                autoBackup = autoBackup,
+                leading = { LeadingAvatar(Icons.Default.FileDownload) },
-                viewModel = viewModel,
+                onClick = {
-                onRestore = { runCatching { openBackup.launch(RESTORE_MIME_TYPES) } },
+                    // A single exportable calendar skips the selector.
-                onPickFolder = { runCatching { pickFolder.launch(null) } },
+                    if (exportable.size == 1) {
-                onExportAll = {
+                        runCatching { createBackup.launch("calendula-backup-${LocalDate.now()}.ics") }
-                    runCatching { createBackup.launch(defaultBackupName()) }
+                    } else {
+                        showExportPicker = true
+                    }
                 },
-                onExportPick = { showExportPicker = true },
+            )
-                onEditInterval = { showInterval = true },
+            GroupedRow(
+                title = stringResource(R.string.calendars_restore_action),
+                summary = stringResource(R.string.calendars_restore_hint),
+                position = Position.Middle,
+                leading = { LeadingAvatar(Icons.Default.FileUpload) },
+                onClick = { runCatching { openBackup.launch(RESTORE_MIME_TYPES) } },
+            )
+            GroupedRow(
+                title = stringResource(R.string.calendars_auto_backup),
+                summary = stringResource(R.string.calendars_auto_backup_hint),
+                position = if (autoBackup.enabled) Position.Middle else Position.Bottom,
+                leading = { LeadingAvatar(Icons.Default.Schedule) },
+                trailing = {
+                    Switch(checked = autoBackup.enabled, onCheckedChange = viewModel::setAutoBackupEnabled)
+                },
+                onClick = { viewModel.setAutoBackupEnabled(!autoBackup.enabled) },
+            )
+            if (autoBackup.enabled) {
+                GroupedRow(
+                    title = stringResource(R.string.calendars_auto_backup_folder),
+                    summary = rememberFolderName(autoBackup.folderUri)
+                        ?: stringResource(R.string.calendars_auto_backup_folder_unset),
+                    position = Position.Middle,
+                    onClick = { runCatching { pickFolder.launch(null) } },
+                )
+                GroupedRow(
+                    title = stringResource(R.string.calendars_auto_backup_interval),
+                    summary = backupIntervalLabel(autoBackup.intervalMinutes),
+                    position = Position.Bottom,
+                    onClick = { showInterval = true },
+                )
+                HintText(backupStatusText(autoBackup.status))
+            }
+        } else if (canImport) {
+            // Nothing to back up, but restore is still possible — don't hide
+            // it behind export eligibility.
+            SectionHeader(stringResource(R.string.calendars_restore_header))
+            HintText(stringResource(R.string.calendars_restore_hint))
+            GroupedRow(
+                title = stringResource(R.string.calendars_restore_action),
+                position = Position.Alone,
+                leading = { LeadingAvatar(Icons.Default.FileUpload) },
+                onClick = { runCatching { openBackup.launch(RESTORE_MIME_TYPES) } },
             )
         }
     }
 
-    // Gated on Ready rather than resetting the flag when the state leaves it:
+    if (showExportPicker) {
-    // flipping it here would be a write during composition.
+        ExportCalendarPicker(
-    (state as? BackupUiState.Ready)?.let { ready ->
+            calendars = exportable,
-        if (showExportPicker) {
+            onExport = viewModel::exportBackup,
-            ExportCalendarPicker(
+            onDismiss = { showExportPicker = false },
-                calendars = ready.exportable,
+        )
-                onExport = viewModel::exportBackup,
-                onDismiss = { showExportPicker = false },
-            )
-        }
     }
     if (showInterval) {
         BackupIntervalDialog(
@@ -182,103 +214,6 @@ fun BackupScreen(
     }
 }
 
-/** The screen's loading state, centred in the scaffold's content column. */
-@Composable
-private fun BackupLoading() {
-    Box(
-        modifier = Modifier.fillMaxSize(),
-        contentAlignment = Alignment.Center,
-    ) {
-        CircularProgressIndicator()
-    }
-}
-
-/** Default file name for a one-shot export. */
-private fun defaultBackupName(): String = "calendula-backup-${LocalDate.now()}.ics"
-
-/**
- * The working screen: export (when there are local calendars to export), restore,
- * and the automatic-backup block. Restore is always on screen — when nothing can
- * receive the events it says so and routes to the calendar manager rather than
- * disappearing, which is what #304 reported as an invisible button.
- */
-@Composable
-private fun BackupContent(
-    exportable: List<CalendarSource>,
-    canImport: Boolean,
-    autoBackup: AutoBackupUiState,
-    viewModel: CalendarsViewModel,
-    onRestore: () -> Unit,
-    onPickFolder: () -> Unit,
-    onExportAll: () -> Unit,
-    onExportPick: () -> Unit,
-    onEditInterval: () -> Unit,
-) {
-    val manageCalendars = LocalManageCalendars.current
-    // Restore never depends on export eligibility, and never disappears: when no
-    // calendar can receive events it explains that and offers the way to fix it.
-    val restoreSummary = if (canImport) {
-        stringResource(R.string.calendars_restore_hint)
-    } else {
-        stringResource(R.string.calendars_restore_unavailable)
-    }
-    val onRestoreClick = if (canImport) onRestore else (manageCalendars ?: onRestore)
-
-    if (exportable.isEmpty()) {
-        GroupedSectionHeader(stringResource(R.string.calendars_restore_header))
-        GroupedHint(restoreSummary, style = MaterialTheme.typography.bodySmall)
-        GroupedRow(
-            title = stringResource(R.string.calendars_restore_action),
-            position = Position.Alone,
-            leading = { LeadingAvatar(Icons.Default.FileUpload) },
-            onClick = onRestoreClick,
-        )
-        return
-    }
-
-    GroupedHint(stringResource(R.string.calendars_backup_hint), style = MaterialTheme.typography.bodySmall)
-    GroupedRow(
-        title = stringResource(R.string.calendars_backup_action),
-        position = Position.Top,
-        leading = { LeadingAvatar(Icons.Default.FileDownload) },
-        // A single exportable calendar skips the selector.
-        onClick = if (exportable.size == 1) onExportAll else onExportPick,
-    )
-    GroupedRow(
-        title = stringResource(R.string.calendars_restore_action),
-        summary = restoreSummary,
-        position = Position.Middle,
-        leading = { LeadingAvatar(Icons.Default.FileUpload) },
-        onClick = onRestoreClick,
-    )
-    GroupedRow(
-        title = stringResource(R.string.calendars_auto_backup),
-        summary = stringResource(R.string.calendars_auto_backup_hint),
-        position = if (autoBackup.enabled) Position.Middle else Position.Bottom,
-        leading = { LeadingAvatar(Icons.Default.Schedule) },
-        trailing = {
-            Switch(checked = autoBackup.enabled, onCheckedChange = viewModel::setAutoBackupEnabled)
-        },
-        onClick = { viewModel.setAutoBackupEnabled(!autoBackup.enabled) },
-    )
-    if (autoBackup.enabled) {
-        GroupedRow(
-            title = stringResource(R.string.calendars_auto_backup_folder),
-            summary = rememberFolderName(autoBackup.folderUri)
-                ?: stringResource(R.string.calendars_auto_backup_folder_unset),
-            position = Position.Middle,
-            onClick = onPickFolder,
-        )
-        GroupedRow(
-            title = stringResource(R.string.calendars_auto_backup_interval),
-            summary = backupIntervalLabel(autoBackup.intervalMinutes),
-            position = Position.Bottom,
-            onClick = onEditInterval,
-        )
-        GroupedHint(backupStatusText(autoBackup.status), style = MaterialTheme.typography.bodySmall)
-    }
-}
-
 /**
  * Choose which local calendars to include in a one-time `.ics` export. Defaults
  * to all selected; the Export action opens the SAF save dialog and hands back
@@ -312,13 +247,12 @@ private fun ExportCalendarPicker(
     FullScreenPicker(
         title = stringResource(R.string.calendars_export_title),
         onDismiss = onDismiss,
-        predictiveBack = true,
     ) {
-        GroupedHint(stringResource(R.string.calendars_export_hint), style = MaterialTheme.typography.bodySmall)
+        HintText(stringResource(R.string.calendars_export_hint))
         calendars.forEachIndexed { index, calendar ->
             val isSelected = calendar.id in selected
             GroupedRow(
-                title = calendar.displayName.orUnnamed(),
+                title = calendar.displayName,
                 summary = calendar.description,
                 position = positionOf(index, calendars.size),
                 leading = { CalendarColorChip(calendar.color) },
@@ -380,7 +314,9 @@ private fun backupIntervalLabel(minutes: Long): String {
 @Composable
 private fun backupStatusText(status: BackupStatus): String {
     if (status.lastRun == 0L) return stringResource(R.string.calendars_auto_backup_status_never)
-    val relative = relativeTimeAgo(status.lastRun)
+    val relative = DateUtils.getRelativeTimeSpanString(
+        status.lastRun, System.currentTimeMillis(), DateUtils.MINUTE_IN_MILLIS,
+    ).toString()
     return if (status.lastSuccess) {
         stringResource(R.string.calendars_auto_backup_status_ok, relative)
     } else {

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

@@ -1,53 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.calendars
-
-import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.FailureReason
-import de.jeanlucmakiola.calendula.domain.calendarListFailure
-import de.jeanlucmakiola.calendula.domain.isEventTarget
-
-/**
- * State of the Backup & restore screen (#69). Three states, because the calendar
- * list it is derived from has all three: it arrives empty, it can throw, and
- * "loaded but nothing to offer" is a real outcome the screen used to render as a
- * blank page (#304).
- */
-sealed interface BackupUiState {
-    data object Loading : BackupUiState
-    data class Failure(val reason: FailureReason) : BackupUiState
-
-    /**
-     * At least one half of the screen works. [exportable] may be empty (restore
-     * only) and [canImport] may be false (export only), but never both — that is
-     * a [Failure].
-     */
-    data class Ready(
-        val exportable: List<CalendarSource>,
-        val canImport: Boolean,
-    ) : BackupUiState
-}
-
-/**
- * What the screen can offer for this calendar list.
- *
- * Export covers the app's own local calendars; managed special-dates mirrors are
- * rebuilt from contacts, so they are excluded. Restore can target anything the
- * import picker offers ([isEventTarget]).
- *
- * A failure is raised only when *neither* is possible — deliberately not
- * [calendarListFailure] on its own, which would call an all-hidden device a
- * failure while its local calendars are still perfectly exportable. When both
- * halves are dead the list itself usually says why (no calendars, everything
- * switched off); [FailureReason.NoImportTarget] covers the remaining case, where
- * calendars exist and are visible but every one of them is read-only, managed or
- * not synced to the device.
- */
-fun backupUiState(calendars: List<CalendarSource>): BackupUiState {
-    val exportable = calendars.filter { it.isLocal && it.canModifyContents && !it.isManaged }
-    val canImport = calendars.any { it.isEventTarget }
-    if (exportable.isEmpty() && !canImport) {
-        return BackupUiState.Failure(
-            calendarListFailure(calendars) ?: FailureReason.NoImportTarget,
-        )
-    }
-    return BackupUiState.Ready(exportable = exportable, canImport = canImport)
-}

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

@@ -6,27 +6,34 @@ import android.content.Intent
 import android.provider.Settings
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.foundation.background
+import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ColumnScope
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
+import androidx.compose.material.icons.automirrored.filled.Notes
 import androidx.compose.material.icons.automirrored.filled.OpenInNew
 import androidx.compose.material.icons.filled.Add
 import androidx.compose.material.icons.filled.Backup
 import androidx.compose.material.icons.filled.CalendarMonth
+import androidx.compose.material.icons.filled.Close
 import androidx.compose.material.icons.filled.Delete
 import androidx.compose.material.icons.filled.Info
 import androidx.compose.material.icons.filled.MoreVert
+import androidx.compose.material.icons.filled.Palette
 import androidx.compose.material.icons.filled.PhoneAndroid
 import androidx.compose.material.icons.filled.Visibility
 import androidx.compose.material.icons.filled.VisibilityOff
@@ -34,14 +41,20 @@ import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Button
 import androidx.compose.material3.DropdownMenu
 import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -72,42 +85,23 @@ import de.jeanlucmakiola.calendula.domain.stateLabels
 import de.jeanlucmakiola.calendula.data.calendar.CalendarColorPalette
 import de.jeanlucmakiola.calendula.ui.common.AccountKey
 import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
-import de.jeanlucmakiola.calendula.ui.common.CalendarVisibilitySwitch
 import de.jeanlucmakiola.calendula.ui.common.accountGroupTitle
 import de.jeanlucmakiola.calendula.ui.common.groupByAccount
 import de.jeanlucmakiola.calendula.ui.common.LocalSoftenColors
 import de.jeanlucmakiola.calendula.ui.common.eventAccent
 import de.jeanlucmakiola.calendula.ui.common.eventFill
-import de.jeanlucmakiola.calendula.ui.common.eventInk
 import de.jeanlucmakiola.calendula.ui.common.LeadingAvatar
 import de.jeanlucmakiola.calendula.ui.common.SourceLogo
 import de.jeanlucmakiola.calendula.ui.common.curatedSourcePackage
-import de.jeanlucmakiola.calendula.ui.common.orUnnamed
 import de.jeanlucmakiola.floret.components.CollapsingScaffold
-import de.jeanlucmakiola.floret.components.GroupedHint
-import de.jeanlucmakiola.floret.components.GroupedSectionHeader
-import de.jeanlucmakiola.floret.identity.LocalFloretDarkTheme
 import de.jeanlucmakiola.floret.identity.collapseExit
 import de.jeanlucmakiola.floret.identity.expandEnter
 import de.jeanlucmakiola.floret.identity.predictiveBack
+import de.jeanlucmakiola.calendula.ui.common.ColorSwatchRow
+import de.jeanlucmakiola.floret.components.GroupedListInset
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.InlineTextField
 import de.jeanlucmakiola.floret.components.Position
-import androidx.compose.foundation.layout.aspectRatio
-import androidx.compose.foundation.layout.heightIn
-import androidx.annotation.StringRes
-import androidx.compose.foundation.border
-import androidx.compose.foundation.selection.selectable
-import androidx.compose.foundation.selection.selectableGroup
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.icons.filled.Check
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.semantics.Role
-import androidx.compose.ui.text.input.ImeAction
-import de.jeanlucmakiola.floret.components.FullScreenPicker
-import de.jeanlucmakiola.floret.components.GroupedSurface
 
 /** Sentinel [editorId] meaning "the editor is composing a new calendar". */
 private const val NEW_CALENDAR_ID = Long.MIN_VALUE
@@ -124,7 +118,6 @@ private const val NEW_CALENDAR_ID = Long.MIN_VALUE
 fun CalendarsScreen(
     onBack: () -> Unit,
     onOpenBackup: () -> Unit,
-    visible: Boolean = true,
     viewModel: CalendarsViewModel = hiltViewModel(),
 ) {
     val calendars by viewModel.calendars.collectAsStateWithLifecycle()
@@ -169,7 +162,6 @@ fun CalendarsScreen(
             onConsumeError = viewModel::consumeError,
             onOpenBackup = onOpenBackup,
             onBack = onBack,
-            visible = visible,
             onAdd = { editorSession++; editorId = NEW_CALENDAR_ID },
             onEdit = { calendar -> editorSession++; editorId = calendar.id },
             onSetVisible = viewModel::setCalendarVisible,
@@ -186,7 +178,6 @@ private fun CalendarsList(
     onConsumeError: () -> Unit,
     onOpenBackup: () -> Unit,
     onBack: () -> Unit,
-    visible: Boolean,
     onAdd: () -> Unit,
     onEdit: (CalendarSource) -> Unit,
     onSetVisible: (Long, Boolean) -> Unit,
@@ -212,10 +203,9 @@ private fun CalendarsList(
         onBack = onBack,
         snackbarHost = { SnackbarHost(snackbarHostState) },
         predictiveBack = true,
-        visible = visible,
     ) {
         // What the per-calendar / per-account switches below actually do.
-        GroupedHint(stringResource(R.string.calendars_visibility_hint), style = MaterialTheme.typography.bodySmall)
+        HintText(stringResource(R.string.calendars_visibility_hint))
 
         // Local (device-only) calendars — one collapsible group. The header's
         // "+" adds a calendar; the switch enables/disables them all at once;
@@ -236,13 +226,24 @@ private fun CalendarsList(
             onToggleAll = { enabled -> onSetAccountVisible(local.map { it.id }, enabled) },
         ) {
             if (local.isEmpty()) {
-                GroupedHint(stringResource(R.string.calendars_local_empty), style = MaterialTheme.typography.bodySmall)
+                HintText(stringResource(R.string.calendars_local_empty))
             } else {
                 local.forEachIndexed { index, calendar ->
-                    CalendarManagerRow(
+                    val disabled = !calendar.isVisibleInSystem
-                        calendar = calendar,
+                    GroupedRow(
-                        last = index == local.lastIndex,
+                        title = calendar.displayName,
-                        onSetVisible = onSetVisible,
+                        summary = calendarRowSummary(calendar),
+                        position = if (index == local.lastIndex) Position.Bottom else Position.Middle,
+                        container = MaterialTheme.colorScheme.surfaceContainerHighest,
+                        dimmed = disabled,
+                        leading = { CalendarColorChip(calendar.color, dimIf(disabled)) },
+                        trailing = {
+                            EnableSwitch(
+                                calendarName = calendar.displayName,
+                                enabled = !disabled,
+                                onToggle = { enabled -> onSetVisible(calendar.id, enabled) },
+                            )
+                        },
                         onClick = { onEdit(calendar) },
                     )
                 }
@@ -271,8 +272,8 @@ private fun CalendarsList(
         // Synced calendars — read-only, grouped by account. Each account is a
         // collapsible group whose header opens the source app (icon) and toggles
         // all of its calendars at once (switch).
-        GroupedSectionHeader(stringResource(R.string.calendars_synced_header))
+        SectionHeader(stringResource(R.string.calendars_synced_header))
-        GroupedHint(stringResource(R.string.calendars_synced_hint), style = MaterialTheme.typography.bodySmall)
+        HintText(stringResource(R.string.calendars_synced_hint))
         synced
             .groupByAccount()
             .forEach { group ->
@@ -313,10 +314,27 @@ private fun CalendarsList(
                     // bottom, dimmed and switchless.
                     val ordered = cals.orderedForManager()
                     ordered.forEachIndexed { index, calendar ->
-                        CalendarManagerRow(
+                        val disabled = !calendar.isVisibleInSystem || calendar.isNotSynced
-                            calendar = calendar,
+                        GroupedRow(
-                            last = index == ordered.lastIndex,
+                            title = calendar.displayName,
-                            onSetVisible = onSetVisible,
+                            summary = calendarRowSummary(calendar),
+                            position = if (index == ordered.lastIndex) Position.Bottom else Position.Middle,
+                            container = MaterialTheme.colorScheme.surfaceContainerHighest,
+                            dimmed = disabled,
+                            leading = { CalendarColorChip(calendar.color, dimIf(disabled)) },
+                            trailing = if (calendar.hasVisibilitySwitch) {
+                                {
+                                    EnableSwitch(
+                                        calendarName = calendar.displayName,
+                                        enabled = calendar.isVisibleInSystem,
+                                        onToggle = { enabled ->
+                                            onSetVisible(calendar.id, enabled)
+                                        },
+                                    )
+                                }
+                            } else {
+                                null
+                            },
                         )
                     }
                 }
@@ -325,15 +343,9 @@ private fun CalendarsList(
 
 }
 
-private const val SWATCHES_PER_ROW = 6
+@OptIn(ExperimentalMaterial3Api::class)
-
-/**
- * Create or edit a local calendar: a name field over the palette of calendar
- * colours, on the family's full-screen sheet with the commit in its title bar.
- * The same sheet Agendula edits a task list in, so the two read as one product.
- */
 @Composable
-internal fun CalendarEditor(
+private fun CalendarEditor(
     sessionKey: Int,
     isNew: Boolean,
     initialName: String,
@@ -348,50 +360,121 @@ internal fun CalendarEditor(
     var color by rememberSaveable(sessionKey) { mutableStateOf(initialColor) }
     var description by rememberSaveable(sessionKey) { mutableStateOf(initialDescription) }
     var confirmDelete by remember { mutableStateOf(false) }
-    val focusRequester = remember { FocusRequester() }
+    val dark = isSystemInDarkTheme()
+    val soften = LocalSoftenColors.current
 
-    val valid = name.isNotBlank()
+    Scaffold(
-    val commit = { if (valid) onSave(name.trim(), color, description.trim().ifEmpty { null }) }
+        modifier = Modifier
-
+            .predictiveBack(onBack = onClose)
-    FullScreenPicker(
+            .fillMaxSize()
-        title = stringResource(
+            .background(MaterialTheme.colorScheme.surface),
-            if (isNew) R.string.calendars_new_title else R.string.calendars_edit_title,
+        topBar = {
-        ),
+            TopAppBar(
-        onDismiss = onClose,
+                title = {
-        predictiveBack = true,
+                    Text(
-        actions = {
+                        stringResource(
-            Button(
+                            if (isNew) R.string.calendars_new_title
-                onClick = commit,
+                            else R.string.calendars_edit_title,
-                enabled = valid,
+                        ),
-                modifier = Modifier.padding(end = 12.dp),
+                    )
-            ) { Text(stringResource(R.string.event_edit_save)) }
+                },
+                navigationIcon = {
+                    IconButton(onClick = onClose) {
+                        Icon(
+                            Icons.Default.Close,
+                            contentDescription = stringResource(R.string.event_edit_close),
+                        )
+                    }
+                },
+                actions = {
+                    if (!isNew) {
+                        // Disabled rather than hidden while the special-dates
+                        // sync owns this calendar; the card below says why.
+                        IconButton(
+                            onClick = { confirmDelete = true },
+                            enabled = !deleteLocked,
+                        ) {
+                            Icon(
+                                Icons.Default.Delete,
+                                contentDescription = stringResource(R.string.event_detail_delete),
+                                tint = if (deleteLocked) {
+                                    MaterialTheme.colorScheme.onSurface.copy(alpha = 0.38f)
+                                } else {
+                                    MaterialTheme.colorScheme.error
+                                },
+                            )
+                        }
+                    }
+                    // Filled save button, matching the event editor's top bar.
+                    Button(
+                        onClick = {
+                            onSave(name.trim(), color, description.trim().ifEmpty { null })
+                        },
+                        enabled = name.isNotBlank(),
+                        modifier = Modifier.padding(end = 12.dp),
+                    ) {
+                        Text(stringResource(R.string.event_edit_save))
+                    }
+                },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = MaterialTheme.colorScheme.surface,
+                ),
+            )
         },
-    ) {
+    ) { innerPadding ->
-        if (deleteLocked) {
+        Column(
-            ManagedNote()
+            modifier = Modifier
-            Spacer(Modifier.height(20.dp))
+                .padding(innerPadding)
-        }
+                .fillMaxSize()
-
+                .verticalScroll(rememberScrollState())
-        CalendarNameField(
+                .padding(horizontal = 16.dp, vertical = 8.dp),
-            name = name,
+            verticalArrangement = Arrangement.spacedBy(12.dp),
-            color = color,
+        ) {
-            focusRequester = focusRequester,
+            if (deleteLocked) {
-            onNameChange = { name = it },
+                EditorCard(
-            onImeAction = commit,
+                    icon = Icons.Default.Info,
-        )
+                    iconTint = MaterialTheme.colorScheme.onSurfaceVariant,
-        // Inside the picker: it is a Dialog, so a request made from the caller's
+                    iconAtTop = true,
-        // composition can run before this field's node exists.
+                ) {
-        // A new calendar opens with the keyboard up: naming it is the whole task.
+                    Text(
-        LaunchedEffect(isNew) { if (isNew) focusRequester.requestFocus() }
+                        text = stringResource(R.string.calendars_managed_delete_locked),
-
+                        style = MaterialTheme.typography.bodyMedium,
-        Spacer(Modifier.height(20.dp))
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
-        EditorSectionLabel(stringResource(R.string.calendars_color_label))
+                    )
-        CalendarColorGrid(selected = color, onSelect = { color = it })
+                }
-
+            }
-        Spacer(Modifier.height(20.dp))
+            EditorCard(icon = Icons.Default.CalendarMonth, iconTint = eventAccent(color, dark, soften)) {
-        EditorSectionLabel(stringResource(R.string.calendars_description_label))
+                InlineTextField(
-        GroupedSurface(position = Position.Alone, modifier = Modifier.padding(horizontal = 16.dp)) {
+                    value = name,
-            Box(Modifier.fillMaxWidth().heightIn(min = 72.dp).padding(16.dp)) {
+                    onValueChange = { name = it },
+                    placeholder = stringResource(R.string.calendars_name_label),
+                    textStyle = MaterialTheme.typography.titleLarge,
+                    capitalization = KeyboardCapitalization.Sentences,
+                )
+            }
+            EditorCard(
+                icon = Icons.Default.Palette,
+                iconTint = MaterialTheme.colorScheme.onSurfaceVariant,
+                iconAtTop = true,
+            ) {
+                Text(
+                    text = stringResource(R.string.calendars_color_label),
+                    style = MaterialTheme.typography.labelLarge,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+                Spacer(Modifier.height(12.dp))
+                ColorSwatchRow(
+                    colors = CalendarColorPalette.all,
+                    selected = color,
+                    onSelect = { color = it },
+                    dark = dark,
+                )
+            }
+            EditorCard(
+                icon = Icons.AutoMirrored.Filled.Notes,
+                iconTint = MaterialTheme.colorScheme.onSurfaceVariant,
+                iconAtTop = true,
+            ) {
                 InlineTextField(
                     value = description,
                     onValueChange = { description = it },
@@ -402,21 +485,20 @@ internal fun CalendarEditor(
                 )
             }
         }
-
-        if (!isNew && !deleteLocked) {
-            Spacer(Modifier.height(24.dp))
-            DeleteCalendarRow(onClick = { confirmDelete = true })
-        }
-        Spacer(Modifier.height(24.dp))
     }
 
     if (confirmDelete) {
         AlertDialog(
             onDismissRequest = { confirmDelete = false },
             title = { Text(stringResource(R.string.calendars_delete_confirm_title)) },
-            text = { Text(stringResource(R.string.calendars_delete_confirm_message, initialName)) },
+            text = {
+                Text(stringResource(R.string.calendars_delete_confirm_message, initialName))
+            },
             confirmButton = {
-                TextButton(onClick = { confirmDelete = false; onDelete() }) {
+                TextButton(onClick = {
+                    confirmDelete = false
+                    onDelete()
+                }) {
                     Text(
                         stringResource(R.string.event_detail_delete),
                         color = MaterialTheme.colorScheme.error,
@@ -432,205 +514,6 @@ internal fun CalendarEditor(
     }
 }
 
-/** The name, with the chosen colour beside it so the two read as one thing. */
-@Composable
-private fun CalendarNameField(
-    name: String,
-    color: Int,
-    focusRequester: FocusRequester,
-    onNameChange: (String) -> Unit,
-    onImeAction: () -> Unit,
-) {
-    val dark = LocalFloretDarkTheme.current
-    val soften = LocalSoftenColors.current
-    GroupedSurface(position = Position.Alone, modifier = Modifier.padding(horizontal = 16.dp)) {
-        Row(
-            modifier = Modifier.fillMaxWidth().heightIn(min = 72.dp).padding(horizontal = 16.dp),
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.spacedBy(16.dp),
-        ) {
-            Box(
-                modifier = Modifier
-                    .size(40.dp)
-                    .clip(CircleShape)
-                    .background(MaterialTheme.colorScheme.surfaceContainerHighest),
-                contentAlignment = Alignment.Center,
-            ) {
-                Icon(
-                    Icons.Default.CalendarMonth,
-                    contentDescription = null,
-                    tint = eventAccent(color, dark, soften),
-                    modifier = Modifier.size(22.dp),
-                )
-            }
-            InlineTextField(
-                value = name,
-                onValueChange = onNameChange,
-                placeholder = stringResource(R.string.calendars_name_label),
-                capitalization = KeyboardCapitalization.Sentences,
-                imeAction = ImeAction.Done,
-                onImeAction = onImeAction,
-                modifier = Modifier.fillMaxWidth().focusRequester(focusRequester),
-            )
-        }
-    }
-}
-
-/**
- * The palette as two rows of round swatches; the chosen one carries a check.
- *
- * Drawn through the app's own tone pass rather than raw, so a swatch is the
- * colour the calendar's events will actually appear in — the user's "soften
- * colours" preference included.
- */
-@Composable
-private fun CalendarColorGrid(selected: Int, onSelect: (Int) -> Unit) {
-    val dark = LocalFloretDarkTheme.current
-    val soften = LocalSoftenColors.current
-    GroupedSurface(position = Position.Alone, modifier = Modifier.padding(horizontal = 16.dp)) {
-        Column(
-            modifier = Modifier
-                .padding(horizontal = 12.dp, vertical = 16.dp)
-                .selectableGroup(),
-            verticalArrangement = Arrangement.spacedBy(12.dp),
-        ) {
-            CalendarColorPalette.all.chunked(SWATCHES_PER_ROW).forEach { row ->
-                Row(
-                    modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.spacedBy(8.dp),
-                ) {
-                    row.forEach { swatch ->
-                        ColorSwatch(
-                            fill = eventFill(swatch, dark, soften),
-                            label = stringResource(swatchLabel(swatch)),
-                            selected = swatch == selected,
-                            onClick = { onSelect(swatch) },
-                            modifier = Modifier.weight(1f),
-                        )
-                    }
-                    // Keeps a short final row's swatches the size a full row's
-                    // are, rather than stretching them across the width.
-                    repeat(SWATCHES_PER_ROW - row.size) { Spacer(Modifier.weight(1f)) }
-                }
-            }
-        }
-    }
-}
-
-@Composable
-private fun ColorSwatch(
-    fill: Color,
-    label: String,
-    selected: Boolean,
-    onClick: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    Box(
-        modifier = modifier
-            .aspectRatio(1f)
-            .clip(CircleShape)
-            .background(fill)
-            .then(
-                if (selected) {
-                    Modifier.border(2.dp, MaterialTheme.colorScheme.onSurface, CircleShape)
-                } else {
-                    Modifier
-                },
-            )
-            // selectable, not clickable: the swatch carries its chosen state in
-            // semantics too, so the check is not the only cue.
-            .selectable(selected = selected, role = Role.RadioButton, onClick = onClick)
-            .semantics { contentDescription = label },
-        contentAlignment = Alignment.Center,
-    ) {
-        if (selected) {
-            Icon(
-                Icons.Default.Check,
-                contentDescription = null,
-                tint = eventInk(fill, alpha = 0.7f),
-                modifier = Modifier.size(22.dp),
-            )
-        }
-    }
-}
-
-/** Names the swatch for a screen reader — twelve circles are otherwise one label. */
-@StringRes
-private fun swatchLabel(argb: Int): Int = when (argb) {
-    CalendarColorPalette.Mauve -> R.string.color_name_mauve
-    CalendarColorPalette.Red -> R.string.color_name_red
-    CalendarColorPalette.Orange -> R.string.color_name_orange
-    CalendarColorPalette.Amber -> R.string.color_name_amber
-    CalendarColorPalette.Olive -> R.string.color_name_olive
-    CalendarColorPalette.Green -> R.string.color_name_green
-    CalendarColorPalette.Teal -> R.string.color_name_teal
-    CalendarColorPalette.Cyan -> R.string.color_name_cyan
-    CalendarColorPalette.Blue -> R.string.color_name_blue
-    CalendarColorPalette.Indigo -> R.string.color_name_indigo
-    CalendarColorPalette.Purple -> R.string.color_name_purple
-    else -> R.string.color_name_pink
-}
-
-/** Said in the sheet rather than on a disabled button: the sync owns this one. */
-@Composable
-private fun ManagedNote() {
-    GroupedSurface(
-        position = Position.Alone,
-        modifier = Modifier.padding(horizontal = 16.dp),
-        color = MaterialTheme.colorScheme.surfaceVariant,
-    ) {
-        Row(
-            modifier = Modifier.fillMaxWidth().heightIn(min = 64.dp).padding(20.dp),
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.spacedBy(16.dp),
-        ) {
-            Icon(Icons.Default.Info, contentDescription = null)
-            Text(
-                text = stringResource(R.string.calendars_managed_delete_locked),
-                style = MaterialTheme.typography.bodyMedium,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-            )
-        }
-    }
-}
-
-@Composable
-private fun DeleteCalendarRow(onClick: () -> Unit) {
-    GroupedSurface(
-        position = Position.Alone,
-        modifier = Modifier.padding(horizontal = 16.dp),
-        onClick = onClick,
-        color = MaterialTheme.colorScheme.errorContainer,
-    ) {
-        Row(
-            modifier = Modifier.fillMaxWidth().heightIn(min = 64.dp).padding(horizontal = 20.dp),
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.spacedBy(16.dp),
-        ) {
-            Icon(
-                Icons.Default.Delete,
-                contentDescription = null,
-                tint = MaterialTheme.colorScheme.onErrorContainer,
-            )
-            Text(
-                text = stringResource(R.string.event_detail_delete),
-                style = MaterialTheme.typography.bodyLarge,
-                color = MaterialTheme.colorScheme.onErrorContainer,
-            )
-        }
-    }
-}
-
-@Composable
-private fun EditorSectionLabel(text: String) {
-    Text(
-        text = text,
-        style = MaterialTheme.typography.labelMedium,
-        color = MaterialTheme.colorScheme.onSurfaceVariant,
-        modifier = Modifier.padding(start = 28.dp, end = 28.dp, bottom = 8.dp),
-    )
-}
-
 /**
  * The row's supporting line: the states that make this calendar behave unlike a
  * plain writable one (#76), then its own description.
@@ -655,37 +538,17 @@ private fun calendarRowSummary(calendar: CalendarSource): String? {
  * `Calendars.VISIBLE`. Unchecked drops the calendar out of every surface and
  * stops its reminders. Carries its own content description.
  */
-/**
- * One calendar in a group: dimmed while switched off or not syncing, with the
- * visibility switch only where it can change anything.
- */
 @Composable
-private fun CalendarManagerRow(
+private fun EnableSwitch(
-    calendar: CalendarSource,
+    calendarName: String,
-    last: Boolean,
+    enabled: Boolean,
-    onSetVisible: (Long, Boolean) -> Unit,
+    onToggle: (Boolean) -> Unit,
-    onClick: (() -> Unit)? = null,
 ) {
-    val disabled = !calendar.isVisibleInSystem || calendar.isNotSynced
+    val label = stringResource(R.string.calendars_visibility_a11y, calendarName)
-    GroupedRow(
+    Switch(
-        title = calendar.displayName.orUnnamed(),
+        checked = enabled,
-        summary = calendarRowSummary(calendar),
+        onCheckedChange = onToggle,
-        position = if (last) Position.Bottom else Position.Middle,
+        modifier = Modifier.semantics { contentDescription = label },
-        container = MaterialTheme.colorScheme.surfaceContainerHighest,
-        dimmed = disabled,
-        leading = { CalendarColorChip(calendar.color, dimIf(disabled)) },
-        trailing = if (calendar.hasVisibilitySwitch) {
-            {
-                CalendarVisibilitySwitch(
-                    calendarName = calendar.displayName.orUnnamed(),
-                    enabled = calendar.isVisibleInSystem,
-                    onToggle = { enabled -> onSetVisible(calendar.id, enabled) },
-                )
-            }
-        } else {
-            null
-        },
-        onClick = onClick,
     )
 }
 
@@ -693,6 +556,36 @@ private fun CalendarManagerRow(
 private fun dimIf(disabled: Boolean): Modifier =
     if (disabled) Modifier.alpha(0.38f) else Modifier
 
+/** Tonal field card matching the event editor's design (icon + content). */
+@Composable
+private fun EditorCard(
+    icon: ImageVector,
+    iconTint: Color,
+    iconAtTop: Boolean = false,
+    content: @Composable () -> Unit,
+) {
+    Surface(
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
+        shape = RoundedCornerShape(16.dp),
+        modifier = Modifier.fillMaxWidth(),
+    ) {
+        Row(
+            modifier = Modifier.padding(16.dp),
+            verticalAlignment = if (iconAtTop) Alignment.Top else Alignment.CenterVertically,
+        ) {
+            Icon(
+                imageVector = icon,
+                contentDescription = null,
+                tint = iconTint,
+                modifier = Modifier
+                    .padding(top = if (iconAtTop) 2.dp else 0.dp)
+                    .size(24.dp),
+            )
+            Spacer(Modifier.width(16.dp))
+            Column(modifier = Modifier.weight(1f)) { content() }
+        }
+    }
+}
 
 /**
  * One collapsible calendar group rendered as a connected card. The header row is
@@ -824,6 +717,33 @@ private fun CalendarGroupMenu(
 }
 
 
+@Composable
+internal fun SectionHeader(text: String) {
+    Text(
+        text = text,
+        style = MaterialTheme.typography.labelLarge,
+        color = MaterialTheme.colorScheme.primary,
+        // The cards' own edge, so header and group share a left margin.
+        modifier = Modifier.padding(
+            start = GroupedListInset,
+            end = GroupedListInset,
+            top = 16.dp,
+            bottom = 4.dp,
+        ),
+    )
+}
+
+@Composable
+internal fun HintText(text: String) {
+    Text(
+        text = text,
+        style = MaterialTheme.typography.bodySmall,
+        color = MaterialTheme.colorScheme.onSurfaceVariant,
+        modifier = Modifier.padding(horizontal = GroupedListInset, vertical = 4.dp),
+    )
+}
+
+
 /**
  * Pick the app to open for managing a synced calendar's account. The account's
  * own authenticator package (resolved from [AccountManager], no permission

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

@@ -9,23 +9,22 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.data.backup.BackupScheduler
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
+import de.jeanlucmakiola.calendula.data.di.IoDispatcher
 import de.jeanlucmakiola.calendula.data.ics.IcsExporter
 import de.jeanlucmakiola.calendula.data.prefs.BackupStatus
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
-import de.jeanlucmakiola.floret.android.stateWhileSubscribed
-import de.jeanlucmakiola.floret.di.IoDispatcher
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import kotlin.coroutines.cancellation.CancellationException
@@ -51,26 +50,12 @@ class CalendarsViewModel @Inject constructor(
         repository.calendars()
             .catch { emit(emptyList()) }
             .flowOn(io)
-            .stateWhileSubscribed(
+            .stateIn(
                 scope = viewModelScope,
+                started = SharingStarted.WhileSubscribed(5_000L),
                 initialValue = emptyList(),
             )
 
-    /**
-     * The Backup & restore screen's own view of that list, with the loading and
-     * failure states [calendars] flattens away — it starts empty and catches to
-     * empty, which that screen used to render as a blank page (#304).
-     */
-    val backupState: StateFlow<BackupUiState> =
-        repository.calendars()
-            .map { backupUiState(it) }
-            .catch { emit(BackupUiState.Failure(FailureReason.ProviderUnavailable)) }
-            .flowOn(io)
-            .stateWhileSubscribed(
-                scope = viewModelScope,
-                initialValue = BackupUiState.Loading,
-            )
-
     /** Automatic-backup settings + last-run status, for the Backup section UI. */
     val autoBackup: StateFlow<AutoBackupUiState> = combine(
         settingsPrefs.autoBackupEnabled,
@@ -81,8 +66,9 @@ class CalendarsViewModel @Inject constructor(
         AutoBackupUiState(enabled, interval, folder, status)
     }
         .flowOn(io)
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = AutoBackupUiState(),
         )
 
@@ -99,8 +85,9 @@ class CalendarsViewModel @Inject constructor(
         if (!enabled) emptySet() else sources.filter { it.isManaged }.map { it.id }.toSet()
     }
         .flowOn(io)
-        .stateWhileSubscribed(
+        .stateIn(
             scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000L),
             initialValue = emptySet(),
         )
 

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

@@ -56,14 +56,12 @@ fun List<CalendarSource>.groupByAccount(): List<CalendarAccountGroup> {
  * account comes from when another account shares the name (#77).
  */
 @Composable
-fun accountGroupTitle(group: CalendarAccountGroup): String {
+fun accountGroupTitle(group: CalendarAccountGroup): String =
-    val label = group.label.orUnnamed()
+    if (!group.ambiguous) {
-    return if (!group.ambiguous) {
+        group.label
-        label
     } else {
-        stringResource(R.string.calendars_account_from_source, label, sourceAppName(group.accountType))
+        stringResource(R.string.calendars_account_from_source, group.label, sourceAppName(group.accountType))
     }
-}
 
 /**
  * The human name of the app backing [accountType], falling back to the raw

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

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

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

@@ -3,7 +3,6 @@ package de.jeanlucmakiola.calendula.ui.common
 import androidx.compose.animation.Crossfade
 import androidx.compose.animation.core.FiniteAnimationSpec
 import androidx.compose.animation.core.animateDpAsState
-import androidx.compose.animation.core.animateFloatAsState
 import androidx.compose.animation.core.snap
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.MaterialTheme
@@ -11,240 +10,24 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.Immutable
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.layout.Layout
+import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.layout.ParentDataModifier
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.rememberTextMeasurer
-import androidx.compose.ui.text.style.TextDecoration
-import androidx.compose.ui.unit.Constraints
-import androidx.compose.ui.unit.Density
 import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
 import de.jeanlucmakiola.floret.identity.rememberReduceMotion
-import kotlin.math.roundToInt
-
-/** Gap a timed block leaves to its neighbours in the column. */
-val BLOCK_OUTER_INSET = 1.dp
-
-/** Padding between a timed block's edge and its text. */
-val BLOCK_TEXT_PADDING = 4.dp
-
-/** The same, above and below — what a block's height has to pay before any text. */
-val BLOCK_TEXT_INSET = 2.dp
-
-/**
- * What a timed block of a given height has to spend on text, and what each line
- * of it costs.
- */
-@Immutable
-data class BlockTextMetrics(
-    /** Padding above and below the text — see [rememberBlockTextMetrics]. */
-    val inset: Dp,
-    /** Height left for text once [inset] is paid at both edges. */
-    val available: Dp,
-    /** What the first line of a title draws in. */
-    val titleLine: Dp,
-    /** What every title line after the first adds. */
-    val titleLeading: Dp,
-    /** What the time label's one line draws in. */
-    val timeLine: Dp,
-) {
-    /** Whether the block can draw a title at all. */
-    val fitsTitle: Boolean get() = available >= titleLine
-
-    /** Height a title of [lines] lines occupies. */
-    fun titleHeight(lines: Int): Dp =
-        if (lines <= 0) 0.dp else titleLine + titleLeading * (lines - 1)
-
-    /** Title lines that fit [within], which may be none. */
-    fun titleBudget(within: Dp): Int =
-        if (within < titleLine) 0 else 1 + ((within - titleLine) / titleLeading).toInt()
-}
-
-/**
- * The vertical padding a block [height] tall can afford around a title line of
- * [titleLine].
- *
- * The inset is what the block gives up first: breathing room is worth having
- * where there is room to breathe, but on a block down to its last few pixels a
- * bare colour chip where a label would have fit reads as a rendering fault. It
- * tapers rather than snapping, so a pinch closes the gap gradually instead of
- * dropping it in one frame (#289).
- */
-internal fun blockTextInset(height: Dp, titleLine: Dp): Dp =
-    minOf(BLOCK_TEXT_INSET, (height - titleLine) / 2).coerceAtLeast(0.dp)
-
-/** Text metrics for a timed block [height] tall. */
-@Composable
-fun rememberBlockTextMetrics(height: Dp): BlockTextMetrics {
-    val titleStyle = MaterialTheme.typography.labelMedium
-    val titleLine = rememberTrimmedLineHeight(titleStyle)
-    // Packed, so a second line costs what the first did rather than a whole
-    // Material line box — the gap between two lines of a wrapped title is the
-    // one place a block pays that leading twice (#190).
-    val titleLeading = titleLine
-    val timeLine = rememberTrimmedLineHeight(MaterialTheme.typography.labelSmall.asEventTime())
-    val inset = blockTextInset(height, titleLine)
-    return BlockTextMetrics(
-        inset = inset,
-        available = height - inset * 2,
-        titleLine = titleLine,
-        titleLeading = titleLeading,
-        timeLine = timeLine,
-    )
-}
-
-/**
- * Lines [text] needs to render whole at [textWidth], capped at [max].
- *
- * Lets a block hand out its height by what the text actually asks for rather
- * than by what would fit: a title that wants one line should not be given three
- * that the time label could have used, and a week column is narrower than a
- * "09:30–11:00" range so the range should not be assumed to want one.
- */
-@Composable
-fun blockTextLines(text: String, style: TextStyle, textWidth: Dp, max: Int): Int {
-    val measurer = rememberTextMeasurer()
-    val widthPx = with(LocalDensity.current) { textWidth.roundToPx() }
-    return remember(text, style, widthPx, max, measurer) {
-        if (max <= 1 || widthPx <= 0) {
-            1
-        } else {
-            measurer.measure(
-                text = text,
-                style = style,
-                constraints = Constraints(maxWidth = widthPx),
-            ).lineCount.coerceIn(1, max)
-        }
-    }
-}
-
-/**
- * Lines the time label may take at [textWidth], out of the [spare] height left
- * once the title and the label's own first line are paid for.
- *
- * A week column is narrower than a "09:30–11:00" range — and a 12-hour
- * "6:00 PM–7:00 PM" can want four lines — so the label wraps over as many as it
- * needs rather than lose its end, but only out of lines the title measured
- * itself as not needing, never one it would have filled.
- */
-@Composable
-fun blockTimeLines(label: String, textWidth: Dp, spare: Dp): Int {
-    val timeLineHeight = rememberTrimmedLineHeight(
-        MaterialTheme.typography.labelSmall.asEventTime(),
-    )
-    return blockTextLines(
-        text = label,
-        // The style it is drawn in, or the budget measures a line the label
-        // never uses (#219).
-        style = MaterialTheme.typography.labelSmall.asEventTime(),
-        textWidth = textWidth,
-        max = timeLinesWithin(spare, timeLineHeight),
-    )
-}
-
-/** Lines a time label may take: its own first one, plus every whole [timeLine] in [spare]. */
-internal fun timeLinesWithin(spare: Dp, timeLine: Dp): Int =
-    if (spare < timeLine || timeLine <= 0.dp) 1 else 1 + (spare / timeLine).toInt()
-
-/**
- * The time range as a timed block draws it.
- *
- * Each time stays whole where the column is wide enough for one, so a 12-hour
- * label never parts "6:00" from its "PM": the range breaks at the dash, which
- * rides on whichever side has room for it. Where not even one time fits, the
- * text wraps wherever it can.
- */
-@Composable
-fun rememberBlockTimeRange(start: String, end: String, textWidth: Dp): String {
-    val measurer = rememberTextMeasurer()
-    val style = MaterialTheme.typography.labelSmall.asEventTime()
-    val widthPx = with(LocalDensity.current) { textWidth.roundToPx() }
-    return remember(start, end, style, widthPx, measurer) {
-        blockTimeRange(start, end) {
-            measurer.measure(text = it, style = style, softWrap = false).size.width <= widthPx
-        }
-    }
-}
-
-internal fun blockTimeRange(start: String, end: String, fits: (String) -> Boolean): String {
-    val from = start.replace(' ', NO_BREAK_SPACE)
-    val to = end.replace(' ', NO_BREAK_SPACE)
-    return when {
-        fits("$from–$to") -> "$from–$to"
-        !fits(from) || !fits(to) -> "$start–$ZERO_WIDTH_SPACE$end"
-        fits("$from–") -> "$from–\n$to"
-        fits("–$to") -> "$from\n–$to"
-        else -> "$from\n$to"
-    }
-}
-
-private const val NO_BREAK_SPACE = ' '
-private const val ZERO_WIDTH_SPACE = '​'
-
-/**
- * A timed block's title, over at most [maxLines], breaking at word boundaries.
- *
- * #164 clipped the last line mid-glyph so none of a narrow chip's few
- * characters went on an ellipsis. On a block that can wrap, whole words read
- * better than full lines do: "Farmers Market" over two lines beats "Farmer" /
- * "s Marke". A single line still clips, having nowhere to wrap to.
- */
-@Composable
-fun BlockTitle(
-    title: String,
-    maxLines: Int,
-    color: Color,
-    modifier: Modifier = Modifier,
-    textDecoration: TextDecoration? = null,
-    fontWeight: FontWeight? = null,
-) {
-    val overflow = eventTitleOverflow(singleLine = maxLines == 1)
-    Text(
-        text = title,
-        modifier = modifier,
-        style = rememberPackedLines(
-            MaterialTheme.typography.labelMedium
-                .let { if (fontWeight == null) it else it.copy(fontWeight = fontWeight) },
-        ),
-        maxLines = maxLines,
-        overflow = overflow.overflow,
-        softWrap = overflow.softWrap,
-        color = color,
-        textDecoration = textDecoration,
-    )
-}
 
 /**
  * A timed block's own time label, crossfaded rather than replaced — the block
  * slides to its new slot, so the label shouldn't change in a single frame.
- *
- * Overflows like a title does (#164): the "…" costs two characters of a string
- * that is nothing but characters, so the label clips at the block's edge
- * instead. [maxLines] lets a narrow column spend spare height on the range
- * rather than losing its end.
  */
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun BlockTimeLabel(
+fun BlockTimeLabel(label: String, color: Color, modifier: Modifier = Modifier) {
-    label: String,
-    color: Color,
-    modifier: Modifier = Modifier,
-    maxLines: Int = 1,
-) {
     val spec: FiniteAnimationSpec<Float> = if (rememberReduceMotion()) {
         snap()
     } else {
         MaterialTheme.motionScheme.fastEffectsSpec()
     }
-    val overflow = eventTitleOverflow(singleLine = maxLines == 1)
-    // Regular weight against the title's medium above it (#219).
-    val style = rememberPackedLines(MaterialTheme.typography.labelSmall.asEventTime())
     Crossfade(
         targetState = label,
         animationSpec = spec,
@@ -253,22 +36,17 @@ fun BlockTimeLabel(
     ) { text ->
         Text(
             text = text,
-            style = style,
+            style = MaterialTheme.typography.labelSmall,
-            maxLines = maxLines,
+            maxLines = 1,
-            overflow = overflow.overflow,
+            overflow = TextOverflow.Ellipsis,
-            softWrap = overflow.softWrap,
             color = color,
         )
     }
 }
 
-/**
+/** Where a timed block sits in its column, after tweening. */
- * Where a timed block sits in its column, after tweening: across as shares of
- * the column's width, so a column resizing carries its blocks with it (#184),
- * down in the timeline's own units.
- */
 @Immutable
-data class BlockPlacement(val xFraction: Float, val widthFraction: Float, val y: Dp, val height: Dp)
+data class BlockPlacement(val x: Dp, val y: Dp, val width: Dp, val height: Dp)
 
 /**
  * A timed block's placement, tweened rather than jumped. Continuity comes from
@@ -278,63 +56,20 @@ data class BlockPlacement(val xFraction: Float, val widthFraction: Float, val y:
  * A pinch-zoom rewrites the hour height every pointer frame, and the gutter and
  * grid lines follow it instantly — so the tween stands down for the gesture
  * rather than leaving the blocks trailing the ruler they are measured against.
- * A [landing] block, under a dropped copy, moves without the spring's bounce.
  */
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun animatedBlockPlacement(
+fun animatedBlockPlacement(x: Dp, y: Dp, width: Dp, height: Dp): BlockPlacement {
-    xFraction: Float,
+    val spec: FiniteAnimationSpec<Dp> = if (rememberReduceMotion() ||
-    widthFraction: Float,
+        LocalTimelineZoom.current.isPinching
-    y: Dp,
+    ) {
-    height: Dp,
+        snap()
-    landing: Boolean = false,
+    } else {
-): BlockPlacement {
+        MaterialTheme.motionScheme.fastSpatialSpec()
-    val still = rememberReduceMotion() || LocalTimelineZoom.current.isPinching
-    val dpSpec: FiniteAnimationSpec<Dp> = when {
-        still -> snap()
-        landing -> MaterialTheme.motionScheme.fastEffectsSpec()
-        else -> MaterialTheme.motionScheme.fastSpatialSpec()
-    }
-    val shareSpec: FiniteAnimationSpec<Float> = if (still) snap() else MaterialTheme.motionScheme.fastSpatialSpec()
-    val animatedX by animateFloatAsState(xFraction, shareSpec, label = "block-x")
-    val animatedWidth by animateFloatAsState(widthFraction, shareSpec, label = "block-width")
-    val animatedY by animateDpAsState(y, dpSpec, label = "block-y")
-    val animatedHeight by animateDpAsState(height, dpSpec, label = "block-height")
-    return BlockPlacement(animatedX, animatedWidth, animatedY, animatedHeight)
-}
-
-/** Seats a block across its [placement]'s share of a [LaneColumn]. */
-fun Modifier.laneSlot(placement: BlockPlacement): Modifier =
-    then(LaneSlot(placement.xFraction, placement.widthFraction))
-
-private data class LaneSlot(val x: Float, val width: Float) : ParentDataModifier {
-    override fun Density.modifyParentData(parentData: Any?): Any = this@LaneSlot
-}
-
-/**
- * A day column's blocks, each measured across the share of the column its
- * [laneSlot] gives it; anything else fills the column. The shares are applied
- * at layout time, so the column can change width every frame without its
- * blocks recomposing.
- */
-@Composable
-fun LaneColumn(modifier: Modifier = Modifier, content: @Composable () -> Unit) {
-    Layout(content = content, modifier = modifier) { measurables, constraints ->
-        val width = constraints.maxWidth
-        val loose = constraints.copy(minWidth = 0, minHeight = 0)
-        val placed = measurables.map { measurable ->
-            val slot = measurable.parentData as? LaneSlot
-            if (slot == null) {
-                measurable.measure(loose) to 0
-            } else {
-                val left = (slot.x * width).roundToInt()
-                val right = ((slot.x + slot.width) * width).roundToInt()
-                val laneWidth = (right - left).coerceAtLeast(0)
-                measurable.measure(loose.copy(minWidth = laneWidth, maxWidth = laneWidth)) to left
-            }
-        }
-        layout(width, constraints.maxHeight) {
-            placed.forEach { (placeable, x) -> placeable.placeRelative(x, 0) }
-        }
     }
+    val animatedX by animateDpAsState(x, spec, label = "block-x")
+    val animatedY by animateDpAsState(y, spec, label = "block-y")
+    val animatedWidth by animateDpAsState(width, spec, label = "block-width")
+    val animatedHeight by animateDpAsState(height, spec, label = "block-height")
+    return BlockPlacement(animatedX, animatedY, animatedWidth, animatedHeight)
 }

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

@@ -1,294 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.animation.AnimatedContent
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.slideInVertically
-import androidx.compose.animation.slideOutVertically
-import androidx.compose.animation.togetherWith
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.animation.scaleIn
-import androidx.compose.animation.scaleOut
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Menu
-import androidx.compose.material.icons.filled.Search
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.TopAppBar
-import androidx.compose.material3.TopAppBarDefaults
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.setValue
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberUpdatedState
-import androidx.compose.runtime.Immutable
-import androidx.compose.runtime.SideEffect
-import androidx.compose.runtime.Stable
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.staticCompositionLocalOf
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.calendula.domain.EventInstance
-import kotlinx.datetime.LocalDate
-
-/**
- * What a calendar screen shows in the top bar, the FAB and the drawer, which the
- * host draws once for all of them (#184): switching screens changes what they
- * say rather than swapping one bar for another.
- *
- * @param titleDate the date the title's picker opens on, or null for a title
- *   that is only a label.
- * @param drawerDate the date the drawer's picker opens on.
- * @param awayFromToday whether "today" is worth offering.
- */
-@Immutable
-data class ScreenChrome(
-    val title: String,
-    val shortTitle: String = title,
-    val titleDate: LocalDate?,
-    val drawerDate: LocalDate,
-    val awayFromToday: Boolean,
-    val todayText: String,
-)
-
-/** What the chrome does for the screen on show; read when used, so not observed. */
-class ScreenActions(
-    val onToday: () -> Unit,
-    val onJumpToDate: (LocalDate) -> Unit,
-    val onCreate: () -> Unit,
-)
-
-/**
- * An event a long press left selected (#141), which the host answers with the
- * action bar in place of the FAB. [dismiss] clears it on the screen that owns it.
- * [create] is set for a block drafted on an empty slot (#153), which has no
- * event yet, so the bar offers to create one.
- */
-@Stable
-class EventSelection(
-    val event: EventInstance,
-    val dismiss: () -> Unit,
-    val create: (() -> Unit)? = null,
-    /** The event at the times an ongoing move or resize would give it, else null. */
-    val preview: () -> EventInstance? = { null },
-)
-
-/** The screen on show's [ScreenChrome] and [ScreenActions], for the host to draw. */
-@Stable
-class ChromeHost {
-    var chrome by mutableStateOf<ScreenChrome?>(null)
-        private set
-
-    var selection by mutableStateOf<EventSelection?>(null)
-        internal set
-
-    /** Whether the selected event is being dragged or resized right now. */
-    var selectionBusy by mutableStateOf(false)
-        internal set
-
-    /** Whether the bar would cover the selected event, and so draws compact. */
-    var selectionCompact by mutableStateOf(false)
-        internal set
-
-
-    var actions: ScreenActions? = null
-        private set
-
-    internal fun publish(chrome: ScreenChrome, actions: ScreenActions) {
-        this.chrome = chrome
-        this.actions = actions
-    }
-}
-
-/** The host's chrome, and whether the screen reading it is the one on show rather than one leaving. */
-class ChromeSlot(val host: ChromeHost, val current: Boolean)
-
-val LocalChromeSlot = staticCompositionLocalOf<ChromeSlot?> { null }
-
-/** Hands [chrome] and [actions] to the host, while this screen is the one on show. */
-@Composable
-fun PublishChrome(chrome: ScreenChrome, actions: ScreenActions) {
-    val slot = LocalChromeSlot.current ?: return
-    if (slot.current) SideEffect { slot.host.publish(chrome, actions) }
-}
-
-/** Hands the screen's selected [event] to the host, for as long as it stays selected. */
-@Composable
-fun PublishSelection(
-    event: EventInstance?,
-    busy: Boolean,
-    compact: Boolean,
-    onDismiss: () -> Unit,
-    onCreate: (() -> Unit)? = null,
-    preview: () -> EventInstance? = { null },
-) {
-    val slot = LocalChromeSlot.current ?: return
-    val currentDismiss by rememberUpdatedState(onDismiss)
-    val currentCreate by rememberUpdatedState(onCreate)
-    val currentPreview by rememberUpdatedState(preview)
-    val drafted = onCreate != null
-    val selection = remember(event, drafted) {
-        event?.let {
-            EventSelection(
-                event = it,
-                dismiss = { currentDismiss() },
-                create = if (drafted) ({ currentCreate?.invoke() }) else null,
-                preview = { currentPreview() },
-            )
-        }
-    }
-    val host = slot.host
-    val current = slot.current
-    DisposableEffect(host, selection, current) {
-        if (current) host.selection = selection
-        onDispose {
-            if (host.selection === selection) host.selection = null
-            // Left mid-drag, nothing else would clear these for the other views.
-            host.selectionBusy = false
-            host.selectionCompact = false
-        }
-    }
-    if (current) {
-        SideEffect {
-            host.selectionBusy = busy && selection != null
-            host.selectionCompact = compact && selection != null
-        }
-    }
-}
-
-/**
- * The top bar every calendar screen shares — or, while an event is selected,
- * the selection's own bar in its place (#141).
- */
-@Composable
-fun CalendarTopBar(
-    host: ChromeHost,
-    selectedView: CalendarView,
-    quickSwitchViews: List<CalendarView>,
-    onCycleView: () -> Unit,
-    onOpenDrawer: () -> Unit,
-    onOpenSearch: () -> Unit,
-    showTodayButton: Boolean,
-) {
-    val effects = MaterialTheme.motionScheme.fastEffectsSpec<Float>()
-    AnimatedContent(
-        targetState = host.selection,
-        contentKey = { it != null },
-        transitionSpec = {
-            (fadeIn(effects) + slideInVertically { -it / 4 })
-                .togetherWith(fadeOut(effects) + slideOutVertically { -it / 4 })
-        },
-        label = "top-bar",
-    ) { selection ->
-        if (selection != null) {
-            SelectionTopBar(selection)
-        } else {
-            ViewTopBar(
-                host = host,
-                selectedView = selectedView,
-                quickSwitchViews = quickSwitchViews,
-                onCycleView = onCycleView,
-                onOpenDrawer = onOpenDrawer,
-                onOpenSearch = onOpenSearch,
-                showTodayButton = showTodayButton,
-            )
-        }
-    }
-}
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-private fun ViewTopBar(
-    host: ChromeHost,
-    selectedView: CalendarView,
-    quickSwitchViews: List<CalendarView>,
-    onCycleView: () -> Unit,
-    onOpenDrawer: () -> Unit,
-    onOpenSearch: () -> Unit,
-    showTodayButton: Boolean,
-) {
-    val chrome = host.chrome
-    TopAppBar(
-        title = {
-            if (chrome != null) {
-                CalendarTitleButton(
-                    title = chrome.title,
-                    currentDate = chrome.titleDate,
-                    onJumpToDate = { host.actions?.onJumpToDate?.invoke(it) },
-                    shortTitle = chrome.shortTitle,
-                )
-            }
-        },
-        navigationIcon = {
-            IconButton(onClick = onOpenDrawer) {
-                Icon(
-                    imageVector = Icons.Default.Menu,
-                    contentDescription = stringResource(R.string.month_open_menu),
-                )
-            }
-        },
-        actions = {
-            TodayAction(show = showTodayButton, onToday = { host.actions?.onToday?.invoke() })
-            IconButton(onClick = onOpenSearch) {
-                Icon(
-                    imageVector = Icons.Default.Search,
-                    contentDescription = stringResource(R.string.search_action),
-                )
-            }
-            ViewSwitcherPill(
-                current = selectedView,
-                cycle = quickSwitchViews,
-                onCycle = onCycleView,
-            )
-        },
-        // Deliberately flat: M3 lifts the bar to mark content scrolling under
-        // it, but here the bar meets the header on the same surface and the
-        // tint is what makes that seam look like a separate block (#186).
-        colors = TopAppBarDefaults.topAppBarColors(
-            containerColor = MaterialTheme.colorScheme.surface,
-            scrolledContainerColor = MaterialTheme.colorScheme.surface,
-        ),
-    )
-}
-
-/**
- * The FAB column every calendar screen shares. While an event is selected the
- * FAB is [selection]'s toggle instead, and it steps aside mid-gesture.
- */
-@Composable
-fun CalendarFab(host: ChromeHost, todayInToolbar: Boolean, selection: FabSelection? = null) {
-    val chrome = host.chrome ?: return
-    AnimatedVisibility(
-        visible = !host.selectionBusy,
-        enter = scaleIn(MaterialTheme.motionScheme.fastSpatialSpec()) + fadeIn(),
-        exit = scaleOut(MaterialTheme.motionScheme.fastSpatialSpec()) + fadeOut(),
-    ) {
-        CalendarFabColumn(
-            todayVisible = chrome.awayFromToday && !todayInToolbar,
-            todayText = chrome.todayText,
-            onToday = { host.actions?.onToday?.invoke() },
-            onCreate = { host.actions?.onCreate?.invoke() },
-            selection = selection,
-        )
-    }
-}
-
-/**
- * A calendar screen's body under the shared chrome, on the ground the screen's
- * own Scaffold used to give it; the host's Scaffold has already made room for
- * the bars, so [content] gets no padding of its own.
- */
-@Composable
-fun ScreenBody(modifier: Modifier = Modifier, content: @Composable (PaddingValues) -> Unit) {
-    Box(modifier.fillMaxSize().background(MaterialTheme.colorScheme.background)) {
-        content(PaddingValues())
-    }
-}

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

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

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

@@ -91,7 +91,7 @@ fun CalendarDrawer(
             DrawerSectionHeader(stringResource(R.string.view_section))
             viewOrder.forEachIndexed { index, view ->
                 GroupedRow(
-                    title = view.label(),
+                    title = stringResource(view.labelRes),
                     position = positionOf(index, viewOrder.size),
                     selected = view == currentView,
                     minHeight = 56.dp,

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

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

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

@@ -1,40 +1,17 @@
 package de.jeanlucmakiola.calendula.ui.common
 
-import android.content.Context
-import android.content.Intent
-import android.provider.CalendarContract
-import android.provider.Settings
-import androidx.annotation.StringRes
-import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.widthIn
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.CalendarMonth
-import androidx.compose.material.icons.outlined.EditOff
-import androidx.compose.material.icons.outlined.ErrorOutline
-import androidx.compose.material.icons.outlined.EventBusy
-import androidx.compose.material.icons.outlined.Lock
-import androidx.compose.material.icons.outlined.SyncProblem
-import androidx.compose.material.icons.outlined.VisibilityOff
 import androidx.compose.material3.FilledTonalButton
-import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.compositionLocalOf
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
@@ -43,168 +20,37 @@ import de.jeanlucmakiola.calendula.domain.FailureReason
 
 /**
  * Full-screen failure state shared by every calendar screen (spec §7).
- * A tonal icon, one headline, one supporting line and one recovery action —
+ * One explanation line + one recovery action, never a toast.
- * never a toast.
  */
 @Composable
-fun CalendarFailure(
+fun CalendarFailure(reason: FailureReason, onRetry: () -> Unit) {
-    reason: FailureReason,
+    val titleRes = when (reason) {
-    onRetry: () -> Unit,
+        FailureReason.PermissionRevoked -> R.string.state_failure_permission
-    modifier: Modifier = Modifier,
+        FailureReason.NoCalendarsConfigured -> R.string.state_failure_no_calendars
-) {
+        FailureReason.ProviderUnavailable -> R.string.state_failure_provider
-    val context = LocalContext.current
+        FailureReason.Unknown,
-    val manageCalendars = LocalManageCalendars.current
+        FailureReason.EventNotFound -> R.string.state_failure_unknown
-    val copy = failureCopy(reason)
+    }
-    val onAction: () -> Unit = when (reason) {
+    val actionRes = when (reason) {
-        FailureReason.NoCalendarsConfigured -> {
+        FailureReason.NoCalendarsConfigured -> R.string.state_failure_no_calendars_action
-            { context.startCalendarSetup() }
+        FailureReason.PermissionRevoked -> R.string.state_failure_permission_action
-        }
+        else -> R.string.state_retry
-        FailureReason.AllCalendarsHidden,
-        FailureReason.NoImportTarget,
-        -> manageCalendars ?: onRetry
-        else -> onRetry
     }
     Column(
-        modifier = modifier
+        modifier = Modifier
             .fillMaxSize()
-            .padding(horizontal = 32.dp, vertical = 24.dp),
+            .padding(32.dp),
         verticalArrangement = Arrangement.Center,
         horizontalAlignment = Alignment.CenterHorizontally,
     ) {
-        FailureIcon(icon = copy.icon, isError = copy.isError)
-        Spacer(Modifier.height(24.dp))
         Text(
-            text = stringResource(copy.title),
+            text = stringResource(titleRes),
             style = MaterialTheme.typography.headlineSmall,
             textAlign = TextAlign.Center,
-            modifier = Modifier.widthIn(max = TEXT_MAX_WIDTH),
         )
-        copy.body?.let { body ->
+        Spacer(Modifier.height(24.dp))
-            Spacer(Modifier.height(12.dp))
+        FilledTonalButton(onClick = onRetry) {
-            Text(
+            Text(stringResource(actionRes))
-                text = stringResource(body),
-                style = MaterialTheme.typography.bodyMedium,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                textAlign = TextAlign.Center,
-                modifier = Modifier.widthIn(max = TEXT_MAX_WIDTH),
-            )
-        }
-        Spacer(Modifier.height(32.dp))
-        FilledTonalButton(onClick = onAction) {
-            Text(stringResource(copy.action))
         }
     }
 }
-
-/** The state's mark: the reason's icon in a tonal circle above the headline. */
-@Composable
-private fun FailureIcon(icon: ImageVector, isError: Boolean) {
-    val container: Color
-    val content: Color
-    if (isError) {
-        container = MaterialTheme.colorScheme.errorContainer
-        content = MaterialTheme.colorScheme.onErrorContainer
-    } else {
-        container = MaterialTheme.colorScheme.secondaryContainer
-        content = MaterialTheme.colorScheme.onSecondaryContainer
-    }
-    Box(
-        modifier = Modifier
-            .size(72.dp)
-            .background(container, CircleShape),
-        contentAlignment = Alignment.Center,
-    ) {
-        Icon(
-            imageVector = icon,
-            contentDescription = null,
-            tint = content,
-            modifier = Modifier.size(36.dp),
-        )
-    }
-}
-
-/**
- * What a reason says and offers. Headline and supporting line are separate so
- * the explanation reads as body text instead of a headline that runs over three
- * lines; [isError] tints the mark for the two reasons that are an actual fault
- * rather than a calendar the user can switch back on.
- */
-private data class FailureCopy(
-    val icon: ImageVector,
-    @StringRes val title: Int,
-    @StringRes val body: Int?,
-    @StringRes val action: Int,
-    val isError: Boolean = false,
-)
-
-private fun failureCopy(reason: FailureReason): FailureCopy = when (reason) {
-    FailureReason.PermissionRevoked -> FailureCopy(
-        icon = Icons.Outlined.Lock,
-        title = R.string.state_failure_permission,
-        body = R.string.state_failure_permission_body,
-        action = R.string.state_failure_permission_action,
-    )
-    FailureReason.NoCalendarsConfigured -> FailureCopy(
-        icon = Icons.Outlined.CalendarMonth,
-        title = R.string.state_failure_no_calendars,
-        body = R.string.state_failure_no_calendars_body,
-        action = R.string.state_failure_no_calendars_action,
-    )
-    FailureReason.AllCalendarsHidden -> FailureCopy(
-        icon = Icons.Outlined.VisibilityOff,
-        title = R.string.state_failure_all_hidden,
-        body = R.string.state_failure_all_hidden_body,
-        action = R.string.state_failure_all_hidden_action,
-    )
-    FailureReason.NoImportTarget -> FailureCopy(
-        icon = Icons.Outlined.EditOff,
-        title = R.string.state_failure_no_import_target,
-        body = R.string.state_failure_no_import_target_body,
-        action = R.string.state_failure_all_hidden_action,
-    )
-    FailureReason.EventNotFound -> FailureCopy(
-        icon = Icons.Outlined.EventBusy,
-        title = R.string.state_failure_event_not_found,
-        body = R.string.state_failure_event_not_found_body,
-        action = R.string.state_retry,
-    )
-    FailureReason.ProviderUnavailable -> FailureCopy(
-        icon = Icons.Outlined.SyncProblem,
-        title = R.string.state_failure_provider,
-        body = R.string.state_failure_provider_body,
-        action = R.string.state_retry,
-        isError = true,
-    )
-    FailureReason.Unknown -> FailureCopy(
-        icon = Icons.Outlined.ErrorOutline,
-        title = R.string.state_failure_unknown,
-        body = null,
-        action = R.string.state_retry,
-        isError = true,
-    )
-}
-
-/** Keeps the headline and its supporting line at a readable measure. */
-private val TEXT_MAX_WIDTH = 320.dp
-
-/**
- * Opens Settings → Calendars, the only screen that can switch a calendar back
- * on. Null outside the calendar host — screens without it never raise the
- * reason that needs it, and fall back to their own retry.
- */
-val LocalManageCalendars = compositionLocalOf<(() -> Unit)?> { null }
-
-/**
- * Open the system screen for putting a calendar on the device: the account
- * chooser filtered to calendar providers, falling back to account settings
- * where no chooser resolves. Both are system components, so nothing here needs
- * a `<queries>` entry.
- */
-private fun Context.startCalendarSetup() {
-    val intents = listOf(
-        Intent(Settings.ACTION_ADD_ACCOUNT)
-            .putExtra(Settings.EXTRA_AUTHORITIES, arrayOf(CalendarContract.AUTHORITY)),
-        Intent(Settings.ACTION_SYNC_SETTINGS),
-    )
-    intents.firstOrNull { runCatching { startActivity(it) }.isSuccess }
-}

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

@@ -1,57 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.FiniteAnimationSpec
-import androidx.compose.animation.core.VectorConverter
-import androidx.compose.foundation.pager.PagerState
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberUpdatedState
-import androidx.compose.runtime.snapshotFlow
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.lerp
-import kotlinx.coroutines.flow.collectLatest
-import kotlin.math.floor
-
-/**
- * One height for every page of something that varies from page to page — the
- * timelines' all-day strip, the split grid's rows — blended between the two
- * pages a swipe sits between, so what sits below it moves with the finger rather
- * than jumping on settle. It follows the swipe directly and only springs when a
- * page's own height changes at rest. [fallback] stands in until the pages have
- * reported theirs, so it doesn't open from zero.
- *
- * @param heights each composed page's own height, by page index.
- */
-@Composable
-fun pagedHeight(pagerState: PagerState, heights: Map<Int, Dp>, fallback: Dp): Dp {
-    val currentFallback by rememberUpdatedState(fallback)
-    val target by remember(pagerState, heights) {
-        derivedStateOf {
-            val position = pagerState.currentPage + pagerState.currentPageOffsetFraction
-            val from = floor(position).toInt()
-            val a = heights[from]
-            val b = heights[from + 1]
-            lerp(a ?: b ?: currentFallback, b ?: a ?: currentFallback, position - from)
-        }
-    }
-    val height = remember { Animatable(target, Dp.VectorConverter) }
-    LaunchedEffect(height) {
-        snapshotFlow { target to pagerState.isScrollInProgress }.collectLatest { (h, scrolling) ->
-            if (scrolling) height.snapTo(h) else height.animateTo(h)
-        }
-    }
-    return height.value
-}
-
-/** A deliberate jump (Today, jump-to-date): animated, or snapped under reduced motion. */
-suspend fun PagerState.jumpToPage(
-    page: Int,
-    reduceMotion: Boolean,
-    spec: FiniteAnimationSpec<Float>,
-) {
-    if (reduceMotion) scrollToPage(page) else animateScrollToPage(page, animationSpec = spec)
-}

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

@@ -34,6 +34,7 @@ import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.floret.components.GroupedRow
 import de.jeanlucmakiola.floret.components.Position
+import de.jeanlucmakiola.floret.components.SelectedCheck
 
 /**
  * The app's single "which calendar" selection list, shared by the event editor
@@ -113,11 +114,17 @@ private fun CalendarPickerGroup(
         leading = leading,
     )
     calendars.forEachIndexed { index, calendar ->
+        val isSelected = calendar.id == selectedId
         GroupedRow(
-            title = calendar.displayName.orUnnamed(),
+            title = calendar.displayName,
             position = if (index == calendars.lastIndex) Position.Bottom else Position.Middle,
-            checked = calendar.id == selectedId,
+            selected = isSelected,
             leading = { CalendarColorChip(calendar.color) },
+            trailing = if (isSelected) {
+                { SelectedCheck() }
+            } else {
+                null
+            },
             onClick = { onSelect(calendar.id) },
         )
     }

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

@@ -0,0 +1,79 @@
+package de.jeanlucmakiola.calendula.ui.common
+
+import androidx.compose.foundation.gestures.detectHorizontalDragGestures
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.dp
+
+/**
+ * Drag distance that turns a calendar page, shared by the month, week and day
+ * views so all three answer a swipe at the same point.
+ *
+ * It was 6dp once, which is inside the distance a tap wanders: brushing the grid
+ * changed the month, and a page that turns on an unintended gesture reads as the
+ * animation misfiring rather than as the gesture being over-eager.
+ */
+val CALENDAR_SWIPE_THRESHOLD = 24.dp
+
+/**
+ * The whole-page horizontal swipe: one page per gesture, committed **the moment
+ * the drag clears [CALENDAR_SWIPE_THRESHOLD]** rather than when the finger lifts.
+ *
+ * Waiting for the lift meant the page sat still under a finger that had already
+ * travelled far enough to ask for it, and the answer only arrived once you let
+ * go — which reads as the view being slow rather than as a deliberate commit.
+ * Firing on the threshold is what makes the gesture feel like it is being
+ * followed. The trade is that a drag can no longer be taken back by dragging the
+ * other way; in practice, once you have moved 24dp deliberately you meant it, and
+ * the page you land on is one swipe back.
+ *
+ * Deliberately **horizontal-only**. The week and day timelines scroll vertically
+ * underneath this, and a two-dimensional detector here would claim those drags
+ * before the inner scroll ever saw them. As it is, a horizontal drag crosses this
+ * detector's slop while a vertical one is consumed below, and the two coexist.
+ * (The month view's split style needs a vertical axis as well, so it keeps its
+ * own axis-locking detector rather than using this.)
+ */
+@Composable
+fun rememberCalendarPageSwipe(
+    onSwipeNext: () -> Unit,
+    onSwipePrev: () -> Unit,
+): Modifier {
+    val threshold = with(LocalDensity.current) { CALENDAR_SWIPE_THRESHOLD.toPx() }
+    return Modifier.pointerInput(onSwipeNext, onSwipePrev) {
+        var accum = 0f
+        // One page per gesture: without this a long drag would keep re-firing
+        // every time the accumulator crossed the threshold again.
+        var fired = false
+        detectHorizontalDragGestures(
+            onDragStart = {
+                accum = 0f
+                fired = false
+            },
+            onDragEnd = {
+                accum = 0f
+                fired = false
+            },
+            onDragCancel = {
+                accum = 0f
+                fired = false
+            },
+            onHorizontalDrag = { _, drag ->
+                accum += drag
+                if (!fired) {
+                    val commit = when {
+                        accum < -threshold -> onSwipeNext
+                        accum > threshold -> onSwipePrev
+                        else -> null
+                    }
+                    if (commit != null) {
+                        fired = true
+                        commit()
+                    }
+                }
+            },
+        )
+    }
+}

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

@@ -1,63 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.common
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.rememberTextMeasurer
-import androidx.compose.ui.text.style.LineHeightStyle
-import androidx.compose.ui.unit.Dp
-import de.jeanlucmakiola.calendula.R
-
-/**
- * The calendar surfaces' line-height treatment. Material wraps an 11sp glyph in
- * a 16sp line box — room a label wants when it stands on its own, and close to
- * a fifth of an event row when it doesn't. The outer edges only, so a wrapped
- * title keeps its interior line spacing (#190).
- *
- * Trimmed rather than set to a smaller line height: the font picker can load a
- * serif, a monospace or a file of the user's own, and a line height under a
- * face's own ascent and descent overlaps its lines. There is nothing to trim
- * below that, so this is safe whatever font is chosen.
- */
-private val TrimmedLines = LineHeightStyle(
-    alignment = LineHeightStyle.Alignment.Center,
-    trim = LineHeightStyle.Trim.Both,
-)
-
-/** Ascenders and descenders both, so a line is measured at its full extent. */
-private const val LINE_SAMPLE = "Ag"
-
-/** [this] with Material's outer leading trimmed — see [TrimmedLines]. */
-fun TextStyle.trimmedLines(): TextStyle = copy(lineHeightStyle = TrimmedLines)
-
-/**
- * [style] with its wrapped lines packed onto the face's own extent instead of
- * Material's line box.
- *
- * [trimmedLines] takes the leading off the outer edges of a run of text; this
- * takes it from between the lines as well, which is the half a wrapped event
- * title pays for twice over. The line height is *measured* from the font rather
- * than picked, so it lands exactly on the face's ascent-plus-descent and can
- * never be short enough to overlap — whatever the font picker has loaded (#190).
- */
-@Composable
-fun rememberPackedLines(style: TextStyle): TextStyle {
-    val line = rememberTrimmedLineHeight(style)
-    return with(LocalDensity.current) { style.trimmedLines().copy(lineHeight = line.toSp()) }
-}
-
-/** What one trimmed line of [style] actually draws in. */
-@Composable
-fun rememberTrimmedLineHeight(style: TextStyle): Dp {
-    val measurer = rememberTextMeasurer()
-    val density = LocalDensity.current
-    return remember(style, density, measurer) {
-        with(density) { measurer.measure(LINE_SAMPLE, style.trimmedLines()).size.height.toDp() }
-    }
-}
-
-/** A calendar or account name, or the "unnamed" label when it is blank. */
-@Composable
-fun String.orUnnamed(): String = ifBlank { stringResource(R.string.calendar_unnamed) }