fix(build): revert ui-tooling-preview to implementation scope

The previous batch fix tried to move ui-tooling-preview to
debugImplementation per a reviewer suggestion, but @Preview is used
in MainActivity.kt which lives in the main source set, so the
annotation class must be available at release-build compile time.

Moving @Preview composables to a debug-only source set would let the
dep stay debug-scoped - that is a Plan 02+ refactor, not foundation
work.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

.gitea/workflows/ci.yaml

@@ -0,0 +1,91 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - '**'
+    tags-ignore:
+      - '**'
+  pull_request:
+
+jobs:
+  ci:
+    runs-on: docker
+    env:
+      ANDROID_HOME: /opt/android-sdk
+      ANDROID_SDK_ROOT: /opt/android-sdk
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'zulu'
+          java-version: '17'
+
+      - name: Setup Android SDK
+        uses: android-actions/setup-android@v3
+
+      - name: Install Android SDK packages
+        run: |
+          yes | sdkmanager --licenses >/dev/null || true
+          sdkmanager \
+            "platform-tools" \
+            "platforms;android-36" \
+            "platforms;android-37.0" \
+            "build-tools;36.0.0"
+
+      - name: Install jq
+        run: |
+          set -e
+          SUDO=""
+          if command -v sudo >/dev/null 2>&1; then
+            SUDO="sudo"
+          fi
+          if command -v apt-get >/dev/null 2>&1; then
+            $SUDO apt-get update
+            $SUDO apt-get install -y jq
+          elif command -v apk >/dev/null 2>&1; then
+            $SUDO apk add --no-cache jq
+          fi
+
+      - name: Setup Gradle cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties', 'gradle/libs.versions.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+
+      - name: Grant execute permission for gradlew
+        run: chmod +x ./gradlew
+
+      - name: Lint
+        run: ./gradlew lint --no-daemon
+
+      - name: Unit tests
+        run: ./gradlew test --no-daemon
+
+      - name: Assemble debug APK
+        run: ./gradlew assembleDebug --no-daemon
+
+      - name: Trivy filesystem scan
+        run: |
+          set -e
+          SUDO=""
+          if command -v sudo >/dev/null 2>&1; then
+            SUDO="sudo"
+          fi
+          if command -v apt-get >/dev/null 2>&1; then
+            $SUDO apt-get update
+            $SUDO apt-get install -y wget apt-transport-https gnupg lsb-release
+            wget -qO - https://aquasecurity.github.io/trivy-repo/deb/public.key | gpg --dearmor | $SUDO tee /usr/share/keyrings/trivy.gpg > /dev/null
+            echo "deb [signed-by=/usr/share/keyrings/trivy.gpg] https://aquasecurity.github.io/trivy-repo/deb generic main" | $SUDO tee /etc/apt/sources.list.d/trivy.list
+            $SUDO apt-get update
+            $SUDO apt-get install -y trivy
+          fi
+          trivy filesystem --severity HIGH,CRITICAL --exit-code 0 .
+        continue-on-error: true

.gitea/workflows/release.yaml

