feat(components): let AboutCard join a grouped list

AboutCard drew its own Surface, so it could only stand alone. Taking a
Position and rendering through GroupedSurface lets it be the top of a group
with rows continuing underneath — for apps whose call to action reads better
as a row of its own than as a tonal button inside the card.

Defaults to Position.Alone, so existing callers are unchanged.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

CHANGELOG.md

@@ -6,14 +6,71 @@ All notable changes to floret-kit are documented here. The format follows
 floret-kit is consumed **from source** — each app embeds it as a git submodule
 and builds it through a Gradle composite build, pinning a specific commit. There
 are no binary releases; "version" tracks the shared `version` in the root build
-(currently `0.1.0`). Entries are grouped by module.
+(currently `0.2.1`). Entries are grouped by module.
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-07-17
+
+### Added
+
+- **`components`** — `CollapsingScaffold` takes a `scrollable` flag (default
+  `true`, so every existing caller is unchanged). Set it to `false` when the
+  content brings its own scrolling container: the scaffold's own
+  `verticalScroll` composes each row up front and can't host a `LazyColumn`
+  (nesting a same-axis scrollable throws), which ruled out any surface with more
+  options than fit an eager pass. Opting out hands the content a plain column and
+  leaves the insets, IME padding and top-bar collapse as they were.
+  `FullScreenPicker` forwards the flag. Consumed by Calendula's ~600-entry
+  time-zone picker from 2.16.0.
+
+## [0.2.0] - 2026-07-17
+
+### Added
+
+- **`components`** — `CustomAmountEditor`, the amount + unit editor behind an
+  "Custom…" picker option (Calendula's custom snooze duration). Consumed by
+  Calendula since 2.15.0.
+- **`core-locale`** — the locale-aware formatting half of the module, so apps
+  stop hand-rolling `"$day. $month $year"` templates that bake one language's
+  field order (and its separators, and its ordinal dot) into every language they
+  ship:
+  - `localizedDateFormatter(locale, skeleton)` — a `DateTimeFormatter` for a
+    field skeleton ("LLLLy", "dMMMy", "EEEdMMM") laid out in the locale's own
+    order, via Android's best-pattern matching. Drop a field from the skeleton to
+    drop it from the output — the locale still supplies the arrangement.
+  - `currentLocale()` — the display locale, observed from `LocalConfiguration`.
+    Since `AppLanguage.apply()` changes the language inside a running process, a
+    locale captured once goes stale; this keys recomposition to the change.
+
+### Changed
+
+- **`core-locale`** now carries Compose (runtime + ui only) for `currentLocale()`.
+  The module previously declared itself Compose-free; applying a language
+  mid-process is its own API, so the hook that makes the UI notice belongs beside
+  it rather than in a Compose module depending back on this one. `core-crash` is
+  the precedent for a `core-*` module carrying Compose.
+
+### Known gaps
+
+- `core-time`'s `Instant.formatDate()` family now overlaps `core-locale`. Its
+  private `dateNoYearFormatter` strips the year by regex-ing the pattern string,
+  which `localizedDateFormatter(locale, "dMMM")` does properly; and its
+  formatters resolve `Locale.getDefault()` once at class-init ("locale changes
+  within a running process are rare enough to ignore"), which `AppLanguage.apply()`
+  makes untrue. Left alone for now — it is unused by Calendula but Agendula-visible.
+  Reconcile when Agendula next re-pins.
+
 ## [0.1.0] - 2026-07-07
 
 ### Added
 
+- **`core-locale`** (Android library) — per-app language plumbing (`AppLanguage`):
+  read the shipped languages from the app's `res/xml/locales_config.xml`, get/set
+  the applied language via `AppCompatDelegate`, render each language's autonym.
+  The app passes its own `locales_config` resource id; the system-default choice
+  is `null`. _(Shipped in 0.1.0 but omitted from this changelog at the time;
+  recorded here retroactively.)_
 - **`core-time`** (JVM library) — pure-Kotlin date/time helpers, no Android and
   no third-party dependencies:
   - `DayWindow.today()` — local-day boundaries for smart-list logic.

README.md

@@ -36,7 +36,7 @@ See [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) for the full consumption mode
 |--------|------|---------------|
 | `core-time` | JVM | Date/time helpers: `DayWindow` local-day windows, locale/zone-aware `Instant` formatting, `TimeBridge` (millis ↔ `Instant`). No Android, no deps. |
 | `core-reminders` | JVM | Reminder-lead plumbing: the lead-time unit model (`ReminderUnit`, `decomposeReminderMinutes`), the per-target override model (`ReminderOverride` + `reminderLeadFor` / `applyReminderOverride`) and the stored-format codec (`ReminderOverrideCodec`, separators configurable per app). Each app layers its own DataStore + string labels on top. |
-| `core-locale` | Android | Per-app language plumbing (`AppLanguage`): read the shipped languages from the app's `res/xml/locales_config.xml`, get/set the applied language via `AppCompatDelegate`, render each language's autonym. The app passes its own `locales_config`; appcompat only, no Compose. |
+| `core-locale` | Android | Everything "what language are we in". Per-app language plumbing (`AppLanguage`): read the shipped languages from the app's `res/xml/locales_config.xml`, get/set the applied language via `AppCompatDelegate`, render each language's autonym. Plus `currentLocale()` (observes the applied language from Compose) and `localizedDateFormatter(locale, skeleton)` (lays a field skeleton out in the locale's own order). The app passes its own `locales_config`. |
 | `core-crash` | Android | Privacy-respecting on-device crash capture + report dialog + issue-tracker hand-off. Parameterized per app via `CrashConfig`. |
 | `identity` | Android | The M3 Expressive theme factory `FloretExpressiveTheme(…)`, `rememberNavSlideSpec()`, the content transitions (`expandEnter`/`collapseExit`/`itemEnter`/…) and the `predictiveBack` peek. Each app supplies its own seed/palette. |
 | `components` | Android | Shared Compose vocabulary + recipes: `GroupedSurface`/`GroupedRow`, `InlineTextField`, `OptionCard`, `CollapsingScaffold`, `OptionPicker`, `ReorderableColumn`, `DebugRibbon`, `pastelize()`, `DialogControls`, `OnboardingScaffold`, `OptionalFormSection`, `AboutCard`, `LanguagePickerRow`. |

build.gradle.kts

@@ -10,5 +10,5 @@ plugins {
 
 subprojects {
     group = "de.jeanlucmakiola.floret"
-    version = "0.2.0"
+    version = "0.2.1"
 }

components/build.gradle.kts

@@ -39,6 +39,8 @@ dependencies {
     // core-locale backs the language-picker recipe (AppLanguage).
     implementation(project(":core-locale"))
 
+    implementation(libs.androidx.core.ktx)
+
     implementation(platform(libs.androidx.compose.bom))
     implementation(libs.androidx.ui)
     implementation(libs.androidx.foundation)

components/src/main/kotlin/de/jeanlucmakiola/floret/components/CollapsingScaffold.kt

@@ -46,6 +46,16 @@ import de.jeanlucmakiola.floret.identity.predictiveBack
  * unchanged: [actions] adds trailing app-bar items; [snackbarHost] hosts
  * transient messages; [predictiveBack] (off by default) wires the gesture
  * preview to [onBack] for full-screen surfaces that want it.
+ *
+ * Set [scrollable] to false when [content] brings its own scrolling container.
+ * The default column scrolls as a whole, which composes every row up front —
+ * fine for the short lists these surfaces normally hold, but a list long enough
+ * to need a [androidx.compose.foundation.lazy.LazyColumn] can neither nest one
+ * inside it (same-axis scrolling throws) nor afford the eager pass. Opting out
+ * hands [content] a plain, unscrolled column to fill instead; the insets, IME
+ * padding and bar behaviour are unchanged, so a lazy list simply takes over the
+ * scrolling and gets the top bar's collapse for free through the shared
+ * nested-scroll connection.
  */
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -55,6 +65,7 @@ fun CollapsingScaffold(
     modifier: Modifier = Modifier,
     largeTopBar: Boolean = true,
     predictiveBack: Boolean = false,
+    scrollable: Boolean = true,
     actions: @Composable RowScope.() -> Unit = {},
     snackbarHost: @Composable () -> Unit = {},
     content: @Composable ColumnScope.() -> Unit,
@@ -112,8 +123,19 @@ fun CollapsingScaffold(
                 .fillMaxSize()
                 .background(MaterialTheme.colorScheme.surface)
                 .imePadding()
+                .then(
+                    if (scrollable) {
+                        Modifier
                             .verticalScroll(rememberScrollState())
-                .padding(top = 8.dp, bottom = 24.dp),
+                            .padding(top = 8.dp, bottom = 24.dp)
+                    } else {
+                        // The content scrolls itself, so it also owns the edge
+                        // spacing — a lazy list wants it as contentPadding, or
+                        // the first and last rows clip instead of scrolling
+                        // under the bars.
+                        Modifier
+                    },
+                ),
             content = content,
         )
     }

components/src/main/kotlin/de/jeanlucmakiola/floret/components/GroupedList.kt

@@ -37,6 +37,16 @@ fun positionOf(index: Int, count: Int): Position = when {
     else -> Position.Middle
 }
 
+/**
+ * The inset a grouped list keeps from the screen edge.
+ *
+ * Exported because it is a *shared* line, not a private detail of [GroupedRow]:
+ * everything that sits outside the cards but belongs to them — section headers,
+ * hints, picker descriptions — has to start on the same edge, or the page reads
+ * as two ragged columns. Take this value rather than writing 16.dp again.
+ */
+val GroupedListInset = 16.dp
+
 /** Corner radii for a grouped segment: full at the group's outer edges, small between. */
 fun groupedShape(position: Position, full: Dp, small: Dp): Shape = when (position) {
     Position.Alone -> RoundedCornerShape(full)
@@ -140,7 +150,7 @@ fun GroupedRow(
     }
     GroupedSurface(
         position = position,
-        modifier = modifier.padding(horizontal = 16.dp),
+        modifier = modifier.padding(horizontal = GroupedListInset),
         onClick = onClick,
         color = containerColor,
         gapBelow = gapBelow,

components/src/main/kotlin/de/jeanlucmakiola/floret/components/OptionPicker.kt

@@ -13,6 +13,8 @@ import androidx.compose.ui.platform.LocalView
 import androidx.compose.ui.window.Dialog
 import androidx.compose.ui.window.DialogProperties
 import androidx.compose.ui.window.DialogWindowProvider
+import androidx.core.view.WindowCompat
+import de.jeanlucmakiola.floret.identity.LocalFloretDarkTheme
 
 /**
  * Full-screen scaffold for selection pickers: a full-bleed [Dialog] that reuses
@@ -20,12 +22,31 @@ import androidx.compose.ui.window.DialogWindowProvider
  * width without a tall header — it's a short selection list, so the large
  * collapsing header would only be empty space to scroll past. [content] places
  * the connected grouped rows; selecting one calls [onDismiss].
+ *
+ * [scrollable] forwards to [CollapsingScaffold]: leave it on unless [content]
+ * scrolls itself, which a picker only needs for an option list long enough to
+ * warrant a lazy container.
+ *
+ * **Picker richness.** Three shapes, in ascending order — take the cheapest one
+ * that makes the choice obvious:
+ * 1. plain option rows, when the label *is* the meaning ("English", "Dark");
+ * 2. rows plus a per-option summary of the concrete effect, when the meaning is
+ *    a date, a time or a number the label only names ("Next 7 days" →
+ *    "30 Jul – 5 Aug"). [OptionPicker]'s `summary` covers this;
+ * 3. a live preview above the rows, when the effect is *visual* and no words
+ *    carry it (month grid style, dimmed past events, week start).
+ *
+ * A picker of the third kind **must not close when an option is tapped** — it
+ * applies immediately and stays open, because closing would hide the very thing
+ * the screen exists to show. The user leaves via back. The first two kinds close
+ * on tap as usual.
  */
 @Composable
 fun FullScreenPicker(
     title: String,
     onDismiss: () -> Unit,
     predictiveBack: Boolean = false,
+    scrollable: Boolean = true,
     actions: @Composable RowScope.() -> Unit = {},
     content: @Composable ColumnScope.() -> Unit,
 ) {
@@ -36,20 +57,35 @@ fun FullScreenPicker(
             decorFitsSystemWindows = false,
         ),
     ) {
-        // The dialog window pans by default when the keyboard opens, which —
+        // A Compose Dialog owns a separate android.view.Window whose bar-icon
+        // appearance is seeded from the XML theme, not from the activity window's
+        // runtime edge-to-edge state — so with decorFitsSystemWindows = false it
+        // draws edge-to-edge under bars whose icons don't match the active theme
+        // (dark icons on a dark picker). Drive the appearance from the runtime
+        // [LocalFloretDarkTheme] so it tracks the in-app light/dark choice even
+        // when that diverges from the system night qualifier.
+        //
+        // Same window also pans by default when the keyboard opens, which —
         // combined with the content's own imePadding — leaves a fixed black gap
         // above the keyboard. Switch it to ADJUST_NOTHING so the window stays
         // full-screen and imePadding alone lifts the focused field.
         val view = LocalView.current
+        val darkTheme = LocalFloretDarkTheme.current
         SideEffect {
-            (view.parent as? DialogWindowProvider)?.window
-                ?.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING)
+            (view.parent as? DialogWindowProvider)?.window?.let { window ->
+                window.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING)
+                WindowCompat.getInsetsController(window, view).apply {
+                    isAppearanceLightStatusBars = !darkTheme
+                    isAppearanceLightNavigationBars = !darkTheme
+                }
+            }
         }
         CollapsingScaffold(
             title = title,
             onBack = onDismiss,
             largeTopBar = false,
             predictiveBack = predictiveBack,
+            scrollable = scrollable,
             actions = actions,
             content = content,
         )
@@ -60,6 +96,15 @@ fun FullScreenPicker(
  * General single-select picker, full-screen: each option is a connected grouped
  * row and the current one carries a check. The drop-in for the family's option
  * dialogs (theme, default list, reminder offset, …).
+ *
+ * [summary] adds a second line per option — reserve it for the option's
+ * *concrete effect*, the thing its label names but doesn't spell out: the dates
+ * a range resolves to, the time a format renders as, what "follow the system"
+ * currently means. Returning null leaves that row single-line, so one option
+ * (typically the automatic one) can carry a note the others don't need. It is
+ * the cheap middle rung of the richness ladder described on [FullScreenPicker]:
+ * every option shows its effect at once and stays comparable, without the cost
+ * of a live preview.
  */
 @Composable
 fun <T> OptionPicker(
@@ -69,6 +114,7 @@ fun <T> OptionPicker(
     label: @Composable (T) -> String,
     onSelect: (T) -> Unit,
     onDismiss: () -> Unit,
+    summary: (@Composable (T) -> String?)? = null,
     leading: (@Composable (T) -> Unit)? = null,
     header: (@Composable ColumnScope.() -> Unit)? = null,
     predictiveBack: Boolean = false,
@@ -79,6 +125,7 @@ fun <T> OptionPicker(
             val isSelected = option == selected
             GroupedRow(
                 title = label(option),
+                summary = summary?.invoke(option),
                 position = positionOf(index, options.size),
                 selected = isSelected,
                 leading = leading?.let { { it(option) } },
@@ -96,8 +143,18 @@ fun <T> OptionPicker(
     }
 }
 
+/**
+ * The trailing check that marks the chosen row in a full-screen picker — the
+ * family's single selection affordance, so every picker (option, reminder,
+ * agenda range, timezone, calendar, recurrence) marks its selection the same
+ * way. Pair it with `GroupedRow(selected = true)`: the tonal highlight carries
+ * the state at a glance, the check confirms it unambiguously.
+ *
+ * Purely decorative — the row itself owns the semantics, so it takes no
+ * content description.
+ */
 @Composable
-private fun SelectedCheck() {
+fun SelectedCheck() {
     Icon(
         imageVector = Icons.Rounded.Check,
         contentDescription = null,

components/src/main/kotlin/de/jeanlucmakiola/floret/components/SettingsRecipes.kt

@@ -13,12 +13,10 @@ 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.shape.RoundedCornerShape
 import androidx.compose.material3.FilledTonalButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedButton
-import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
@@ -41,6 +39,12 @@ data class AboutLink(val icon: ImageVector, val label: String, val url: String)
  * outlined buttons (e.g. source, licence) and an optional full-width
  * [highlightLink] tonal button (e.g. donate). Each link opens its URL in the
  * browser. The app supplies its own logo, strings and links.
+ *
+ * [position] lets the card join a grouped list instead of standing alone: with
+ * [Position.Top] it takes the group's top corners and the 2dp gap below, so a
+ * [GroupedRow] underneath continues the same container. Use that when the card's
+ * call to action reads better as a row of its own than as a button inside the
+ * card — the two then form one block rather than a card with a lid on it.
  */
 @Composable
 fun AboutCard(
@@ -49,15 +53,16 @@ fun AboutCard(
     author: String,
     primaryLinks: List<AboutLink>,
     highlightLink: AboutLink? = null,
+    position: Position = Position.Alone,
 ) {
     val context = LocalContext.current
     val open = { url: String ->
         runCatching { context.startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url))) }
         Unit
     }
-    Surface(
+    GroupedSurface(
+        position = position,
         color = MaterialTheme.colorScheme.surfaceContainerHigh,
-        shape = RoundedCornerShape(24.dp),
         modifier = Modifier.fillMaxWidth(),
     ) {
         Column(Modifier.fillMaxWidth().padding(16.dp)) {

core-locale/build.gradle.kts

@@ -1,10 +1,20 @@
-// core-locale — per-app language plumbing shared across the family: read the
-// shipped languages from res/xml/locales_config.xml, get/set the applied
-// language via AppCompatDelegate, and render each language's autonym. App-
-// agnostic — the consuming app passes its own locales_config resource id; no
-// Compose, no DataStore.
+// core-locale — everything "what language are we in", shared across the family:
+// read the shipped languages from res/xml/locales_config.xml, get/set the applied
+// language via AppCompatDelegate, render each language's autonym, observe the
+// current locale from Compose, and format dates in that locale's own field order.
+// App-agnostic — the consuming app passes its own locales_config resource id; no
+// DataStore.
+//
+// Compose is here for currentLocale() alone: applying a language mid-process is
+// this module's own API, so the hook that makes the UI notice belongs beside it
+// rather than in a Compose module that would have to depend back on this one.
+// (core-crash is the precedent for a core-* module carrying Compose.) Deliberately
+// lean: runtime + ui only, no material3, no foundation.
 plugins {
+    // AGP 9.x provides built-in Kotlin compilation, so only the Compose plugin is
+    // applied alongside the Android library plugin.
     alias(libs.plugins.android.library)
+    alias(libs.plugins.kotlin.compose)
 }
 
 android {
@@ -20,6 +30,10 @@ android {
         targetCompatibility = JavaVersion.VERSION_17
     }
 
+    buildFeatures {
+        compose = true
+    }
+
     testOptions {
         unitTests {
             all { it.useJUnitPlatform() }
@@ -39,6 +53,16 @@ dependencies {
     // annotation (XmlRes) transitives.
     implementation(libs.androidx.appcompat)
 
+    // ConfigurationCompat for currentLocale(). Reachable transitively via
+    // appcompat, but declared because this module uses it directly.
+    implementation(libs.androidx.core.ktx)
+
+    // currentLocale() only needs the runtime (@Composable, remember) and ui
+    // (LocalConfiguration) — api() so consumers can use the returned Locale in
+    // their own composables without re-declaring Compose themselves.
+    api(platform(libs.androidx.compose.bom))
+    implementation(libs.androidx.ui)
+
     testImplementation(libs.junit.jupiter.api)
     testRuntimeOnly(libs.junit.jupiter.engine)
     testRuntimeOnly(libs.junit.platform.launcher)

core-locale/src/main/kotlin/de/jeanlucmakiola/floret/locale/DateFormatting.kt

@@ -0,0 +1,33 @@
+package de.jeanlucmakiola.floret.locale
+
+import java.time.format.DateTimeFormatter
+import java.util.Locale
+
+/**
+ * A [DateTimeFormatter] for [skeleton]'s fields laid out in [locale]'s own order,
+ * via Android's best-pattern matching.
+ *
+ * A skeleton lists the *fields* you want, not their arrangement: "dMMMy" asks for
+ * day, abbreviated month and year, and the locale decides that en-US renders
+ * "Jul 17, 2026" while de-DE renders "17. Juli 2026". Hand-rolled templates like
+ * `"$day. $month $year"` can't do this — they bake one locale's order (and its
+ * separators, and its ordinal dot) into every language the app ships.
+ *
+ * Drop a field to drop it from the output: "dMMM" is the same date without the
+ * year, still in the locale's order. Prefer that over post-processing a longer
+ * pattern, which cannot know which separators belonged to the removed field.
+ *
+ * Common skeletons: "LLLLy" (standalone month + year), "dMMMy" (day, month, year),
+ * "EEEdMMM" (weekday too). [locale] should come from [currentLocale] in Compose,
+ * so formatting follows an in-process language change.
+ *
+ * NB: this delegates to `android.text.format.DateFormat`, so it needs a real
+ * Android runtime — under unit tests with `isReturnDefaultValues` it yields no
+ * pattern. Test the skeleton *choice* in your own code; the layout itself is ICU's
+ * job and is not worth mocking.
+ */
+fun localizedDateFormatter(locale: Locale, skeleton: String): DateTimeFormatter =
+    DateTimeFormatter.ofPattern(
+        android.text.format.DateFormat.getBestDateTimePattern(locale, skeleton),
+        locale,
+    )

core-locale/src/main/kotlin/de/jeanlucmakiola/floret/locale/LocaleCompose.kt

@@ -0,0 +1,26 @@
+package de.jeanlucmakiola.floret.locale
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.core.os.ConfigurationCompat
+import java.util.Locale
+
+/**
+ * The current display [Locale], read observably from [LocalConfiguration].
+ *
+ * Use this rather than [Locale.getDefault] anywhere a composable formats a date,
+ * a name or a number. [AppLanguage.apply] changes the language inside a running
+ * process, so a locale captured once — in a `val`, a top-level formatter, or a
+ * `remember {}` with no key — goes stale and keeps rendering the old language.
+ * Reading through [LocalConfiguration] keys recomposition to the configuration,
+ * so the UI follows the switch. (Android lint flags the alternative as
+ * NonObservableLocale.)
+ */
+@Composable
+fun currentLocale(): Locale {
+    val configuration = LocalConfiguration.current
+    return remember(configuration) {
+        ConfigurationCompat.getLocales(configuration).get(0) ?: Locale.getDefault()
+    }
+}

docs/ROADMAP.md

@@ -13,6 +13,7 @@ divergent or app-specific code where it lives.
 |---|---|---|
 | `core-time` | JVM | Agendula (and Calendula's pending branch) |
 | `core-reminders` | JVM | Agendula (and Calendula's pending branch) |
+| `core-locale` | Android | Agendula, Calendula |
 | `core-crash` | Android | Agendula |
 | `identity` | Android | Agendula |
 | `components` | Android | Agendula |

identity/src/main/kotlin/de/jeanlucmakiola/floret/identity/Theme.kt

@@ -10,8 +10,19 @@ import androidx.compose.material3.Typography
 import androidx.compose.material3.dynamicDarkColorScheme
 import androidx.compose.material3.dynamicLightColorScheme
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.ui.platform.LocalContext
 
+/**
+ * The resolved light/dark decision the current [FloretExpressiveTheme] is running
+ * with, carried down the tree so components can align window chrome (e.g. status-
+ * and navigation-bar icon appearance) with the *runtime* theme rather than the
+ * system night resource qualifier — the two diverge whenever an app overrides
+ * light/dark from settings. Defaults to `false` (light) outside a Floret theme.
+ */
+val LocalFloretDarkTheme = staticCompositionLocalOf { false }
+
 /**
  * The family's Material 3 Expressive theme factory. Honours system light/dark
  * and Material You dynamic colour (API 31+), falling back to the app-supplied
@@ -43,10 +54,12 @@ fun FloretExpressiveTheme(
         else -> lightScheme
     }
 
+    CompositionLocalProvider(LocalFloretDarkTheme provides darkTheme) {
         MaterialExpressiveTheme(
             colorScheme = colorScheme,
             typography = typography,
             motionScheme = MotionScheme.standard(),
             content = content,
         )
+    }
 }