fix(edit): curate the CalDAV colour picker in painted space (#22 )

The picker paints every swatch through pastelize, which pins lightness to a constant and caps saturation — so the raw palette's lightness axis is invisible on screen. Curating in raw space (as the first pass did) left near-identical painted swatches (navy/blue/midnightblue all paint as one mid blue) and stranded every neutral as an identical pale tint in a run of "pinks" at the end of the grid. Move dedup, thinning, and ordering into the painted (pastelised) space the user actually sees: colours that paint identically collapse to one, oversized palettes drop washed-out neutral-origin tints (painted chroma below a floor) and thin by CIE76 ΔE in painted Lab, and the survivors sort continuously by painted hue with the wheel cut at its widest gap. The CSS3 147-colour dump now lands at ~33 distinct, rainbow-ordered swatches with no neutrals stranded at the end. The hue/saturation shaping moves into a shared domain pastelArgb() so the picker paints exactly what curation reasons about; ui/pastelize wraps it and only picks the theme's brightness. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
docs(changelog): note curated CalDAV colour picker (#22 )
2026-07-03 15:29:46 +02:00 · 2026-07-02 10:37:34 +02:00 · 2026-07-02 10:36:50 +02:00
25 changed files with 429 additions and 854 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -24,6 +24,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  suggestions ([#18], [#20]).

 ### Fixed
+- A tidy colour picker on CalDAV calendars. For calendars synced by a CalDAV
+  app (such as DAVx5), the event colour picker showed every colour the account
+  publishes — nearly 150 swatches in alphabetical order, many of them
+  duplicates or near-identical shades. The picker now shows only visually
+  distinct colours, arranged as a rainbow; near-duplicate shades and the
+  washed-out neutrals are folded away so no two swatches look alike. Picked
+  colours still sync exactly as before, and calendars with hand-picked
+  palettes (like Google's) are unaffected. Thanks to @ptab for the report
+  ([#22]).
 - Month widget arrows and "today" button work again. On release builds the
  prev/next-month arrows and the jump-to-today control on the month widget did
  nothing when tapped — code shrinking had stripped the tap handlers behind
@@ -768,3 +777,4 @@ automatically, with zero telemetry and no internet permission.
 [#17]: https://codeberg.org/jlmakiola/calendula/issues/17
 [#18]: https://codeberg.org/jlmakiola/calendula/issues/18
 [#20]: https://codeberg.org/jlmakiola/calendula/issues/20
+[#22]: https://codeberg.org/jlmakiola/calendula/issues/22
--- a/app/src/main/java/de/jeanlucmakiola/calendula/MainActivity.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/MainActivity.kt
@@ -34,11 +34,8 @@ import de.jeanlucmakiola.calendula.ui.common.DebugRibbon
 import de.jeanlucmakiola.calendula.ui.crash.CrashReportActivity
 import de.jeanlucmakiola.calendula.ui.crash.CrashReportDialog
 import de.jeanlucmakiola.calendula.ui.crash.submitCrashReport
-import de.jeanlucmakiola.calendula.domain.FontRole
 import de.jeanlucmakiola.calendula.ui.settings.SettingsViewModel
 import de.jeanlucmakiola.calendula.ui.theme.CalendulaTheme
-import de.jeanlucmakiola.calendula.ui.theme.calendulaTypography
-import de.jeanlucmakiola.calendula.ui.theme.resolveFontFamily
 import kotlinx.datetime.LocalDate
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.toLocalDateTime
@@ -102,20 +99,9 @@ class MainActivity : AppCompatActivity() {
            val use24Hour = remember(settings.timeFormat, context) {
                settings.timeFormat.is24Hour(android.text.format.DateFormat.is24HourFormat(context))
            }
-            // The user's custom-font choice, resolved to a Material typography
-            // (issue #19). Recomputed only when a token changes; "system for both"
-            // returns the default scale untouched.
-            val fonts by settingsViewModel.fontState.collectAsStateWithLifecycle()
-            val typography = remember(fonts, context) {
-                calendulaTypography(
-                    brand = resolveFontFamily(fonts.brand, FontRole.BRAND, context),
-                    plain = resolveFontFamily(fonts.plain, FontRole.PLAIN, context),
-                )
-            }
            CalendulaTheme(
                darkTheme = darkTheme,
                dynamicColor = settings.dynamicColor,
-                typography = typography,
            ) {
                Box(modifier = Modifier.fillMaxSize()) {
                    CompositionLocalProvider(
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarDataSource.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/calendar/CalendarDataSource.kt
@@ -20,6 +20,7 @@ import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventAttendee
 import de.jeanlucmakiola.calendula.domain.EventColorOption
 import de.jeanlucmakiola.calendula.domain.EventDetail
+import de.jeanlucmakiola.calendula.domain.curatedForPicker
 import de.jeanlucmakiola.calendula.domain.EventForm
 import de.jeanlucmakiola.calendula.domain.EventInstance
 import de.jeanlucmakiola.calendula.domain.EventStatus
@@ -57,7 +58,10 @@ interface CalendarDataSource {

    /**
     * The event-colour palette the calendar's account publishes
-     * (`CalendarContract.Colors`, `TYPE_EVENT`), sorted by key. Empty when the
+     * (`CalendarContract.Colors`, `TYPE_EVENT`), curated for display — deduped,
+     * thinned to visually distinct swatches when oversized (CalDAV adapters
+     * publish all ~147 CSS3 names, #22) and hue-sorted; see
+     * [curatedForPicker]. Empty when the
     * account exposes no palette (most local calendars, some CalDAV) — the
     * signal that a custom colour can only be written as a raw `EVENT_COLOR`,
     * which a synced calendar may drop on its next sync.
@@ -420,7 +424,7 @@ class AndroidCalendarDataSource @Inject constructor(
            c.mapAll { EventColorOption(key = it.getString(0).orEmpty(), argb = it.getInt(1)) }
        }
            ?.filter { it.key.isNotEmpty() }
-            ?.sortedBy { it.key }
+            ?.curatedForPicker()
            ?: emptyList()
    }

--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/fonts/CustomFontStore.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/fonts/CustomFontStore.kt
@@ -1,57 +0,0 @@
-package de.jeanlucmakiola.calendula.data.fonts
-
-import android.content.Context
-import android.net.Uri
-import de.jeanlucmakiola.calendula.domain.FontRole
-import java.io.File
-import java.util.Locale
-import android.graphics.fonts.Font as PlatformFont
-
-/**
- * Storage for user-loaded custom fonts (issue #19). A font a user picks via the
- * system file picker is copied into the app's private storage — one file per
- * [FontRole] — so the selection survives even if the original is later moved or
- * deleted, and never leaves the app. The chosen file is validated as a real font
- * before it replaces the previous one, so a bad pick can't wedge the app-wide
- * typography.
- */
-object CustomFontStore {
-
-    private fun dir(context: Context): File = File(context.filesDir, "fonts")
-
-    /** The stored font file for [role] (may not exist yet). */
-    fun file(context: Context, role: FontRole): File =
-        File(dir(context), "${role.name.lowercase(Locale.ROOT)}.ttf")
-
-    fun exists(context: Context, role: FontRole): Boolean =
-        file(context, role).let { it.exists() && it.length() > 0 }
-
-    /**
-     * Copy [uri] into per-role storage, first validating that it parses as a
-     * font. Returns true on success; on any failure the previous file is left
-     * untouched and false is returned (the caller keeps the old selection).
-     */
-    fun import(context: Context, role: FontRole, uri: Uri): Boolean {
-        val target = file(context, role)
-        target.parentFile?.mkdirs()
-        val tmp = File(target.parentFile, "${role.name.lowercase(Locale.ROOT)}.tmp")
-        return try {
-            context.contentResolver.openInputStream(uri)?.use { input ->
-                tmp.outputStream().use { output -> input.copyTo(output) }
-            } ?: return false
-            // Font.Builder throws IOException for anything that isn't a valid
-            // font file (API 29+, which is our minSdk) — a cheap, reliable check.
-            PlatformFont.Builder(tmp).build()
-            if (target.exists() && !target.delete()) return false
-            tmp.renameTo(target)
-        } catch (_: Exception) {
-            tmp.delete()
-            false
-        }
-    }
-
-    /** Forget the custom font for [role] (used when switching away from it). */
-    fun clear(context: Context, role: FontRole) {
-        file(context, role).delete()
-    }
-}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefs.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/data/prefs/SettingsPrefs.kt
@@ -14,7 +14,6 @@ import de.jeanlucmakiola.calendula.ui.agenda.storageValue
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.IMPLEMENTED_VIEWS
 import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
-import de.jeanlucmakiola.calendula.ui.theme.FONT_SYSTEM_TOKEN
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 import kotlinx.datetime.DayOfWeek
@@ -107,27 +106,6 @@ class SettingsPrefs @Inject constructor(
        store.edit { it[DYNAMIC_COLOR_KEY] = enabled }
    }

-    /**
-     * Custom-font tokens per Material typeface role (issue #19). Stored as opaque
-     * strings — "system", "custom", or a bundled font's token — resolved to a
-     * FontFamily at the theme layer; an unknown token degrades to the default.
-     */
-    val brandFont: Flow<String> = store.data.map { prefs ->
-        prefs[BRAND_FONT_KEY] ?: FONT_SYSTEM_TOKEN
-    }
-
-    val plainFont: Flow<String> = store.data.map { prefs ->
-        prefs[PLAIN_FONT_KEY] ?: FONT_SYSTEM_TOKEN
-    }
-
-    suspend fun setBrandFont(token: String) {
-        store.edit { it[BRAND_FONT_KEY] = token }
-    }
-
-    suspend fun setPlainFont(token: String) {
-        store.edit { it[PLAIN_FONT_KEY] = token }
-    }
-
    suspend fun setWeekStart(pref: WeekStartPref) {
        store.edit { it[WEEK_START_KEY] = pref.storageValue() }
    }
@@ -523,8 +501,6 @@ class SettingsPrefs @Inject constructor(
    companion object {
        internal val THEME_MODE_KEY = stringPreferencesKey("theme_mode")
        internal val DYNAMIC_COLOR_KEY = booleanPreferencesKey("dynamic_color")
-        internal val BRAND_FONT_KEY = stringPreferencesKey("brand_font")
-        internal val PLAIN_FONT_KEY = stringPreferencesKey("plain_font")
        internal val WEEK_START_KEY = stringPreferencesKey("week_start")
        internal val AGENDA_SCREEN_RANGE_KEY = stringPreferencesKey("agenda_screen_range")
        internal val AGENDA_WIDGET_RANGE_KEY = stringPreferencesKey("agenda_widget_range")
--- a/app/src/main/java/de/jeanlucmakiola/calendula/domain/EventColorPalette.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/domain/EventColorPalette.kt
@@ -0,0 +1,179 @@
+package de.jeanlucmakiola.calendula.domain
+
+import kotlin.math.abs
+import kotlin.math.atan2
+import kotlin.math.cbrt
+import kotlin.math.hypot
+import kotlin.math.pow
+import kotlin.math.roundToInt
+import kotlin.math.sqrt
+
+/**
+ * Curates an account's published event palette for the colour picker.
+ *
+ * Sync adapters differ wildly in what they publish: Google exposes a
+ * hand-picked two-dozen set, while CalDAV adapters (DAVx5) dump all ~147 CSS3
+ * named colours — including exact-value aliases (aqua/cyan, the gray/grey
+ * spelling pairs) and dozens of visually indistinguishable whites and grays
+ * (#22).
+ *
+ * Crucially, curation runs against the colour the picker actually *paints*, not
+ * the raw provider value. The picker softens every swatch through [pastelArgb]:
+ * it pins lightness to a constant and caps saturation, so the raw palette's
+ * lightness axis is invisible on screen. Two raw colours that look different —
+ * a navy and a mid blue — paint as one swatch, and every neutral (black, the
+ * grays, white) paints as the same pale tint. Judging distinctness in raw
+ * space, as before, left near-identical painted swatches and stranded the
+ * neutrals as a run of look-alike "pinks" at the end of the grid.
+ *
+ * Three steps, all in painted space:
+ *  1. Collapse swatches that paint identically to one (alphabetically-first key
+ *     wins, deterministically) — this folds aliases, dark/light shades of a
+ *     hue, and all the neutrals together.
+ *  2. Oversized palettes (> [CURATION_TRIGGER_SIZE]) drop the washed-out
+ *     neutral-origin tints (painted chroma < [PASTEL_CHROMA_FLOOR]) and are
+ *     then thinned to visually distinct colours: most vivid first, a colour is
+ *     kept only when at least [MIN_DELTA_E] (CIE76, painted Lab) from every
+ *     colour already kept. Small palettes are already curated by their adapter
+ *     and pass through whole.
+ *  3. The survivors are ordered like a rainbow — continuously by painted hue —
+ *     with the wheel cut at its single widest empty gap so the one unavoidable
+ *     seam lands in dead space and no hue family is torn across both ends.
+ *
+ * Every surviving option keeps its provider [EventColorOption.key], so a pick
+ * still round-trips through sync.
+ */
+fun List<EventColorOption>.curatedForPicker(): List<EventColorOption> {
+    val painted = sortedBy { it.key }
+        .distinctBy { pastelArgb(it.argb) }
+        .map { it to Lab.of(pastelArgb(it.argb)) }
+    val kept = if (painted.size <= CURATION_TRIGGER_SIZE) {
+        painted
+    } else {
+        thin(painted.filter { (_, lab) -> lab.chroma >= PASTEL_CHROMA_FLOOR })
+    }
+    return orderAroundWheel(kept).map { (option, _) -> option }
+}
+
+/**
+ * Orders swatches continuously around the (painted) hue wheel, then cuts the
+ * circle at its widest angular gap so the single seam lands in empty space
+ * instead of mid-family. Saturation breaks ties, vivid first.
+ */
+private fun orderAroundWheel(
+    swatches: List<Pair<EventColorOption, Lab>>,
+): List<Pair<EventColorOption, Lab>> {
+    if (swatches.size < 2) return swatches
+    val byHue = swatches.sortedWith(
+        compareBy({ (_, lab) -> lab.hue }, { (_, lab) -> -lab.chroma }),
+    )
+    // Split the wheel after the largest empty arc between neighbouring hues;
+    // the default is the wrap gap (last hue back round to the first), i.e. the
+    // familiar 0→360 order, and we only rotate away from it for a wider void.
+    var cutAfter = byHue.lastIndex
+    var widestGap = 360.0 - byHue.last().second.hue + byHue.first().second.hue
+    for (i in 0 until byHue.lastIndex) {
+        val gap = byHue[i + 1].second.hue - byHue[i].second.hue
+        if (gap > widestGap) {
+            widestGap = gap
+            cutAfter = i
+        }
+    }
+    return byHue.subList(cutAfter + 1, byHue.size) + byHue.subList(0, cutAfter + 1)
+}
+
+/** Greedy max-distance filter: vivid colours stake out clusters first. */
+private fun thin(
+    swatches: List<Pair<EventColorOption, Lab>>,
+): List<Pair<EventColorOption, Lab>> {
+    val byVividness = swatches
+        .sortedWith(compareByDescending<Pair<EventColorOption, Lab>> { it.second.chroma }.thenBy { it.first.key })
+    val kept = mutableListOf<Pair<EventColorOption, Lab>>()
+    for (candidate in byVividness) {
+        if (kept.none { it.second.deltaE(candidate.second) < MIN_DELTA_E }) kept += candidate
+    }
+    return kept
+}
+
+/**
+ * The softening the colour picker paints over every swatch (mirrored by
+ * ui/pastelize, which wraps this): keep the hue, scale and clamp saturation
+ * into a gentle band, and pin value to a constant so nothing screams and
+ * everything reads on the surface. Value is fixed here so curation is
+ * theme-independent — only hue and saturation distinguish painted swatches.
+ */
+fun pastelArgb(rawArgb: Int): Int {
+    val r = ((rawArgb shr 16) and 0xFF) / 255f
+    val g = ((rawArgb shr 8) and 0xFF) / 255f
+    val b = (rawArgb and 0xFF) / 255f
+    val max = maxOf(r, g, b)
+    val min = minOf(r, g, b)
+    val delta = max - min
+    val hue = when {
+        delta == 0f -> 0f
+        max == r -> 60f * (((g - b) / delta) % 6f)
+        max == g -> 60f * (((b - r) / delta) + 2f)
+        else -> 60f * (((r - g) / delta) + 4f)
+    }.let { if (it < 0f) it + 360f else it }
+    val sat = (if (max == 0f) 0f else delta / max) * 0.6f
+    val s = sat.coerceIn(0.25f, 0.65f)
+    val v = PASTEL_VALUE
+    val c = v * s
+    val x = c * (1f - abs((hue / 60f) % 2f - 1f))
+    val m = v - c
+    val (rr, gg, bb) = when {
+        hue < 60f -> Triple(c, x, 0f)
+        hue < 120f -> Triple(x, c, 0f)
+        hue < 180f -> Triple(0f, c, x)
+        hue < 240f -> Triple(0f, x, c)
+        hue < 300f -> Triple(x, 0f, c)
+        else -> Triple(c, 0f, x)
+    }
+    fun channel(value: Float) = ((value + m) * 255f).roundToInt().coerceIn(0, 255)
+    return (0xFF shl 24) or (channel(rr) shl 16) or (channel(gg) shl 8) or channel(bb)
+}
+
+/** Reference lightness for curation; the picker paints at this on dark surfaces. */
+private const val PASTEL_VALUE = 0.82f
+
+/** Palettes at most this big skip the thinning (Google's ~26 pass through). */
+private const val CURATION_TRIGGER_SIZE = 36
+
+/** Minimum CIE76 ΔE between surviving painted swatches. */
+private const val MIN_DELTA_E = 13.0
+
+/**
+ * Painted-chroma floor for oversized palettes: below this a swatch is a washed-
+ * out tint — the neutrals and near-whites the saturation clamp muddies — so it
+ * is dropped rather than shown as pale filler.
+ */
+private const val PASTEL_CHROMA_FLOOR = 22.0
+
+/** CIE Lab (D65) — the space where Euclidean distance ≈ perceived difference. */
+private class Lab(val l: Double, val a: Double, val b: Double) {
+    val chroma: Double get() = hypot(a, b)
+
+    /** Hue angle in degrees, 0–360, around the Lab a-b plane. */
+    val hue: Double get() = (Math.toDegrees(atan2(b, a)) + 360.0) % 360.0
+
+    fun deltaE(other: Lab): Double =
+        sqrt((l - other.l).pow(2) + (a - other.a).pow(2) + (b - other.b).pow(2))
+
+    companion object {
+        fun of(argb: Int): Lab {
+            fun linear(shift: Int): Double {
+                val c = ((argb shr shift) and 0xFF) / 255.0
+                return if (c <= 0.04045) c / 12.92 else ((c + 0.055) / 1.055).pow(2.4)
+            }
+            val r = linear(16)
+            val g = linear(8)
+            val b = linear(0)
+            val x = (0.4124 * r + 0.3576 * g + 0.1805 * b) / 0.95047
+            val y = 0.2126 * r + 0.7152 * g + 0.0722 * b
+            val z = (0.0193 * r + 0.1192 * g + 0.9505 * b) / 1.08883
+            fun f(t: Double) = if (t > 0.008856) cbrt(t) else 7.787 * t + 16.0 / 116.0
+            val fy = f(y)
+            return Lab(116 * fy - 16, 500 * (f(x) - fy), 200 * (fy - f(z)))
+        }
+    }
+}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/domain/FontRole.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/domain/FontRole.kt
@@ -1,8 +0,0 @@
-package de.jeanlucmakiola.calendula.domain
-
-/**
- * The two Material 3 typeface roles a user can set independently (issue #19):
- * [BRAND] drives the display/headline styles (expression), [PLAIN] the
- * title/body/label styles (readability). Each defaults to the system typeface.
- */
-enum class FontRole { BRAND, PLAIN }
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarColors.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarColors.kt
@@ -15,17 +15,21 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.dp
+import de.jeanlucmakiola.calendula.domain.pastelArgb

 /**
 * Soften a raw calendar color toward a pastel that fits the active theme.
 *  - Keeps the hue (so users still recognise their calendars)
 *  - Caps saturation so harsh provider colors stop screaming
 *  - Pins value/brightness to a band that reads on both light and dark surfaces
+ *
+ * The hue/saturation shaping lives in [pastelArgb] so the event-colour picker's
+ * curation reasons about the exact colour painted here (#22); this only picks
+ * the theme's brightness.
 */
 fun pastelize(rawArgb: Int, dark: Boolean): Color {
    val hsv = FloatArray(3)
-    android.graphics.Color.colorToHSV(rawArgb, hsv)
-    hsv[1] = (hsv[1] * 0.6f).coerceIn(0.25f, 0.65f)
+    android.graphics.Color.colorToHSV(pastelArgb(rawArgb), hsv)
    hsv[2] = if (dark) 0.82f else 0.72f
    return Color(android.graphics.Color.HSVToColor(hsv))
 }
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/edit/EventEditScreen.kt
@@ -1712,12 +1712,20 @@ private fun ColorPickerDialog(
        text = {
            Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
                if (palette.isNotEmpty()) {
+                    // The event's current colour may not be in the curated
+                    // palette (thinned near-duplicate, or a raw colour set
+                    // elsewhere) — append it so the selection ring has a home.
+                    val swatches = palette.map { it.argb }.let {
+                        if (selected != null && selected !in it) it + selected else it
+                    }
                    ColorSwatchRow(
-                        colors = palette.map { it.argb },
+                        colors = swatches,
                        selected = selected,
                        onSelect = { argb ->
-                            palette.firstOrNull { it.argb == argb }
-                                ?.let { onPickKey(it.key, it.argb) }
+                            val option = palette.firstOrNull { it.argb == argb }
+                            // The appended current colour has no key to write —
+                            // it is already the event's colour, so just close.
+                            if (option != null) onPickKey(option.key, option.argb) else onDismiss()
                        },
                        dark = dark,
                    )
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsScreen.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsScreen.kt
@@ -7,11 +7,9 @@ import android.content.Context
 import android.content.Intent
 import android.content.pm.PackageManager
 import android.graphics.drawable.Icon
-import android.net.Uri
 import android.os.Build
 import android.os.PowerManager
 import android.provider.Settings
-import android.widget.Toast
 import androidx.annotation.RequiresApi
 import android.text.format.DateFormat
 import androidx.activity.compose.rememberLauncherForActivityResult
@@ -55,7 +53,6 @@ import androidx.compose.material.icons.filled.Notifications
 import androidx.compose.material.icons.filled.Palette
 import androidx.compose.material.icons.filled.Translate
 import androidx.compose.material.icons.filled.Tune
-import androidx.compose.material.icons.filled.UploadFile
 import androidx.compose.material3.FilledTonalButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
@@ -65,7 +62,6 @@ import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -80,7 +76,6 @@ import androidx.compose.ui.res.colorResource
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.core.content.ContextCompat
@@ -102,11 +97,9 @@ import de.jeanlucmakiola.calendula.qs.NewEventTileService
 import de.jeanlucmakiola.calendula.ui.crash.CrashReportDialog
 import de.jeanlucmakiola.calendula.ui.crash.openIssueTracker
 import de.jeanlucmakiola.calendula.ui.crash.submitCrashReport
-import de.jeanlucmakiola.calendula.domain.FontRole
 import de.jeanlucmakiola.calendula.ui.common.calendarCollapseExit
 import de.jeanlucmakiola.calendula.ui.common.calendarExpandEnter
 import de.jeanlucmakiola.calendula.ui.common.AgendaRangePicker
-import de.jeanlucmakiola.calendula.ui.common.FullScreenPicker
 import de.jeanlucmakiola.calendula.ui.common.agendaRangeLabel
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.CollapsingScaffold
@@ -129,10 +122,6 @@ import de.jeanlucmakiola.calendula.ui.common.rememberCalendarSlideSpec
 import de.jeanlucmakiola.calendula.ui.common.currentLocale
 import de.jeanlucmakiola.calendula.ui.common.eventFormFieldIcon
 import de.jeanlucmakiola.calendula.ui.common.eventFormFieldLabel
-import de.jeanlucmakiola.calendula.ui.theme.BundledFont
-import de.jeanlucmakiola.calendula.ui.theme.FONT_CUSTOM_TOKEN
-import de.jeanlucmakiola.calendula.ui.theme.FONT_SYSTEM_TOKEN
-import de.jeanlucmakiola.calendula.ui.theme.resolveFontFamily
 import kotlinx.datetime.DayOfWeek
 import kotlinx.datetime.LocalTime
 import java.time.format.TextStyle as JavaTextStyle
@@ -509,18 +498,6 @@ private fun AppearanceScreen(
    var showAgendaScreenRange by remember { mutableStateOf(false) }
    var showAgendaWidgetRange by remember { mutableStateOf(false) }
    var showPastEvents by remember { mutableStateOf(false) }
-    var showBrandFont by remember { mutableStateOf(false) }
-    var showPlainFont by remember { mutableStateOf(false) }
-
-    val fonts by viewModel.fontState.collectAsStateWithLifecycle()
-    // A picked file that didn't parse as a font: tell the user and keep the old choice.
-    val context = LocalContext.current
-    val importFailedMessage = stringResource(R.string.settings_font_import_failed)
-    LaunchedEffect(Unit) {
-        viewModel.fontImportFailed.collect {
-            Toast.makeText(context, importFailedMessage, Toast.LENGTH_LONG).show()
-        }
-    }

    CollapsingScaffold(
        title = stringResource(R.string.settings_section_appearance),
@@ -557,24 +534,6 @@ private fun AppearanceScreen(

        Spacer(Modifier.height(16.dp))

-        // Fonts — the two Material typeface roles, each independently choosable
-        // (issue #19). Headings = brand (display/headline); body = plain
-        // (title/body/label). Both default to the system typeface.
-        GroupedRow(
-            title = stringResource(R.string.settings_font_headings),
-            summary = fontLabel(fonts.brand),
-            position = Position.Top,
-            onClick = { showBrandFont = true },
-        )
-        GroupedRow(
-            title = stringResource(R.string.settings_font_body),
-            summary = fontLabel(fonts.plain),
-            position = Position.Bottom,
-            onClick = { showPlainFont = true },
-        )
-
-        Spacer(Modifier.height(16.dp))
-
        // Calendar — view, week, and timeline formatting
        GroupedRow(
            title = stringResource(R.string.settings_default_view),
@@ -666,26 +625,6 @@ private fun AppearanceScreen(
            onDismiss = { showTheme = false },
        )
    }
-    if (showBrandFont) {
-        FontPicker(
-            title = stringResource(R.string.settings_font_headings),
-            role = FontRole.BRAND,
-            selected = fonts.brand,
-            onSelect = { viewModel.setFont(FontRole.BRAND, it) },
-            onImport = { viewModel.importCustomFont(FontRole.BRAND, it) },
-            onDismiss = { showBrandFont = false },
-        )
-    }
-    if (showPlainFont) {
-        FontPicker(
-            title = stringResource(R.string.settings_font_body),
-            role = FontRole.PLAIN,
-            selected = fonts.plain,
-            onSelect = { viewModel.setFont(FontRole.PLAIN, it) },
-            onImport = { viewModel.importCustomFont(FontRole.PLAIN, it) },
-            onDismiss = { showPlainFont = false },
-        )
-    }
    if (showWeekStart) {
        OptionPicker(
            title = stringResource(R.string.settings_week_start),
@@ -1393,145 +1332,6 @@ private fun themeLabel(mode: ThemeMode): String = stringResource(
    },
 )

-/** The summary label for a stored font token (issue #19). */
-@Composable
-private fun fontLabel(token: String): String = when (token) {
-    FONT_SYSTEM_TOKEN -> stringResource(R.string.settings_font_system)
-    FONT_CUSTOM_TOKEN -> stringResource(R.string.settings_font_custom_selected)
-    else -> BundledFont.fromToken(token)?.let { stringResource(it.labelRes) }
-        ?: stringResource(R.string.settings_font_system)
-}
-
-/**
- * MIME types offered to the document picker so it lists only font files. Covers
- * the modern `font/` types plus the legacy `application/` font aliases some
- * providers still report. Anything that slips through is still validated by
- * [de.jeanlucmakiola.calendula.data.fonts.CustomFontStore] before use.
- */
-private val FONT_PICKER_MIME_TYPES = arrayOf(
-    "font/ttf",
-    "font/otf",
-    "font/sfnt",
-    "font/collection",
-    "application/x-font-ttf",
-    "application/x-font-otf",
-    "application/font-sfnt",
-    "application/vnd.ms-opentype",
-)
-
-/**
- * Full-screen font chooser for one [FontRole]: the system default, each bundled
- * font (previewed in its own face), and "Choose file…" which opens the system
- * picker to load a .ttf/.otf. Selecting a system/bundled option applies at once;
- * a file is validated and imported by the caller, switching to the custom font
- * on success.
- */
-@Composable
-private fun FontPicker(
-    title: String,
-    role: FontRole,
-    selected: String,
-    onSelect: (String) -> Unit,
-    onImport: (Uri) -> Unit,
-    onDismiss: () -> Unit,
-) {
-    val context = LocalContext.current
-    val launcher = rememberLauncherForActivityResult(
-        contract = ActivityResultContracts.OpenDocument(),
-    ) { uri ->
-        if (uri != null) {
-            onImport(uri)
-            onDismiss()
-        }
-    }
-
-    // System default + the bundled fonts + the "Choose file…" row.
-    val rowCount = BundledFont.entries.size + 2
-    val isCustom = selected == FONT_CUSTOM_TOKEN
-
-    FullScreenPicker(title = title, onDismiss = onDismiss) {
-        FontOptionRow(
-            label = stringResource(R.string.settings_font_system),
-            preview = FontFamily.Default,
-            selected = selected == FONT_SYSTEM_TOKEN,
-            position = positionOf(0, rowCount),
-            onClick = {
-                onSelect(FONT_SYSTEM_TOKEN)
-                onDismiss()
-            },
-        )
-        BundledFont.entries.forEachIndexed { index, font ->
-            FontOptionRow(
-                label = stringResource(font.labelRes),
-                preview = font.family,
-                selected = selected == font.token,
-                position = positionOf(index + 1, rowCount),
-                onClick = {
-                    onSelect(font.token)
-                    onDismiss()
-                },
-            )
-        }
-        FontOptionRow(
-            label = if (isCustom) {
-                stringResource(R.string.settings_font_custom_selected)
-            } else {
-                stringResource(R.string.settings_font_choose_file)
-            },
-            // A loaded font previews in its own face; otherwise show an upload cue.
-            preview = if (isCustom) resolveFontFamily(FONT_CUSTOM_TOKEN, role, context) else null,
-            leadingIcon = if (isCustom) null else Icons.Default.UploadFile,
-            selected = isCustom,
-            position = positionOf(rowCount - 1, rowCount),
-            onClick = { launcher.launch(FONT_PICKER_MIME_TYPES) },
-        )
-    }
-}
-
-/**
- * One row in the [FontPicker]: the font's name, a leading "Ag" sample rendered in
- * the option's own [preview] face (or an [leadingIcon] cue when there's nothing
- * to preview), and a check when it's the current selection.
- */
-@Composable
-private fun FontOptionRow(
-    label: String,
-    preview: FontFamily?,
-    selected: Boolean,
-    position: Position,
-    onClick: () -> Unit,
-    leadingIcon: ImageVector? = null,
-) {
-    GroupedRow(
-        title = label,
-        position = position,
-        selected = selected,
-        leading = {
-            if (preview != null) {
-                Text(
-                    text = "Ag",
-                    fontFamily = preview,
-                    style = MaterialTheme.typography.titleLarge,
-                )
-            } else if (leadingIcon != null) {
-                Icon(imageVector = leadingIcon, contentDescription = null)
-            }
-        },
-        trailing = if (selected) {
-            {
-                Icon(
-                    imageVector = Icons.Default.Check,
-                    contentDescription = null,
-                    tint = MaterialTheme.colorScheme.primary,
-                )
-            }
-        } else {
-            null
-        },
-        onClick = onClick,
-    )
-}
-
 /** Picker options: "Follow system" first, then Monday…Sunday in ISO order. */
 private val WEEK_START_OPTIONS: List<WeekStartPref> =
    listOf(WeekStartPref.Auto) + DayOfWeek.entries.map { WeekStartPref.Day(it) }
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsViewModel.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/settings/SettingsViewModel.kt
@@ -1,7 +1,6 @@
 package de.jeanlucmakiola.calendula.ui.settings

 import android.content.Context
-import android.net.Uri
 import android.os.Build
 import androidx.glance.appwidget.GlanceAppWidgetManager
 import androidx.glance.appwidget.state.updateAppWidgetState
@@ -11,8 +10,6 @@ import androidx.lifecycle.viewModelScope
 import dagger.hilt.android.lifecycle.HiltViewModel
 import dagger.hilt.android.qualifiers.ApplicationContext
 import de.jeanlucmakiola.calendula.data.calendar.CalendarRepository
-import de.jeanlucmakiola.calendula.data.di.IoDispatcher
-import de.jeanlucmakiola.calendula.data.fonts.CustomFontStore
 import de.jeanlucmakiola.calendula.data.prefs.CalendarReminderOverride
 import de.jeanlucmakiola.calendula.data.prefs.PastEventDisplay
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
@@ -21,21 +18,15 @@ import de.jeanlucmakiola.calendula.data.prefs.TimeFormatPref
 import de.jeanlucmakiola.calendula.data.prefs.WeekStartPref
 import de.jeanlucmakiola.calendula.domain.CalendarSource
 import de.jeanlucmakiola.calendula.domain.EventFormField
-import de.jeanlucmakiola.calendula.domain.FontRole
 import de.jeanlucmakiola.calendula.ui.agenda.AgendaRange
 import de.jeanlucmakiola.calendula.ui.agenda.storageValue
 import de.jeanlucmakiola.calendula.ui.common.CalendarView
 import de.jeanlucmakiola.calendula.ui.common.QuickSwitchConfig
-import de.jeanlucmakiola.calendula.ui.theme.AppFontSettings
-import de.jeanlucmakiola.calendula.ui.theme.FONT_CUSTOM_TOKEN
 import de.jeanlucmakiola.calendula.widget.agenda.AGENDA_PAST_DISPLAY_KEY
 import de.jeanlucmakiola.calendula.widget.agenda.AGENDA_RANGE_KEY
 import de.jeanlucmakiola.calendula.widget.agenda.AgendaWidget
 import de.jeanlucmakiola.calendula.widget.month.MonthWidget
-import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.catch
@@ -45,14 +36,12 @@ import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.withContext
 import javax.inject.Inject

@HiltViewModel
 class SettingsViewModel @Inject constructor(
    private val prefs: SettingsPrefs,
    repository: CalendarRepository,
-    @IoDispatcher private val io: CoroutineDispatcher,
    @ApplicationContext private val appContext: Context,
 ) : ViewModel() {

@@ -151,27 +140,6 @@ class SettingsViewModel @Inject constructor(
            initialValue = SettingsUiState(dynamicColorAvailable = dynamicColorAvailable),
        )

-    /**
-     * The app-wide custom-font choice (issue #19). Its own flow — both this
-     * screen and [MainActivity] (which builds the typography) read it
-     * independently of the main settings combine.
-     */
-    val fontState: StateFlow<AppFontSettings> = combine(
-        prefs.brandFont,
-        prefs.plainFont,
-    ) { brand, plain ->
-        AppFontSettings(brand = brand, plain = plain)
-    }.stateIn(
-        scope = viewModelScope,
-        started = SharingStarted.WhileSubscribed(5_000L),
-        initialValue = AppFontSettings(),
-    )
-
-    // Emitted when a picked font file couldn't be read as a font; the screen
-    // surfaces it and the previous selection stays put.
-    private val _fontImportFailed = MutableSharedFlow<Unit>(extraBufferCapacity = 1)
-    val fontImportFailed: SharedFlow<Unit> = _fontImportFailed
-
    // Serialises widget redraws so a rapid flip-and-flip-back can't run two
    // updateAll calls at once — concurrent calls coalesce around a stale read
    // and can leave the widget on the intermediate value. Held sequentially,
@@ -221,31 +189,6 @@ class SettingsViewModel @Inject constructor(
        viewModelScope.launch { prefs.setDynamicColor(enabled) }
    }

-    fun setFont(role: FontRole, token: String) {
-        viewModelScope.launch {
-            when (role) {
-                FontRole.BRAND -> prefs.setBrandFont(token)
-                FontRole.PLAIN -> prefs.setPlainFont(token)
-            }
-        }
-    }
-
-    /**
-     * Import a user-picked font file for [role]. Copies and validates it off the
-     * main thread; on success the role switches to the custom font, otherwise the
-     * previous choice is kept and [fontImportFailed] fires.
-     */
-    fun importCustomFont(role: FontRole, uri: Uri) {
-        viewModelScope.launch {
-            val ok = withContext(io) { CustomFontStore.import(appContext, role, uri) }
-            if (ok) {
-                setFont(role, FONT_CUSTOM_TOKEN)
-            } else {
-                _fontImportFailed.emit(Unit)
-            }
-        }
-    }
-
    fun setWeekStart(pref: WeekStartPref) {
        viewModelScope.launch {
            prefs.setWeekStart(pref)
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/theme/Fonts.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/theme/Fonts.kt
@@ -1,124 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.theme
-
-import android.content.Context
-import androidx.annotation.StringRes
-import androidx.compose.material3.Typography
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontVariation
-import androidx.compose.ui.text.font.FontWeight
-import de.jeanlucmakiola.calendula.R
-import de.jeanlucmakiola.calendula.data.fonts.CustomFontStore
-import de.jeanlucmakiola.calendula.domain.FontRole
-import java.io.File
-
-/** Stored token for "use the device default typeface" — the default for both roles. */
-const val FONT_SYSTEM_TOKEN = "system"
-
-/** Stored token for "use the font the user loaded from a file" (per role). */
-const val FONT_CUSTOM_TOKEN = "custom"
-
-/**
- * A font checked into the app that a user can pick without providing a file
- * (issue #19). [token] is the stable value persisted in preferences; [family] is
- * the resolved Compose family. Kept deliberately small and readability-focused.
- */
-enum class BundledFont(
-    val token: String,
-    @StringRes val labelRes: Int,
-    val family: FontFamily,
-) {
-    /** Purpose-built for low-vision legibility (Braille Institute). */
-    AtkinsonHyperlegible(
-        token = "atkinson_hyperlegible",
-        labelRes = R.string.font_atkinson_hyperlegible,
-        family = FontFamily(
-            Font(R.font.atkinson_hyperlegible_regular, FontWeight.Normal),
-            Font(R.font.atkinson_hyperlegible_bold, FontWeight.Bold),
-        ),
-    ),
-
-    /** A serif alternative; shipped as a variable font, weights via its wght axis. */
-    Lora(
-        token = "lora",
-        labelRes = R.string.font_lora,
-        family = FontFamily(
-            Font(R.font.lora, FontWeight.Normal, variationSettings = weightAxis(400)),
-            Font(R.font.lora, FontWeight.Medium, variationSettings = weightAxis(500)),
-            Font(R.font.lora, FontWeight.Bold, variationSettings = weightAxis(700)),
-        ),
-    ),
-
-    /** A monospace option. */
-    JetBrainsMono(
-        token = "jetbrains_mono",
-        labelRes = R.string.font_jetbrains_mono,
-        family = FontFamily(
-            Font(R.font.jetbrains_mono_regular, FontWeight.Normal),
-            Font(R.font.jetbrains_mono_bold, FontWeight.Bold),
-        ),
-    );
-
-    companion object {
-        fun fromToken(token: String?): BundledFont? = entries.firstOrNull { it.token == token }
-    }
-}
-
-private fun weightAxis(weight: Int) = FontVariation.Settings(FontVariation.weight(weight))
-
-/** The two roles' current font tokens (see [FontRole]); the app-wide typeface choice. */
-data class AppFontSettings(
-    val brand: String = FONT_SYSTEM_TOKEN,
-    val plain: String = FONT_SYSTEM_TOKEN,
-)
-
-/**
- * Resolve a stored [token] for [role] to a Compose [FontFamily], or null to mean
- * "leave the Material default" (the system typeface). A custom token whose file
- * is missing or unreadable also resolves to null, so a deleted file degrades to
- * the system font rather than crashing text layout.
- */
-fun resolveFontFamily(token: String, role: FontRole, context: Context): FontFamily? = when (token) {
-    FONT_SYSTEM_TOKEN -> null
-    FONT_CUSTOM_TOKEN -> customFontFamily(CustomFontStore.file(context, role))
-    else -> BundledFont.fromToken(token)?.family
-}
-
-private fun customFontFamily(file: File): FontFamily? =
-    if (file.exists() && file.length() > 0) {
-        runCatching { FontFamily(Font(file)) }.getOrNull()
-    } else {
-        null
-    }
-
-/**
- * Build the app typography from the chosen [brand] and [plain] families. A null
- * family leaves that role's Material default (system typeface) in place, so the
- * common "system for both" case returns [CalendulaTypography] untouched. Brand
- * drives display + headline; plain drives title + body + label (M3's two
- * typeface roles).
- */
-fun calendulaTypography(brand: FontFamily?, plain: FontFamily?): Typography {
-    if (brand == null && plain == null) return CalendulaTypography
-    val base = CalendulaTypography
-    fun TextStyle.withFamily(family: FontFamily?): TextStyle =
-        if (family != null) copy(fontFamily = family) else this
-    return base.copy(
-        displayLarge = base.displayLarge.withFamily(brand),
-        displayMedium = base.displayMedium.withFamily(brand),
-        displaySmall = base.displaySmall.withFamily(brand),
-        headlineLarge = base.headlineLarge.withFamily(brand),
-        headlineMedium = base.headlineMedium.withFamily(brand),
-        headlineSmall = base.headlineSmall.withFamily(brand),
-        titleLarge = base.titleLarge.withFamily(plain),
-        titleMedium = base.titleMedium.withFamily(plain),
-        titleSmall = base.titleSmall.withFamily(plain),
-        bodyLarge = base.bodyLarge.withFamily(plain),
-        bodyMedium = base.bodyMedium.withFamily(plain),
-        bodySmall = base.bodySmall.withFamily(plain),
-        labelLarge = base.labelLarge.withFamily(plain),
-        labelMedium = base.labelMedium.withFamily(plain),
-        labelSmall = base.labelSmall.withFamily(plain),
-    )
-}
--- a/app/src/main/java/de/jeanlucmakiola/calendula/ui/theme/Theme.kt
+++ b/app/src/main/java/de/jeanlucmakiola/calendula/ui/theme/Theme.kt
@@ -5,7 +5,6 @@ import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.MaterialExpressiveTheme
 import androidx.compose.material3.MotionScheme
-import androidx.compose.material3.Typography
 import androidx.compose.material3.dynamicDarkColorScheme
 import androidx.compose.material3.dynamicLightColorScheme
 import androidx.compose.runtime.Composable
@@ -16,18 +15,15 @@ import androidx.compose.ui.platform.LocalContext
 *   - System light/dark.
 *   - Dynamic Color on API 31+, else falls back to the hand-tuned scheme
 *     derived from [CalendulaSeed].
- *   - A user-chosen [typography] (custom fonts, issue #19), defaulting to the
- *     Material scale on the system typeface.
 *
- * The Settings screen overrides darkTheme, dynamicColor, and typography; the
- * bare defaults (used by the crash screen) just follow the system.
+ * The Settings screen (later) can override useDynamicColor and themePreference,
+ * but the V1 foundation just follows the system.
 */
@OptIn(ExperimentalMaterial3ExpressiveApi::class)
@Composable
 fun CalendulaTheme(
    darkTheme: Boolean = isSystemInDarkTheme(),
    dynamicColor: Boolean = true,
-    typography: Typography = CalendulaTypography,
    content: @Composable () -> Unit,
 ) {
    val colorScheme = when {
@@ -46,7 +42,7 @@ fun CalendulaTheme(
    // the bouncy variant felt overdone in review (2026-06-11).
    MaterialExpressiveTheme(
        colorScheme = colorScheme,
-        typography = typography,
+        typography = CalendulaTypography,
        motionScheme = MotionScheme.standard(),
        content = content,
    )
--- a/app/src/main/res/font/atkinson_hyperlegible_bold.ttf
+++ b/app/src/main/res/font/atkinson_hyperlegible_bold.ttf
--- a/app/src/main/res/font/atkinson_hyperlegible_regular.ttf
+++ b/app/src/main/res/font/atkinson_hyperlegible_regular.ttf
--- a/app/src/main/res/font/jetbrains_mono_bold.ttf
+++ b/app/src/main/res/font/jetbrains_mono_bold.ttf
--- a/app/src/main/res/font/jetbrains_mono_regular.ttf
+++ b/app/src/main/res/font/jetbrains_mono_regular.ttf
--- a/app/src/main/res/font/lora.ttf
+++ b/app/src/main/res/font/lora.ttf
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -274,15 +274,6 @@
    <string name="settings_default_view">Default view</string>
    <string name="settings_dynamic_color">Dynamic colour</string>
    <string name="settings_dynamic_color_unavailable">Requires Android 12 or newer</string>
-    <string name="settings_font_headings">Headings font</string>
-    <string name="settings_font_body">Body font</string>
-    <string name="settings_font_system">System default</string>
-    <string name="font_atkinson_hyperlegible">Atkinson Hyperlegible</string>
-    <string name="font_lora">Lora</string>
-    <string name="font_jetbrains_mono">JetBrains Mono</string>
-    <string name="settings_font_choose_file">Choose file…</string>
-    <string name="settings_font_custom_selected">Custom font</string>
-    <string name="settings_font_import_failed">Couldn\'t read that file as a font</string>
    <string name="settings_week_start">Week starts on</string>
    <string name="settings_week_start_auto">Automatic</string>
    <string name="settings_time_format">Time format</string>
--- a/app/src/test/java/de/jeanlucmakiola/calendula/domain/EventColorPaletteTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/domain/EventColorPaletteTest.kt
@@ -0,0 +1,214 @@
+package de.jeanlucmakiola.calendula.domain
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
+
+class EventColorPaletteTest {
+
+    @Test
+    fun `empty palette stays empty`() {
+        assertThat(emptyList<EventColorOption>().curatedForPicker()).isEmpty()
+    }
+
+    @Test
+    fun `exact duplicate values collapse to the alphabetically first key`() {
+        val curated = listOf(
+            EventColorOption("cyan", 0xFF00FFFF.toInt()),
+            EventColorOption("aqua", 0xFF00FFFF.toInt()),
+            EventColorOption("red", 0xFFFF0000.toInt()),
+        ).curatedForPicker()
+
+        assertThat(curated.map { it.key }).containsExactly("aqua", "red")
+    }
+
+    @Test
+    fun `small palettes pass through whole, so Google's curated set is untouched`() {
+        // A Google-like palette: two dozen distinct hand-picked colours.
+        val palette = (0 until 24).map {
+            val hue = it * 15
+            EventColorOption("$it", hsvArgb(hue.toFloat()))
+        }
+
+        val curated = palette.curatedForPicker()
+
+        assertThat(curated).containsExactlyElementsIn(palette)
+    }
+
+    @Test
+    fun `oversized CSS3 palette thins to a pickable number of distinct swatches`() {
+        val curated = css3Palette().curatedForPicker()
+
+        // The whole point of #22: ~147 published colours become a single
+        // manageable grid instead of a full screen.
+        assertThat(curated.size).isAtLeast(30)
+        assertThat(curated.size).isAtMost(60)
+    }
+
+    @Test
+    fun `curation never invents colours or drops keys`() {
+        val source = css3Palette()
+        val curated = source.curatedForPicker()
+
+        assertThat(source).containsAtLeastElementsIn(curated)
+        assertThat(curated.map { it.argb }).containsNoDuplicates()
+    }
+
+    @Test
+    fun `spelling-alias pairs never both survive`() {
+        val keys = css3Palette().curatedForPicker().map { it.key }.toSet()
+
+        val aliasPairs = listOf(
+            "aqua" to "cyan",
+            "fuchsia" to "magenta",
+            "gray" to "grey",
+            "darkgray" to "darkgrey",
+            "dimgray" to "dimgrey",
+            "lightgray" to "lightgrey",
+            "slategray" to "slategrey",
+            "lightslategray" to "lightslategrey",
+            "darkslategray" to "darkslategrey",
+        )
+        aliasPairs.forEach { (a, b) ->
+            assertThat(keys.contains(a) && keys.contains(b)).isFalse()
+        }
+    }
+
+    @Test
+    fun `neutrals collapse to one painted tint instead of a run of look-alikes`() {
+        // Black and every gray paint as the same pale swatch (the picker pins
+        // lightness and floors saturation), so only one survives — no stranded
+        // run of look-alike "pinks" at the end of the grid (#22).
+        val curated = listOf(
+            EventColorOption("black", 0xFF000000.toInt()),
+            EventColorOption("gray", 0xFF808080.toInt()),
+            EventColorOption("darkgray", 0xFFA9A9A9.toInt()),
+            EventColorOption("blue", 0xFF0000FF.toInt()),
+            EventColorOption("red", 0xFFFF0000.toInt()),
+        ).curatedForPicker().map { it.key }
+
+        assertThat(curated).containsNoneOf("gray", "darkgray") // folded into black
+        assertThat(curated).containsAtLeast("black", "red", "blue")
+    }
+
+    @Test
+    fun `a dark and a light shade of one hue collapse to a single swatch`() {
+        // The picker paints every swatch at one fixed lightness, so navy and a
+        // mid blue are indistinguishable once painted — keep just one.
+        val curated = listOf(
+            EventColorOption("navy", 0xFF000080.toInt()),
+            EventColorOption("blue", 0xFF0000FF.toInt()),
+        ).curatedForPicker()
+
+        assertThat(curated).hasSize(1)
+    }
+
+    @Test
+    fun `the wheel is cut once, keeping each hue family contiguous`() {
+        // Twelve pure hues, deliberately shuffled; a small palette passes the
+        // thinning stage untouched so only the ordering is under test.
+        val shuffledHues = listOf(0, 300, 60, 180, 120, 240, 30, 330, 90, 210, 150, 270)
+        val curated = shuffledHues
+            .map { EventColorOption("$it", hsvArgb(it.toFloat())) }
+            .curatedForPicker()
+            .map { it.key.toInt() }
+
+        // A proper single-seam sweep around the wheel descends exactly once
+        // (at the seam). The old bucketed sort could scatter a family across
+        // both ends, producing extra descents.
+        val descents = curated.indices.count { i ->
+            curated[(i + 1) % curated.size] < curated[i]
+        }
+        assertThat(descents).isEqualTo(1)
+    }
+
+    @Test
+    fun `CSS3 survivors span the whole rainbow`() {
+        val keys = css3Palette().curatedForPicker().map { it.key }
+        fun has(vararg families: String) = keys.any { k -> families.any { k.contains(it) } }
+
+        // Which exact name represents a hue family depends on the vivid-first
+        // thinning, so assert each family survives, not a specific key.
+        assertThat(has("red", "crimson", "firebrick", "tomato", "maroon", "brown")).isTrue()
+        assertThat(has("orange", "gold", "goldenrod", "peru", "sienna", "salmon")).isTrue()
+        assertThat(has("green", "olive", "lime", "chartreuse", "forest", "sea")).isTrue()
+        assertThat(has("blue", "navy", "dodger", "steel", "royal", "sky", "aqua")).isTrue()
+        assertThat(has("violet", "purple", "magenta", "orchid", "fuchsia", "indigo", "plum")).isTrue()
+    }
+
+    private fun hsvArgb(hue: Float): Int {
+        val h = hue / 60f
+        val sector = h.toInt() % 6
+        val f = h - h.toInt()
+        val q = ((1 - f) * 255).toInt()
+        val t = (f * 255).toInt()
+        return when (sector) {
+            0 -> argb(255, t, 0)
+            1 -> argb(q, 255, 0)
+            2 -> argb(0, 255, t)
+            3 -> argb(0, q, 255)
+            4 -> argb(t, 0, 255)
+            else -> argb(255, 0, q)
+        }
+    }
+
+    private fun argb(r: Int, g: Int, b: Int): Int =
+        (0xFF shl 24) or (r shl 16) or (g shl 8) or b
+
+    /** The exact set ical4android/DAVx5 publishes: CSS3's 147 named colours. */
+    private fun css3Palette(): List<EventColorOption> = CSS3.map { (name, rgb) ->
+        EventColorOption(name, 0xFF000000.toInt() or rgb)
+    }
+
+    private val CSS3 = mapOf(
+        "aliceblue" to 0xF0F8FF, "antiquewhite" to 0xFAEBD7, "aqua" to 0x00FFFF,
+        "aquamarine" to 0x7FFFD4, "azure" to 0xF0FFFF, "beige" to 0xF5F5DC,
+        "bisque" to 0xFFE4C4, "black" to 0x000000, "blanchedalmond" to 0xFFEBCD,
+        "blue" to 0x0000FF, "blueviolet" to 0x8A2BE2, "brown" to 0xA52A2A,
+        "burlywood" to 0xDEB887, "cadetblue" to 0x5F9EA0, "chartreuse" to 0x7FFF00,
+        "chocolate" to 0xD2691E, "coral" to 0xFF7F50, "cornflowerblue" to 0x6495ED,
+        "cornsilk" to 0xFFF8DC, "crimson" to 0xDC143C, "cyan" to 0x00FFFF,
+        "darkblue" to 0x00008B, "darkcyan" to 0x008B8B, "darkgoldenrod" to 0xB8860B,
+        "darkgray" to 0xA9A9A9, "darkgreen" to 0x006400, "darkgrey" to 0xA9A9A9,
+        "darkkhaki" to 0xBDB76B, "darkmagenta" to 0x8B008B, "darkolivegreen" to 0x556B2F,
+        "darkorange" to 0xFF8C00, "darkorchid" to 0x9932CC, "darkred" to 0x8B0000,
+        "darksalmon" to 0xE9967A, "darkseagreen" to 0x8FBC8F, "darkslateblue" to 0x483D8B,
+        "darkslategray" to 0x2F4F4F, "darkslategrey" to 0x2F4F4F, "darkturquoise" to 0x00CED1,
+        "darkviolet" to 0x9400D3, "deeppink" to 0xFF1493, "deepskyblue" to 0x00BFFF,
+        "dimgray" to 0x696969, "dimgrey" to 0x696969, "dodgerblue" to 0x1E90FF,
+        "firebrick" to 0xB22222, "floralwhite" to 0xFFFAF0, "forestgreen" to 0x228B22,
+        "fuchsia" to 0xFF00FF, "gainsboro" to 0xDCDCDC, "ghostwhite" to 0xF8F8FF,
+        "gold" to 0xFFD700, "goldenrod" to 0xDAA520, "gray" to 0x808080,
+        "green" to 0x008000, "greenyellow" to 0xADFF2F, "grey" to 0x808080,
+        "honeydew" to 0xF0FFF0, "hotpink" to 0xFF69B4, "indianred" to 0xCD5C5C,
+        "indigo" to 0x4B0082, "ivory" to 0xFFFFF0, "khaki" to 0xF0E68C,
+        "lavender" to 0xE6E6FA, "lavenderblush" to 0xFFF0F5, "lawngreen" to 0x7CFC00,
+        "lemonchiffon" to 0xFFFACD, "lightblue" to 0xADD8E6, "lightcoral" to 0xF08080,
+        "lightcyan" to 0xE0FFFF, "lightgoldenrodyellow" to 0xFAFAD2, "lightgray" to 0xD3D3D3,
+        "lightgreen" to 0x90EE90, "lightgrey" to 0xD3D3D3, "lightpink" to 0xFFB6C1,
+        "lightsalmon" to 0xFFA07A, "lightseagreen" to 0x20B2AA, "lightskyblue" to 0x87CEFA,
+        "lightslategray" to 0x778899, "lightslategrey" to 0x778899, "lightsteelblue" to 0xB0C4DE,
+        "lightyellow" to 0xFFFFE0, "lime" to 0x00FF00, "limegreen" to 0x32CD32,
+        "linen" to 0xFAF0E6, "magenta" to 0xFF00FF, "maroon" to 0x800000,
+        "mediumaquamarine" to 0x66CDAA, "mediumblue" to 0x0000CD, "mediumorchid" to 0xBA55D3,
+        "mediumpurple" to 0x9370DB, "mediumseagreen" to 0x3CB371, "mediumslateblue" to 0x7B68EE,
+        "mediumspringgreen" to 0x00FA9A, "mediumturquoise" to 0x48D1CC,
+        "mediumvioletred" to 0xC71585, "midnightblue" to 0x191970, "mintcream" to 0xF5FFFA,
+        "mistyrose" to 0xFFE4E1, "moccasin" to 0xFFE4B5, "navajowhite" to 0xFFDEAD,
+        "navy" to 0x000080, "oldlace" to 0xFDF5E6, "olive" to 0x808000,
+        "olivedrab" to 0x6B8E23, "orange" to 0xFFA500, "orangered" to 0xFF4500,
+        "orchid" to 0xDA70D6, "palegoldenrod" to 0xEEE8AA, "palegreen" to 0x98FB98,
+        "paleturquoise" to 0xAFEEEE, "palevioletred" to 0xDB7093, "papayawhip" to 0xFFEFD5,
+        "peachpuff" to 0xFFDAB9, "peru" to 0xCD853F, "pink" to 0xFFC0CB,
+        "plum" to 0xDDA0DD, "powderblue" to 0xB0E0E6, "purple" to 0x800080,
+        "red" to 0xFF0000, "rosybrown" to 0xBC8F8F, "royalblue" to 0x4169E1,
+        "saddlebrown" to 0x8B4513, "salmon" to 0xFA8072, "sandybrown" to 0xF4A460,
+        "seagreen" to 0x2E8B57, "seashell" to 0xFFF5EE, "sienna" to 0xA0522D,
+        "silver" to 0xC0C0C0, "skyblue" to 0x87CEEB, "slateblue" to 0x6A5ACD,
+        "slategray" to 0x708090, "slategrey" to 0x708090, "snow" to 0xFFFAFA,
+        "springgreen" to 0x00FF7F, "steelblue" to 0x4682B4, "tan" to 0xD2B48C,
+        "teal" to 0x008080, "thistle" to 0xD8BFD8, "tomato" to 0xFF6347,
+        "turquoise" to 0x40E0D0, "violet" to 0xEE82EE, "wheat" to 0xF5DEB3,
+        "white" to 0xFFFFFF, "whitesmoke" to 0xF5F5F5, "yellow" to 0xFFFF00,
+        "yellowgreen" to 0x9ACD32,
+    )
+}
--- a/app/src/test/java/de/jeanlucmakiola/calendula/ui/theme/FontsTest.kt
+++ b/app/src/test/java/de/jeanlucmakiola/calendula/ui/theme/FontsTest.kt
@@ -1,52 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.theme
-
-import com.google.common.truth.Truth.assertThat
-import org.junit.jupiter.api.Test
-
-class FontsTest {
-
-    @Test
-    fun `fromToken round-trips every bundled font`() {
-        BundledFont.entries.forEach { font ->
-            assertThat(BundledFont.fromToken(font.token)).isEqualTo(font)
-        }
-    }
-
-    @Test
-    fun `fromToken is null for system, custom, and unknown tokens`() {
-        assertThat(BundledFont.fromToken(FONT_SYSTEM_TOKEN)).isNull()
-        assertThat(BundledFont.fromToken(FONT_CUSTOM_TOKEN)).isNull()
-        assertThat(BundledFont.fromToken("not-a-font")).isNull()
-        assertThat(BundledFont.fromToken(null)).isNull()
-    }
-
-    @Test
-    fun `system for both roles returns the untouched default typography`() {
-        assertThat(calendulaTypography(brand = null, plain = null))
-            .isSameInstanceAs(CalendulaTypography)
-    }
-
-    @Test
-    fun `brand drives display and headline, plain drives title, body, and label`() {
-        val brand = BundledFont.Lora.family
-        val plain = BundledFont.JetBrainsMono.family
-        val typography = calendulaTypography(brand = brand, plain = plain)
-
-        assertThat(typography.displayLarge.fontFamily).isEqualTo(brand)
-        assertThat(typography.headlineSmall.fontFamily).isEqualTo(brand)
-        assertThat(typography.titleLarge.fontFamily).isEqualTo(plain)
-        assertThat(typography.bodyMedium.fontFamily).isEqualTo(plain)
-        assertThat(typography.labelSmall.fontFamily).isEqualTo(plain)
-    }
-
-    @Test
-    fun `a null role keeps that role's default family while the other is applied`() {
-        val plain = BundledFont.Lora.family
-        val typography = calendulaTypography(brand = null, plain = plain)
-
-        // Brand styles keep the Material default; plain styles switch.
-        assertThat(typography.displayLarge.fontFamily)
-            .isEqualTo(CalendulaTypography.displayLarge.fontFamily)
-        assertThat(typography.bodyLarge.fontFamily).isEqualTo(plain)
-    }
-}
--- a/licenses/fonts/AtkinsonHyperlegible-OFL.txt
+++ b/licenses/fonts/AtkinsonHyperlegible-OFL.txt
@@ -1,92 +0,0 @@
-Copyright 2020 Braille Institute of America, Inc.
-
-This Font Software is licensed under the SIL Open Font License, Version 1.1.
-This license is copied below, and is also available with a FAQ at:
-http://scripts.sil.org/OFL
-
-----------------------------------------------------------
-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------
-
-PREAMBLE
-The goals of the Open Font License (OFL) are to stimulate worldwide
-development of collaborative font projects, to support the font creation
-efforts of academic and linguistic communities, and to provide a free and
-open framework in which fonts may be shared and improved in partnership
-with others.
-
-The OFL allows the licensed fonts to be used, studied, modified and
-redistributed freely as long as they are not sold by themselves. The
-fonts, including any derivative works, can be bundled, embedded, 
-redistributed and/or sold with any software provided that any reserved
-names are not used by derivative works. The fonts and derivatives,
-however, cannot be released under any other type of license. The
-requirement for fonts to remain under this license does not apply
-to any document created using the fonts or their derivatives.
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this license and clearly marked as such. This may
-include source files, build scripts and documentation.
-
-"Reserved Font Name" refers to any names specified as such after the
-copyright statement(s).
-
-"Original Version" refers to the collection of Font Software components as
-distributed by the Copyright Holder(s).
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting -- in part or in whole -- any of the components of the
-Original Version, by changing formats or by porting the Font Software to a
-new environment.
-
-"Author" refers to any designer, engineer, programmer, technical
-writer or other person who contributed to the Font Software.
-
-PERMISSION & CONDITIONS
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of the Font Software, to use, study, copy, merge, embed, modify,
-redistribute, and sell modified and unmodified copies of the Font
-Software, subject to the following conditions:
-
-1) Neither the Font Software nor any of its individual components,
-in Original or Modified Versions, may be sold by itself.
-
-2) Original or Modified Versions of the Font Software may be bundled,
-redistributed and/or sold with any software, provided that each copy
-contains the above copyright notice and this license. These can be
-included either as stand-alone text files, human-readable headers or
-in the appropriate machine-readable metadata fields within text or
-binary files as long as those fields can be easily viewed by the user.
-
-3) No Modified Version of the Font Software may use the Reserved Font
-Name(s) unless explicit written permission is granted by the corresponding
-Copyright Holder. This restriction only applies to the primary font name as
-presented to the users.
-
-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
-Software shall not be used to promote, endorse or advertise any
-Modified Version, except to acknowledge the contribution(s) of the
-Copyright Holder(s) and the Author(s) or with their explicit written
-permission.
-
-5) The Font Software, modified or unmodified, in part or in whole,
-must be distributed entirely under this license, and must not be
-distributed under any other license. The requirement for fonts to
-remain under this license does not apply to any document created
-using the Font Software.
-
-TERMINATION
-This license becomes null and void if any of the above conditions are
-not met.
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
-OTHER DEALINGS IN THE FONT SOFTWARE.
--- a/licenses/fonts/JetBrainsMono-OFL.txt
+++ b/licenses/fonts/JetBrainsMono-OFL.txt
@@ -1,93 +0,0 @@
-Copyright 2020 The JetBrains Mono Project Authors (https://github.com/JetBrains/JetBrainsMono)
-
-This Font Software is licensed under the SIL Open Font License, Version 1.1.
-This license is copied below, and is also available with a FAQ at:
-https://openfontlicense.org
-
-
-----------------------------------------------------------
-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------
-
-PREAMBLE
-The goals of the Open Font License (OFL) are to stimulate worldwide
-development of collaborative font projects, to support the font creation
-efforts of academic and linguistic communities, and to provide a free and
-open framework in which fonts may be shared and improved in partnership
-with others.
-
-The OFL allows the licensed fonts to be used, studied, modified and
-redistributed freely as long as they are not sold by themselves. The
-fonts, including any derivative works, can be bundled, embedded, 
-redistributed and/or sold with any software provided that any reserved
-names are not used by derivative works. The fonts and derivatives,
-however, cannot be released under any other type of license. The
-requirement for fonts to remain under this license does not apply
-to any document created using the fonts or their derivatives.
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this license and clearly marked as such. This may
-include source files, build scripts and documentation.
-
-"Reserved Font Name" refers to any names specified as such after the
-copyright statement(s).
-
-"Original Version" refers to the collection of Font Software components as
-distributed by the Copyright Holder(s).
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting -- in part or in whole -- any of the components of the
-Original Version, by changing formats or by porting the Font Software to a
-new environment.
-
-"Author" refers to any designer, engineer, programmer, technical
-writer or other person who contributed to the Font Software.
-
-PERMISSION & CONDITIONS
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of the Font Software, to use, study, copy, merge, embed, modify,
-redistribute, and sell modified and unmodified copies of the Font
-Software, subject to the following conditions:
-
-1) Neither the Font Software nor any of its individual components,
-in Original or Modified Versions, may be sold by itself.
-
-2) Original or Modified Versions of the Font Software may be bundled,
-redistributed and/or sold with any software, provided that each copy
-contains the above copyright notice and this license. These can be
-included either as stand-alone text files, human-readable headers or
-in the appropriate machine-readable metadata fields within text or
-binary files as long as those fields can be easily viewed by the user.
-
-3) No Modified Version of the Font Software may use the Reserved Font
-Name(s) unless explicit written permission is granted by the corresponding
-Copyright Holder. This restriction only applies to the primary font name as
-presented to the users.
-
-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
-Software shall not be used to promote, endorse or advertise any
-Modified Version, except to acknowledge the contribution(s) of the
-Copyright Holder(s) and the Author(s) or with their explicit written
-permission.
-
-5) The Font Software, modified or unmodified, in part or in whole,
-must be distributed entirely under this license, and must not be
-distributed under any other license. The requirement for fonts to
-remain under this license does not apply to any document created
-using the Font Software.
-
-TERMINATION
-This license becomes null and void if any of the above conditions are
-not met.
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
-OTHER DEALINGS IN THE FONT SOFTWARE.
--- a/licenses/fonts/Lora-OFL.txt
+++ b/licenses/fonts/Lora-OFL.txt
@@ -1,93 +0,0 @@
-Copyright 2011 The Lora Project Authors (https://github.com/cyrealtype/Lora-Cyrillic), with Reserved Font Name "Lora".
-
-This Font Software is licensed under the SIL Open Font License, Version 1.1.
-This license is copied below, and is also available with a FAQ at:
-https://scripts.sil.org/OFL
-
-
-----------------------------------------------------------
-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------
-
-PREAMBLE
-The goals of the Open Font License (OFL) are to stimulate worldwide
-development of collaborative font projects, to support the font creation
-efforts of academic and linguistic communities, and to provide a free and
-open framework in which fonts may be shared and improved in partnership
-with others.
-
-The OFL allows the licensed fonts to be used, studied, modified and
-redistributed freely as long as they are not sold by themselves. The
-fonts, including any derivative works, can be bundled, embedded, 
-redistributed and/or sold with any software provided that any reserved
-names are not used by derivative works. The fonts and derivatives,
-however, cannot be released under any other type of license. The
-requirement for fonts to remain under this license does not apply
-to any document created using the fonts or their derivatives.
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this license and clearly marked as such. This may
-include source files, build scripts and documentation.
-
-"Reserved Font Name" refers to any names specified as such after the
-copyright statement(s).
-
-"Original Version" refers to the collection of Font Software components as
-distributed by the Copyright Holder(s).
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting -- in part or in whole -- any of the components of the
-Original Version, by changing formats or by porting the Font Software to a
-new environment.
-
-"Author" refers to any designer, engineer, programmer, technical
-writer or other person who contributed to the Font Software.
-
-PERMISSION & CONDITIONS
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of the Font Software, to use, study, copy, merge, embed, modify,
-redistribute, and sell modified and unmodified copies of the Font
-Software, subject to the following conditions:
-
-1) Neither the Font Software nor any of its individual components,
-in Original or Modified Versions, may be sold by itself.
-
-2) Original or Modified Versions of the Font Software may be bundled,
-redistributed and/or sold with any software, provided that each copy
-contains the above copyright notice and this license. These can be
-included either as stand-alone text files, human-readable headers or
-in the appropriate machine-readable metadata fields within text or
-binary files as long as those fields can be easily viewed by the user.
-
-3) No Modified Version of the Font Software may use the Reserved Font
-Name(s) unless explicit written permission is granted by the corresponding
-Copyright Holder. This restriction only applies to the primary font name as
-presented to the users.
-
-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
-Software shall not be used to promote, endorse or advertise any
-Modified Version, except to acknowledge the contribution(s) of the
-Copyright Holder(s) and the Author(s) or with their explicit written
-permission.
-
-5) The Font Software, modified or unmodified, in part or in whole,
-must be distributed entirely under this license, and must not be
-distributed under any other license. The requirement for fonts to
-remain under this license does not apply to any document created
-using the Font Software.
-
-TERMINATION
-This license becomes null and void if any of the above conditions are
-not met.
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
-OTHER DEALINGS IN THE FONT SOFTWARE.
--- a/licenses/fonts/README.md
+++ b/licenses/fonts/README.md
@@ -1,17 +0,0 @@
-# Bundled fonts
-
-Calendula bundles the following fonts as optional user-selectable typefaces
-(Settings → Appearance → Fonts). Each is licensed under the SIL Open Font
-License 1.1; the full license text is included alongside this file.
-
-| Font | Files (`app/src/main/res/font/`) | Copyright | License |
-|------|----------------------------------|-----------|---------|
-| Atkinson Hyperlegible | `atkinson_hyperlegible_regular.ttf`, `atkinson_hyperlegible_bold.ttf` | © 2020 Braille Institute of America, Inc. | [OFL](AtkinsonHyperlegible-OFL.txt) |
-| Lora (variable) | `lora.ttf` | © 2011 Cyreal | [OFL](Lora-OFL.txt) |
-| JetBrains Mono | `jetbrains_mono_regular.ttf`, `jetbrains_mono_bold.ttf` | © 2020 The JetBrains Mono Project Authors | [OFL](JetBrainsMono-OFL.txt) |
-
-The device's default typeface (Roboto on most Android builds) remains the
-default and is not bundled.
-
-Fonts a user loads from their own device via "Choose file…" are copied into the
-app's private storage and are not redistributed.