@@ -0,0 +1,183 @@
+name: Build and Release to F-Droid
+
+on:
+  push:
+    tags:
+      - '*'
+  workflow_dispatch:
+
+jobs:
+  ci:
+    runs-on: docker
+    env:
+      ANDROID_HOME: /opt/android-sdk
+      ANDROID_SDK_ROOT: /opt/android-sdk
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'zulu'
+          java-version: '17'
+
+      - name: Setup Android SDK
+        uses: android-actions/setup-android@v3
+
+      - name: Install Android SDK packages
+        run: |
+          yes | sdkmanager --licenses >/dev/null || true
+          sdkmanager \
+            "platform-tools" \
+            "platforms;android-36" \
+            "platforms;android-37.0" \
+            "build-tools;36.0.0"
+
+      - name: Grant execute permission for gradlew
+        run: chmod +x ./gradlew
+
+      - name: Lint + tests + debug build (sanity)
+        run: ./gradlew lint test assembleDebug --no-daemon
+
+  build-and-deploy:
+    needs: ci
+    runs-on: docker
+    env:
+      ANDROID_HOME: /opt/android-sdk
+      ANDROID_SDK_ROOT: /opt/android-sdk
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'zulu'
+          java-version: '17'
+
+      - name: Setup Android SDK
+        uses: android-actions/setup-android@v3
+
+      - name: Install Android SDK packages
+        run: |
+          yes | sdkmanager --licenses >/dev/null || true
+          sdkmanager \
+            "platform-tools" \
+            "platforms;android-36" \
+            "platforms;android-37.0" \
+            "build-tools;36.0.0"
+
+      - name: Install jq
+        run: |
+          set -e
+          SUDO=""
+          if command -v sudo >/dev/null 2>&1; then SUDO="sudo"; fi
+          if command -v apt-get >/dev/null 2>&1; then
+            $SUDO apt-get update
+            $SUDO apt-get install -y jq
+          elif command -v apk >/dev/null 2>&1; then
+            $SUDO apk add --no-cache jq
+          fi
+
+      - name: Set version from git tag
+        run: |
+          set -e
+          RAW_TAG="${GITHUB_REF_NAME:-${GITHUB_REF##*/}}"
+          VERSION="${RAW_TAG#v}"
+          MAJOR=$(echo "$VERSION" | cut -d. -f1)
+          MINOR=$(echo "$VERSION" | cut -d. -f2)
+          PATCH=$(echo "$VERSION" | cut -d. -f3)
+          MAJOR=${MAJOR:-0}; MINOR=${MINOR:-0}; PATCH=${PATCH:-0}
+          VERSION_CODE=$(( MAJOR * 10000 + MINOR * 100 + PATCH ))
+          echo "Version: $VERSION, VersionCode: $VERSION_CODE"
+          sed -i "s/versionName = \".*\"/versionName = \"$VERSION\"/" app/build.gradle.kts
+          sed -i "s/versionCode = .*/versionCode = $VERSION_CODE/" app/build.gradle.kts
+          grep -E 'versionName|versionCode' app/build.gradle.kts
+
+      - name: Setup Android Keystore
+        env:
+          KEYSTORE_BASE64: ${{ secrets.KEYSTORE_BASE64 }}
+          KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}
+          KEY_ALIAS: ${{ secrets.KEY_ALIAS }}
+        run: |
+          mkdir -p app
+          echo "$KEYSTORE_BASE64" | base64 --decode > app/upload-keystore.jks
+          cat > key.properties <<EOF
+          storePassword=$KEY_PASSWORD
+          keyPassword=$KEY_PASSWORD
+          keyAlias=$KEY_ALIAS
+          storeFile=upload-keystore.jks
+          EOF
+
+      - name: Grant execute permission for gradlew
+        run: chmod +x ./gradlew
+
+      - name: Build release APK
+        run: ./gradlew assembleRelease --no-daemon
+
+      - name: Setup F-Droid Server Tools
+        run: |
+          SUDO=""
+          if command -v sudo >/dev/null 2>&1; then SUDO="sudo"; fi
+          $SUDO apt-get update
+          $SUDO apt-get install -y sshpass python3-pip
+          pip3 install --break-system-packages --upgrade fdroidserver
+
+      - name: Initialize or fetch F-Droid Repository
+        env:
+          HOST: ${{ secrets.HETZNER_HOST }}
+          USER: ${{ secrets.HETZNER_USER }}
+          PASS: ${{ secrets.HETZNER_PASS }}
+        run: |
+          mkdir -p fdroid
+          sshpass -p "$PASS" sftp -o StrictHostKeyChecking=no "$USER@$HOST" <<'SFTP'
+          -mkdir dev
+          -mkdir dev/fdroid
+          -mkdir dev/fdroid/repo
+          SFTP
+          sshpass -p "$PASS" scp -o StrictHostKeyChecking=no -r "$USER@$HOST:dev/fdroid/." fdroid/ || (cd fdroid && fdroid init)
+
+      - name: Ensure F-Droid repo signing key and icon
+        run: |
+          cd fdroid
+          mkdir -p repo/icons
+          if [ ! -f keystore.p12 ]; then
+            fdroid update --create-key
+          fi
+
+      - name: Copy new APK to repo
+        run: |
+          set -e
+          mkdir -p fdroid/repo
+          REF_NAME="${GITHUB_REF_NAME:-${GITHUB_REF##*/}}"
+          SAFE_REF_NAME="$(echo "$REF_NAME" | tr '/ ' '__' | tr -cd '[:alnum:]_.-')"
+          if [ -z "$SAFE_REF_NAME" ]; then
+            SAFE_REF_NAME="${GITHUB_SHA:-manual}"
+          fi
+          cp app/build/outputs/apk/release/app-release.apk "fdroid/repo/calendula_${SAFE_REF_NAME}.apk"
+
+      - name: Copy metadata to F-Droid repo
+        run: |
+          mkdir -p fdroid/metadata
+          cp -r fdroid-metadata/* fdroid/metadata/
+
+      - name: Generate F-Droid Index
+        run: |
+          cd fdroid
+          fdroid update -c
+
+      - name: Upload Repo to Hetzner
+        env:
+          HOST: ${{ secrets.HETZNER_HOST }}
+          USER: ${{ secrets.HETZNER_USER }}
+          PASS: ${{ secrets.HETZNER_PASS }}
+        run: |
+          set -euo pipefail
+          SSH_OPTS="-o StrictHostKeyChecking=no -o ConnectTimeout=20"
+          sshpass -p "$PASS" sftp $SSH_OPTS "$USER@$HOST" <<'SFTP'
+          -mkdir dev
+          -mkdir dev/fdroid
+          -mkdir dev/fdroid/repo
+          SFTP
+          sshpass -p "$PASS" scp $SSH_OPTS -r fdroid/. "$USER@$HOST:dev/fdroid/"

.planning/REQUIREMENTS.md

@@ -5,11 +5,11 @@ See full design spec: `docs/superpowers/specs/2026-06-08-calendar-app-design.md`
 ## V1 Scope (Variant "B")
 
 ### Validated (shipped)
-- (none yet — first milestone in progress)
+- Foundation & CI infrastructure — v0.1.0 (2026-06-08)
 
 ### Active (V1)
 
-- [ ] Foundation & CI infrastructure
+- [x] Foundation & CI infrastructure
 - [ ] Data Layer over `CalendarContract`
 - [ ] Permission flow (`READ_CALENDAR`)
 - [ ] Month view (S1)

.planning/ROADMAP.md

@@ -4,7 +4,7 @@
 
 | Version | Milestone | Status |
 |---|---|---|
-| v0.1 | Foundation & CI | in progress |
+| v0.1 | Foundation & CI | complete |
 | v0.2 | Data Layer & Permission Flow | pending |
 | v0.3 | Month view | pending |
 | v0.4 | Week view | pending |

.planning/STATE.md

@@ -5,17 +5,18 @@
 ## Status
 
 **Milestone:** v0.1 — Foundation & CI
-**Phase:** Implementation in progress (Plan 01 active)
+**Phase:** Plan 01 complete; ready to start Plan 02
 
 ## Progress
 
 - [x] Design spec written and committed (`docs/superpowers/specs/2026-06-08-calendar-app-design.md`)
 - [x] V1 design decisions resolved (App name "Calendula", icon, seed color)
-- [x] Plan 01 written (`docs/superpowers/plans/2026-06-08-01-foundation.md`)
-- [ ] Plan 01 executed
+- [x] Plan 01 written and executed (`docs/superpowers/plans/2026-06-08-01-foundation.md`)
+- [x] Foundation lands: theme, icon, i18n, Hilt, DataStore, CI green
+- [ ] Plan 02 written (Data Layer & Permission Flow)
 
 ## Next
 
-1. Execute Plan 01 to land foundation
-2. Write and execute Plan 02 (Data Layer & Permission Flow)
+1. Write Plan 02: Data Layer & Permission Flow
+2. Execute Plan 02
 3. Iterate on UI design (mockups) before screens are built

CHANGELOG.md

@@ -7,9 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.0] — 2026-06-08
+
 ### Added
-- Initial project scaffold with Material 3 Expressive theme
-- Adaptive launcher icon (numeral "1" on slate squircle, referencing *kalendae*)
+- Initial project scaffold (Gradle Kotlin DSL, Version Catalog, Hilt, DataStore)
+- Material 3 Expressive theme with Dynamic Color (API 31+) and slate-derived fallback
+- Adaptive launcher icon — stylized "1" on slate squircle (references *kalendae*)
 - German + English localization infrastructure
-- Hilt + DataStore dependency injection and preferences setup
-- Gitea CI/CD workflows for build, test, lint, and release
+- Permission declaration for `READ_CALENDAR` (no UI flow yet — that's Plan 02)
+- Gitea CI workflow: lint, unit tests, debug build, Trivy scan
+- Gitea release workflow: signed release APK + F-Droid metadata sync to Hetzner
+- F-Droid metadata stubs (DE + EN short/full descriptions)
+- `.planning/` project-tracking documents

app/build.gradle.kts

@@ -1,3 +1,6 @@
+import java.util.Properties
+import java.io.FileInputStream
+
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.compose)
@@ -5,9 +8,16 @@ plugins {
     alias(libs.plugins.hilt)
 }
 
+val keystorePropertiesFile = rootProject.file("key.properties")
+val keystoreProperties = Properties().apply {
+    if (keystorePropertiesFile.exists()) {
+        load(FileInputStream(keystorePropertiesFile))
+    }
+}
+
 android {
     namespace = "de.jeanlucmakiola.calendula"
-    compileSdk = 36
+    compileSdk = 37
 
     defaultConfig {
         applicationId = "de.jeanlucmakiola.calendula"
@@ -19,6 +29,17 @@ android {
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
 
+    signingConfigs {
+        if (keystorePropertiesFile.exists()) {
+            create("release") {
+                keyAlias = keystoreProperties["keyAlias"] as String
+                keyPassword = keystoreProperties["keyPassword"] as String
+                storeFile = file(keystoreProperties["storeFile"] as String)
+                storePassword = keystoreProperties["storePassword"] as String
+            }
+        }
+    }
+
     buildTypes {
         release {
             isMinifyEnabled = true
@@ -27,6 +48,9 @@ android {
                 getDefaultProguardFile("proguard-android-optimize.txt"),
                 "proguard-rules.pro"
             )
+            if (keystorePropertiesFile.exists()) {
+                signingConfig = signingConfigs.getByName("release")
+            }
         }
         debug {
             applicationIdSuffix = ".debug"

app/src/androidTest/java/de/jeanlucmakiola/calendula/MainActivitySmokeTest.kt

@@ -0,0 +1,26 @@
+package de.jeanlucmakiola.calendula
+
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class MainActivitySmokeTest {
+
+    @get:Rule
+    val composeTestRule = createAndroidComposeRule<MainActivity>()
+
+    @Test
+    fun appName_isDisplayed_onLaunch() {
+        composeTestRule.onNodeWithText("Calendula").assertIsDisplayed()
+    }
+
+    @Test
+    fun tagline_isDisplayed_onLaunch() {
+        composeTestRule.onNodeWithText("A modern calendar.").assertIsDisplayed()
+    }
+}

app/src/main/AndroidManifest.xml

@@ -17,9 +17,7 @@
         tools:targetApi="35">
         <activity
             android:name=".MainActivity"
-            android:exported="true"
-            android:label="@string/app_name"
-            android:theme="@style/Theme.Calendula">
+            android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />

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

@@ -0,0 +1,11 @@
+package de.jeanlucmakiola.calendula
+
+import android.app.Application
+import dagger.hilt.android.HiltAndroidApp
+
+/**
+ * Application entry point. Registered as android:name=".CalendulaApp"
+ * in AndroidManifest.xml. Hilt initializes its component graph here.
+ */
+@HiltAndroidApp
+class CalendulaApp : Application()

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

@@ -0,0 +1,59 @@
+package de.jeanlucmakiola.calendula
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import dagger.hilt.android.AndroidEntryPoint
+import de.jeanlucmakiola.calendula.ui.theme.CalendulaTheme
+
+@AndroidEntryPoint
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        enableEdgeToEdge()
+        setContent {
+            CalendulaTheme {
+                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
+                    PlaceholderScreen(modifier = Modifier.padding(innerPadding))
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun PlaceholderScreen(modifier: Modifier = Modifier) {
+    Column(
+        modifier = modifier.fillMaxSize(),
+        verticalArrangement = Arrangement.Center,
+        horizontalAlignment = Alignment.CenterHorizontally,
+    ) {
+        Text(
+            text = stringResource(R.string.app_name),
+            style = MaterialTheme.typography.displayMedium,
+        )
+        Text(
+            text = stringResource(R.string.app_tagline),
+            style = MaterialTheme.typography.bodyLarge,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun PlaceholderPreview() {
+    CalendulaTheme { PlaceholderScreen() }
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/theme/Color.kt

@@ -0,0 +1,43 @@
+package de.jeanlucmakiola.calendula.ui.theme
+
+import androidx.compose.material3.darkColorScheme
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.ui.graphics.Color
+
+/**
+ * Seed color anchoring the entire palette. See spec section 12.
+ * Desaturated slate blue-gray; distinct from HouseHoldKeaper's sage.
+ */
+val CalendulaSeed: Color = Color(0xFF5C6B7A)
+
+/**
+ * Fallback light scheme used on devices that don't support dynamic color
+ * (API < 31) or when the user disables it. The real palette is derived by
+ * Material's tonal-palette generator from CalendulaSeed at runtime; these
+ * constants are a hand-picked subset that approximates that result.
+ */
+val CalendulaLightFallback = lightColorScheme(
+    primary = Color(0xFF3B5364),
+    onPrimary = Color(0xFFFFFFFF),
+    primaryContainer = Color(0xFFCBE6FA),
+    onPrimaryContainer = Color(0xFF001E2E),
+    secondary = Color(0xFF526070),
+    onSecondary = Color(0xFFFFFFFF),
+    background = Color(0xFFFBFCFE),
+    onBackground = Color(0xFF191C1F),
+    surface = Color(0xFFFBFCFE),
+    onSurface = Color(0xFF191C1F),
+)
+
+val CalendulaDarkFallback = darkColorScheme(
+    primary = Color(0xFFA3CBE2),
+    onPrimary = Color(0xFF003348),
+    primaryContainer = Color(0xFF21495F),
+    onPrimaryContainer = Color(0xFFCBE6FA),
+    secondary = Color(0xFFB9C8DA),
+    onSecondary = Color(0xFF243240),
+    background = Color(0xFF101316),
+    onBackground = Color(0xFFE1E3E6),
+    surface = Color(0xFF101316),
+    onSurface = Color(0xFFE1E3E6),
+)

app/src/main/java/de/jeanlucmakiola/calendula/ui/theme/Theme.kt

@@ -0,0 +1,40 @@
+package de.jeanlucmakiola.calendula.ui.theme
+
+import android.os.Build
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.dynamicDarkColorScheme
+import androidx.compose.material3.dynamicLightColorScheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalContext
+
+/**
+ * App theme. Honors:
+ *   - System light/dark.
+ *   - Dynamic Color on API 31+, else falls back to the hand-tuned scheme
+ *     derived from [CalendulaSeed].
+ *
+ * The Settings screen (later) can override useDynamicColor and themePreference,
+ * but the V1 foundation just follows the system.
+ */
+@Composable
+fun CalendulaTheme(
+    darkTheme: Boolean = isSystemInDarkTheme(),
+    dynamicColor: Boolean = true,
+    content: @Composable () -> Unit,
+) {
+    val colorScheme = when {
+        dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
+            val ctx = LocalContext.current
+            if (darkTheme) dynamicDarkColorScheme(ctx) else dynamicLightColorScheme(ctx)
+        }
+        darkTheme -> CalendulaDarkFallback
+        else -> CalendulaLightFallback
+    }
+
+    MaterialTheme(
+        colorScheme = colorScheme,
+        typography = CalendulaTypography,
+        content = content,
+    )
+}

app/src/main/java/de/jeanlucmakiola/calendula/ui/theme/Type.kt

@@ -0,0 +1,10 @@
+package de.jeanlucmakiola.calendula.ui.theme
+
+import androidx.compose.material3.Typography
+
+/**
+ * Default Material 3 Expressive typography. Custom font + tuned scale will
+ * land in a later UI-design iteration; the defaults are intentional for V1
+ * scaffolding to keep the foundation lean.
+ */
+val CalendulaTypography = Typography()

app/src/test/java/de/jeanlucmakiola/calendula/ui/theme/ColorSchemeTest.kt

@@ -0,0 +1,28 @@
+package de.jeanlucmakiola.calendula.ui.theme
+
+import androidx.compose.ui.graphics.Color
+import com.google.common.truth.Truth.assertThat
+import org.junit.jupiter.api.Test
+
+class ColorSchemeTest {
+
+    @Test
+    fun `seed color matches design spec slate`() {
+        // The seed color must remain stable - the design is anchored to it.
+        // Change this only if the spec is updated.
+        assertThat(CalendulaSeed).isEqualTo(Color(0xFF5C6B7A))
+    }
+
+    @Test
+    fun `light fallback scheme uses seed as primary derivation source`() {
+        val scheme = CalendulaLightFallback
+        // Primary should be a recognizable derivative of the seed (not neutral gray)
+        assertThat(scheme.primary).isNotEqualTo(Color.Black)
+        assertThat(scheme.primary).isNotEqualTo(Color.White)
+    }
+
+    @Test
+    fun `dark fallback scheme differs from light`() {
+        assertThat(CalendulaDarkFallback.background).isNotEqualTo(CalendulaLightFallback.background)
+    }
+}