diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index cf554d3866682b76afe250feee828cd50404752c..0858e3ff9b610f022045807728d1163c6d00c4e3 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -20,11 +20,6 @@
       </option>
     </JavaCodeStyleSettings>
     <JetCodeStyleSettings>
-      <option name="PACKAGES_TO_USE_STAR_IMPORTS">
-        <value>
-          <package name="kotlinx.android.synthetic" alias="false" withSubpackages="true" />
-        </value>
-      </option>
       <option name="PACKAGES_IMPORT_LAYOUT">
         <value>
           <package name="" alias="false" withSubpackages="true" />
diff --git a/app-feature-preview/build.gradle.kts b/app-feature-preview/build.gradle.kts
index b8661a101b0658b46ad83a8081395cfc445247f5..ac4d713137c3b8536d7ad5324d3a2c2ad867c04e 100644
--- a/app-feature-preview/build.gradle.kts
+++ b/app-feature-preview/build.gradle.kts
@@ -10,6 +10,18 @@ android {
         versionCode = 1
         versionName = "1.0"
     }
+
+    packaging {
+        resources {
+            excludes += listOf(
+                "META-INF/DEPENDENCIES",
+            )
+        }
+    }
+
+    lint {
+        baseline = file("lint-baseline.xml")
+    }
 }
 
 dependencies {
@@ -17,4 +29,5 @@ dependencies {
 
     implementation(projects.feature.onboarding)
     implementation(projects.feature.account.setup)
+    implementation(libs.okhttp)
 }
diff --git a/app-feature-preview/lint-baseline.xml b/app-feature-preview/lint-baseline.xml
new file mode 100644
index 0000000000000000000000000000000000000000..5182475262024573d420d0e16ad978d8f9a00c48
--- /dev/null
+++ b/app-feature-preview/lint-baseline.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<issues format="6" by="lint 8.0.2" type="baseline" client="gradle" dependencies="true" name="AGP (8.0.2)" variant="all" version="8.0.2">
+
+    <issue
+        id="CustomX509TrustManager"
+        message="Implementing a custom `X509TrustManager` is error-prone and likely to be insecure. It is likely to disable certificate validation altogether, and is non-trivial to implement correctly without calling Android&apos;s default implementation."
+        errorLine1="    private class SecureX509TrustManager implements X509TrustManager {"
+        errorLine2="                  ~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/com/fsck/k9/mail/ssl/TrustManagerFactory.java"
+            line="70"
+            column="19"/>
+    </issue>
+
+</issues>
diff --git a/app-feature-preview/src/main/AndroidManifest.xml b/app-feature-preview/src/main/AndroidManifest.xml
index 5312e4e208ce682f897aea8a4f728dbe1b43afb7..1d43f40e5b1f5d1f8f44eff6209b35f045aa9378 100644
--- a/app-feature-preview/src/main/AndroidManifest.xml
+++ b/app-feature-preview/src/main/AndroidManifest.xml
@@ -1,23 +1,35 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest
+    xmlns:tools="http://schemas.android.com/tools"
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    >
+
+    <uses-permission android:name="android.permission.INTERNET"/>
 
     <application
+        android:name=".FeatureApplication"
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
+        android:usesCleartextTraffic="true"
+        android:networkSecurityConfig="@xml/network_security_config"
         android:supportsRtl="true"
         android:theme="@style/Theme.Thunderbird.Splashscreen"
+        tools:ignore="UnusedAttribute"
         >
 
         <activity
             android:name=".FeatureActivity"
-            android:exported="true">
+            android:exported="true"
+            android:windowSoftInputMode="adjustResize"
+            >
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
 
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
+
     </application>
 
 </manifest>
diff --git a/app-feature-preview/src/main/java/app/k9mail/feature/preview/FeatureApplication.kt b/app-feature-preview/src/main/java/app/k9mail/feature/preview/FeatureApplication.kt
new file mode 100644
index 0000000000000000000000000000000000000000..00c415908ae4539d35521cbd4228edb94be19952
--- /dev/null
+++ b/app-feature-preview/src/main/java/app/k9mail/feature/preview/FeatureApplication.kt
@@ -0,0 +1,17 @@
+package app.k9mail.feature.preview
+
+import android.app.Application
+import org.koin.android.ext.koin.androidContext
+import org.koin.core.context.startKoin
+
+class FeatureApplication : Application() {
+
+    override fun onCreate() {
+        super.onCreate()
+
+        startKoin {
+            androidContext(this@FeatureApplication)
+            modules(featureModule)
+        }
+    }
+}
diff --git a/app-feature-preview/src/main/java/app/k9mail/feature/preview/FeatureModule.kt b/app-feature-preview/src/main/java/app/k9mail/feature/preview/FeatureModule.kt
new file mode 100644
index 0000000000000000000000000000000000000000..56d5226ba040a770c30df5f89b8663859c39c6c6
--- /dev/null
+++ b/app-feature-preview/src/main/java/app/k9mail/feature/preview/FeatureModule.kt
@@ -0,0 +1,16 @@
+package app.k9mail.feature.preview
+
+import app.k9mail.feature.account.setup.featureAccountSetupModule
+import okhttp3.OkHttpClient
+import org.koin.core.module.Module
+import org.koin.dsl.module
+
+val featureModule: Module = module {
+
+    // TODO move to network module
+    single<OkHttpClient> {
+        OkHttpClient()
+    }
+
+    includes(featureAccountSetupModule)
+}
diff --git a/app-feature-preview/src/main/java/app/k9mail/feature/preview/navigation/FeatureNavHost.kt b/app-feature-preview/src/main/java/app/k9mail/feature/preview/navigation/FeatureNavHost.kt
index b0c7c03709bdd0f7004660fbda4067ce12434620..c64f81d5da771da41568eeeea12b93f51c39fe9a 100644
--- a/app-feature-preview/src/main/java/app/k9mail/feature/preview/navigation/FeatureNavHost.kt
+++ b/app-feature-preview/src/main/java/app/k9mail/feature/preview/navigation/FeatureNavHost.kt
@@ -4,10 +4,10 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.navigation.NavHostController
 import androidx.navigation.compose.NavHost
-import app.k9mail.feature.account.setup.navigation.accountSetupScreen
+import app.k9mail.feature.account.setup.navigation.accountSetupRoute
 import app.k9mail.feature.account.setup.navigation.navigateToAccountSetup
 import app.k9mail.feature.onboarding.navigation.NAVIGATION_ROUTE_ONBOARDING
-import app.k9mail.feature.onboarding.navigation.onboardingScreen
+import app.k9mail.feature.onboarding.navigation.onboardingRoute
 
 @Composable
 fun FeatureNavHost(
@@ -20,13 +20,13 @@ fun FeatureNavHost(
         startDestination = startDestination,
         modifier = modifier,
     ) {
-        onboardingScreen(
-            onStartClick = { navController.navigateToAccountSetup() },
-            onImportClick = { /* TODO */ },
+        onboardingRoute(
+            onStart = { navController.navigateToAccountSetup() },
+            onImport = { /* TODO */ },
         )
-        accountSetupScreen(
-            onBackClick = navController::popBackStack,
-            onFinishClick = { /* TODO */ },
+        accountSetupRoute(
+            onBack = navController::popBackStack,
+            onFinish = { /* TODO */ },
         )
     }
 }
diff --git a/app-feature-preview/src/main/java/app/k9mail/feature/preview/ui/FeatureApp.kt b/app-feature-preview/src/main/java/app/k9mail/feature/preview/ui/FeatureApp.kt
index baa3ceddb80a8938d2d3c6f558cddbd0e1bc052c..1d6c0bd801065001143ee73d1e418218dbf6d2a0 100644
--- a/app-feature-preview/src/main/java/app/k9mail/feature/preview/ui/FeatureApp.kt
+++ b/app-feature-preview/src/main/java/app/k9mail/feature/preview/ui/FeatureApp.kt
@@ -1,10 +1,7 @@
 package app.k9mail.feature.preview.ui
 
-import androidx.compose.foundation.layout.WindowInsets
-import androidx.compose.foundation.layout.asPaddingValues
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.systemBars
+import androidx.compose.foundation.layout.safeDrawingPadding
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.navigation.compose.rememberNavController
@@ -19,12 +16,10 @@ fun FeatureApp(
     val navController = rememberNavController()
 
     K9Theme {
-        val contentPadding = WindowInsets.systemBars.asPaddingValues()
-
         Background(
             modifier = Modifier
                 .fillMaxSize()
-                .padding(contentPadding)
+                .safeDrawingPadding()
                 .then(modifier),
         ) {
             FeatureNavHost(navController = navController)
diff --git a/app-feature-preview/src/main/res/values/themes.xml b/app-feature-preview/src/main/res/values/themes.xml
index 5bfdb913ac697a755a7c0ebd6608b5b006c53330..b784534a72714ddc8861f4cbd13ade270e46671d 100644
--- a/app-feature-preview/src/main/res/values/themes.xml
+++ b/app-feature-preview/src/main/res/values/themes.xml
@@ -1,6 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <style name="Theme.Thunderbird" parent="Theme.MaterialComponents.DayNight.NoActionBar" />
+    <style name="Theme.Thunderbird" parent="Theme.MaterialComponents.DayNight.NoActionBar">
+        <item name="android:statusBarColor">@android:color/transparent</item>
+        <item name="android:navigationBarColor">@android:color/transparent</item>
+    </style>
 
     <style name="Theme.Thunderbird.Splashscreen" parent="Theme.SplashScreen">
         <item name="windowSplashScreenAnimatedIcon">@drawable/ic_launcher_foreground</item>
diff --git a/app-feature-preview/src/main/res/xml/network_security_config.xml b/app-feature-preview/src/main/res/xml/network_security_config.xml
new file mode 100644
index 0000000000000000000000000000000000000000..094d43225127492bdcb2444b0c828a628d332cb8
--- /dev/null
+++ b/app-feature-preview/src/main/res/xml/network_security_config.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<network-security-config xmlns:tools="http://schemas.android.com/tools"
+    tools:ignore="InsecureBaseConfiguration,AcceptsUserCertificates">
+
+    <base-config cleartextTrafficPermitted="true">
+        <trust-anchors>
+            <certificates src="system" />
+            <certificates src="user" />
+        </trust-anchors>
+    </base-config>
+
+</network-security-config>
diff --git a/app-ui-catalog/build.gradle.kts b/app-ui-catalog/build.gradle.kts
index 97166e25954ec1291b30ab4c049b73e68088786c..2e2544b485463f4a548c213341828c11b0a520f6 100644
--- a/app-ui-catalog/build.gradle.kts
+++ b/app-ui-catalog/build.gradle.kts
@@ -14,4 +14,7 @@ android {
 
 dependencies {
     implementation(projects.core.ui.compose.designsystem)
+
+    implementation(libs.androidx.compose.material)
+    implementation(libs.androidx.compose.material.icons.extended)
 }
diff --git a/app-ui-catalog/src/main/AndroidManifest.xml b/app-ui-catalog/src/main/AndroidManifest.xml
index f39530bf044b654659c5dfbca4397e1c87c0310e..a8179f1005aaada3c9d5155e04648695c6a5a6df 100644
--- a/app-ui-catalog/src/main/AndroidManifest.xml
+++ b/app-ui-catalog/src/main/AndroidManifest.xml
@@ -2,6 +2,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
     <application
+        android:name=".CatalogApplication"
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
@@ -11,14 +12,16 @@
 
         <activity
             android:name=".CatalogActivity"
-            android:exported="true">
+            android:exported="true"
+            android:windowSoftInputMode="adjustResize"
+            >
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
 
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
-        
+
     </application>
 
 </manifest>
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogActivity.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogActivity.kt
index f2c3b0ffe8a354764e3ce2778e9de298aefdb740..458a19166ba9add6be3b6fad7bec5b5d5c9d0969 100644
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogActivity.kt
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogActivity.kt
@@ -5,6 +5,7 @@ import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.core.view.WindowCompat
+import app.k9mail.ui.catalog.ui.CatalogScreen
 
 class CatalogActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogApplication.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogApplication.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f351adcbd83abf8d69be171aca9f0a3f1f553c66
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogApplication.kt
@@ -0,0 +1,18 @@
+package app.k9mail.ui.catalog
+
+import android.app.Application
+import app.k9mail.ui.catalog.ui.catalogUiModule
+import org.koin.android.ext.koin.androidContext
+import org.koin.core.context.startKoin
+
+class CatalogApplication : Application() {
+
+    override fun onCreate() {
+        super.onCreate()
+
+        startKoin {
+            androidContext(this@CatalogApplication)
+            modules(catalogUiModule)
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogContent.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogContent.kt
deleted file mode 100644
index 19e4ed24e73431141adfd0863e2819a924a00503..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogContent.kt
+++ /dev/null
@@ -1,89 +0,0 @@
-package app.k9mail.ui.catalog
-
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.grid.GridCells
-import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.dp
-import app.k9mail.core.ui.compose.common.DevicePreviews
-import app.k9mail.core.ui.compose.designsystem.atom.Surface
-import app.k9mail.core.ui.compose.designsystem.template.ResponsiveContent
-import app.k9mail.core.ui.compose.theme.K9Theme
-import app.k9mail.core.ui.compose.theme.MainTheme
-import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
-import app.k9mail.ui.catalog.items.buttonItems
-import app.k9mail.ui.catalog.items.colorItems
-import app.k9mail.ui.catalog.items.imageItems
-import app.k9mail.ui.catalog.items.selectionControlItems
-import app.k9mail.ui.catalog.items.textFieldItems
-import app.k9mail.ui.catalog.items.themeHeaderItem
-import app.k9mail.ui.catalog.items.themeSelectorItems
-import app.k9mail.ui.catalog.items.typographyItems
-
-@Composable
-fun CatalogContent(
-    catalogTheme: CatalogTheme,
-    catalogThemeVariant: CatalogThemeVariant,
-    onThemeChange: () -> Unit,
-    onThemeVariantChange: () -> Unit,
-    contentPadding: PaddingValues,
-    modifier: Modifier = Modifier,
-) {
-    Surface {
-        ResponsiveContent {
-            LazyVerticalGrid(
-                columns = GridCells.Adaptive(300.dp),
-                contentPadding = contentPadding,
-                horizontalArrangement = Arrangement.spacedBy(MainTheme.spacings.double),
-                verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.double),
-                modifier = modifier.padding(MainTheme.spacings.double),
-            ) {
-                themeHeaderItem(text = "Thunderbird Catalog")
-                themeSelectorItems(
-                    catalogTheme = catalogTheme,
-                    catalogThemeVariant = catalogThemeVariant,
-                    onThemeChange = onThemeChange,
-                    onThemeVariantChange = onThemeVariantChange,
-                )
-
-                typographyItems()
-                colorItems()
-                buttonItems()
-                selectionControlItems()
-                textFieldItems()
-                imageItems()
-            }
-        }
-    }
-}
-
-@DevicePreviews
-@Composable
-internal fun CatalogContentK9ThemePreview() {
-    K9Theme {
-        CatalogContent(
-            catalogTheme = CatalogTheme.K9,
-            catalogThemeVariant = CatalogThemeVariant.LIGHT,
-            onThemeChange = {},
-            onThemeVariantChange = {},
-            contentPadding = PaddingValues(),
-        )
-    }
-}
-
-@DevicePreviews
-@Composable
-internal fun CatalogContentThunderbirdThemePreview() {
-    ThunderbirdTheme {
-        CatalogContent(
-            catalogTheme = CatalogTheme.THUNDERBIRD,
-            catalogThemeVariant = CatalogThemeVariant.LIGHT,
-            onThemeChange = {},
-            onThemeVariantChange = {},
-            contentPadding = PaddingValues(),
-        )
-    }
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogScreen.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogScreen.kt
deleted file mode 100644
index f7b03e55471dc80697be1ec046fd3394d4cebb99..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogScreen.kt
+++ /dev/null
@@ -1,53 +0,0 @@
-package app.k9mail.ui.catalog
-
-import androidx.compose.foundation.layout.WindowInsets
-import androidx.compose.foundation.layout.asPaddingValues
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.systemBars
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import app.k9mail.core.ui.compose.common.DevicePreviews
-
-@Composable
-fun CatalogScreen(
-    modifier: Modifier = Modifier,
-) {
-    val themeState = remember { mutableStateOf(CatalogTheme.K9) }
-    val themeVariantState = remember { mutableStateOf(CatalogThemeVariant.LIGHT) }
-
-    CatalogThemeSwitch(
-        theme = themeState.value,
-        themeVariant = themeVariantState.value,
-    ) {
-        val contentPadding = WindowInsets.systemBars.asPaddingValues()
-
-        CatalogContent(
-            catalogTheme = themeState.value,
-            catalogThemeVariant = themeVariantState.value,
-            onThemeChange = {
-                themeState.value = when (themeState.value) {
-                    CatalogTheme.K9 -> CatalogTheme.THUNDERBIRD
-                    CatalogTheme.THUNDERBIRD -> CatalogTheme.K9
-                }
-            },
-            onThemeVariantChange = {
-                themeVariantState.value = when (themeVariantState.value) {
-                    CatalogThemeVariant.LIGHT -> CatalogThemeVariant.DARK
-                    CatalogThemeVariant.DARK -> CatalogThemeVariant.LIGHT
-                }
-            },
-            contentPadding = contentPadding,
-            modifier = Modifier
-                .fillMaxSize()
-                .then(modifier),
-        )
-    }
-}
-
-@DevicePreviews
-@Composable
-internal fun CatalogScreenPreview() {
-    CatalogScreen()
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogTheme.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogTheme.kt
deleted file mode 100644
index 123dd4e1bb087d25d61d183488a90fce526b0555..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogTheme.kt
+++ /dev/null
@@ -1,13 +0,0 @@
-package app.k9mail.ui.catalog
-
-enum class CatalogTheme(
-    private val displayName: String,
-) {
-    K9("K-9"),
-    THUNDERBIRD("Thunderbird"),
-    ;
-
-    override fun toString(): String {
-        return displayName
-    }
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeVariant.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeVariant.kt
deleted file mode 100644
index 0b8cee444e31dc970524cb66c8b73416327b1d60..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeVariant.kt
+++ /dev/null
@@ -1,5 +0,0 @@
-package app.k9mail.ui.catalog
-
-enum class CatalogThemeVariant {
-    LIGHT, DARK
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ImageItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ImageItems.kt
deleted file mode 100644
index e4ff3e9cafcabc2fbba4c569a8b74171a6244365..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ImageItems.kt
+++ /dev/null
@@ -1,13 +0,0 @@
-package app.k9mail.ui.catalog.items
-
-import androidx.compose.foundation.Image
-import androidx.compose.foundation.lazy.grid.LazyGridScope
-import androidx.compose.ui.res.painterResource
-import app.k9mail.core.ui.compose.theme.MainTheme
-
-fun LazyGridScope.imageItems() {
-    sectionHeaderItem(text = "Images")
-    item {
-        Image(painter = painterResource(id = MainTheme.images.logo), contentDescription = "logo")
-    }
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SectionHeaderItem.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SectionHeaderItem.kt
deleted file mode 100644
index 7e144028fbacce9edc175a7cadaab1b7e2eda035..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SectionHeaderItem.kt
+++ /dev/null
@@ -1,16 +0,0 @@
-package app.k9mail.ui.catalog.items
-
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.grid.GridItemSpan
-import androidx.compose.foundation.lazy.grid.LazyGridScope
-import androidx.compose.ui.Modifier
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline6
-import app.k9mail.core.ui.compose.theme.MainTheme
-
-fun LazyGridScope.sectionHeaderItem(
-    text: String,
-) {
-    item(span = { GridItemSpan(maxLineSpan) }) {
-        TextHeadline6(text = text, modifier = Modifier.padding(top = MainTheme.spacings.default))
-    }
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SectionSubtitleItem.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SectionSubtitleItem.kt
deleted file mode 100644
index 015466a11e2365f11a8bdbe93a040cb677314d10..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SectionSubtitleItem.kt
+++ /dev/null
@@ -1,16 +0,0 @@
-package app.k9mail.ui.catalog.items
-
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.grid.GridItemSpan
-import androidx.compose.foundation.lazy.grid.LazyGridScope
-import androidx.compose.ui.Modifier
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
-import app.k9mail.core.ui.compose.theme.MainTheme
-
-fun LazyGridScope.sectionSubtitleItem(
-    text: String,
-) {
-    item(span = { GridItemSpan(maxLineSpan) }) {
-        TextSubtitle1(text = text, modifier = Modifier.padding(top = MainTheme.spacings.default))
-    }
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/TextFieldItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/TextFieldItems.kt
deleted file mode 100644
index 9bfdc5f5365deb8e656b2b73dd2a6375cd848822..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/TextFieldItems.kt
+++ /dev/null
@@ -1,90 +0,0 @@
-package app.k9mail.ui.catalog.items
-
-import androidx.compose.foundation.lazy.grid.LazyGridScope
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.MutableState
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import app.k9mail.core.ui.compose.designsystem.atom.textfield.PasswordTextFieldOutlined
-import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlined
-
-fun LazyGridScope.textFieldItems() {
-    sectionHeaderItem(text = "Text fields")
-    textFieldOutlinedItems()
-    passwordTextFieldOutlinedItems()
-}
-
-private fun LazyGridScope.textFieldOutlinedItems() {
-    sectionSubtitleItem(text = "Outlined")
-    item {
-        WithRememberedInput(text = "Initial text") { input ->
-            TextFieldOutlined(
-                value = input.value,
-                label = "Label",
-                onValueChange = { input.value = it },
-            )
-        }
-    }
-    item {
-        WithRememberedInput(text = "Input text with error") { input ->
-            TextFieldOutlined(
-                value = input.value,
-                label = "Label",
-                onValueChange = { input.value = it },
-                isError = true,
-            )
-        }
-    }
-    item {
-        WithRememberedInput(text = "Input text disabled") { input ->
-            TextFieldOutlined(
-                value = input.value,
-                label = "Label",
-                onValueChange = { input.value = it },
-                enabled = false,
-            )
-        }
-    }
-}
-
-private fun LazyGridScope.passwordTextFieldOutlinedItems() {
-    sectionSubtitleItem(text = "Password outlined")
-    item {
-        WithRememberedInput(text = "Input text") { input ->
-            PasswordTextFieldOutlined(
-                value = input.value,
-                label = "Label",
-                onValueChange = { input.value = it },
-            )
-        }
-    }
-    item {
-        WithRememberedInput(text = "Input text with error") { input ->
-            PasswordTextFieldOutlined(
-                value = input.value,
-                label = "Label",
-                onValueChange = { input.value = it },
-                isError = true,
-            )
-        }
-    }
-    item {
-        WithRememberedInput(text = "Input text disabled") { input ->
-            PasswordTextFieldOutlined(
-                value = input.value,
-                label = "Label",
-                onValueChange = { input.value = it },
-                enabled = false,
-            )
-        }
-    }
-}
-
-@Composable
-private fun WithRememberedInput(
-    text: String,
-    content: @Composable (text: MutableState<String>) -> Unit,
-) {
-    val inputText = remember { mutableStateOf(text) }
-    content(inputText)
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ThemeHeaderItem.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ThemeHeaderItem.kt
deleted file mode 100644
index 023b72e716e5a71d43cc38a8ee0dcb661bd794af..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ThemeHeaderItem.kt
+++ /dev/null
@@ -1,16 +0,0 @@
-package app.k9mail.ui.catalog.items
-
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.grid.GridItemSpan
-import androidx.compose.foundation.lazy.grid.LazyGridScope
-import androidx.compose.ui.Modifier
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline4
-import app.k9mail.core.ui.compose.theme.MainTheme
-
-fun LazyGridScope.themeHeaderItem(
-    text: String,
-) {
-    item(span = { GridItemSpan(maxLineSpan) }) {
-        TextHeadline4(text = text, modifier = Modifier.padding(top = MainTheme.spacings.default))
-    }
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ThemeSelectorItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ThemeSelectorItems.kt
deleted file mode 100644
index 38dc19a63aca8fef77290093b32981b967bcfeee..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ThemeSelectorItems.kt
+++ /dev/null
@@ -1,31 +0,0 @@
-package app.k9mail.ui.catalog.items
-
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.lazy.grid.LazyGridScope
-import androidx.compose.ui.Modifier
-import app.k9mail.ui.catalog.CatalogTheme
-import app.k9mail.ui.catalog.CatalogThemeSelector
-import app.k9mail.ui.catalog.CatalogThemeVariant
-import app.k9mail.ui.catalog.CatalogThemeVariantSelector
-
-fun LazyGridScope.themeSelectorItems(
-    catalogTheme: CatalogTheme,
-    catalogThemeVariant: CatalogThemeVariant,
-    onThemeChange: () -> Unit,
-    onThemeVariantChange: () -> Unit,
-) {
-    item {
-        CatalogThemeSelector(
-            catalogTheme = catalogTheme,
-            modifier = Modifier.fillMaxWidth(),
-            onThemeChangeClick = onThemeChange,
-        )
-    }
-    item {
-        CatalogThemeVariantSelector(
-            catalogThemeVariant = catalogThemeVariant,
-            modifier = Modifier.fillMaxWidth(),
-            onThemeVariantChange = onThemeVariantChange,
-        )
-    }
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/TypographyItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/TypographyItems.kt
deleted file mode 100644
index 7ad1735d4704818e43233a0d229eb25eba07cdae..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/TypographyItems.kt
+++ /dev/null
@@ -1,33 +0,0 @@
-package app.k9mail.ui.catalog.items
-
-import androidx.compose.foundation.lazy.grid.LazyGridScope
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody2
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextButton
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextCaption
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline1
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline2
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline3
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline4
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline5
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline6
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextOverline
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle2
-
-fun LazyGridScope.typographyItems() {
-    sectionHeaderItem(text = "Typography")
-    item { TextHeadline1(text = "Headline1") }
-    item { TextHeadline2(text = "Headline2") }
-    item { TextHeadline3(text = "Headline3") }
-    item { TextHeadline4(text = "Headline4") }
-    item { TextHeadline5(text = "Headline5") }
-    item { TextHeadline6(text = "Headline6") }
-    item { TextSubtitle1(text = "Subtitle1") }
-    item { TextSubtitle2(text = "Subtitle2") }
-    item { TextBody1(text = "Body1") }
-    item { TextBody2(text = "Body2") }
-    item { TextButton(text = "Button") }
-    item { TextCaption(text = "Caption") }
-    item { TextOverline(text = "Overline") }
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogContent.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0a96342d582b53c273f0b5ce333098c41a6e9d95
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogContent.kt
@@ -0,0 +1,58 @@
+package app.k9mail.ui.catalog.ui
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.navigation.compose.rememberNavController
+import app.k9mail.core.ui.compose.designsystem.template.Scaffold
+import app.k9mail.ui.catalog.ui.CatalogContract.State
+import app.k9mail.ui.catalog.ui.atom.navigateToCatalogAtom
+import app.k9mail.ui.catalog.ui.common.ThemeTopAppBar
+import app.k9mail.ui.catalog.ui.common.drawer.DrawerContent
+import app.k9mail.ui.catalog.ui.molecule.navigateToCatalogMolecule
+import app.k9mail.ui.catalog.ui.navigation.CatalogNavHost
+import app.k9mail.ui.catalog.ui.organism.navigateToCatalogOrganism
+
+@Composable
+fun CatalogContent(
+    state: State,
+    onThemeChanged: () -> Unit,
+    onThemeVariantChanged: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val navController = rememberNavController()
+
+    Scaffold(
+        modifier = modifier,
+        topBar = { toggleDrawer ->
+            ThemeTopAppBar(
+                onNavigationClick = toggleDrawer,
+                theme = state.theme,
+                themeVariant = state.themeVariant,
+                onThemeClick = onThemeChanged,
+                onThemeVariantClick = onThemeVariantChanged,
+            )
+        },
+        drawerContent = { toogleDrawer ->
+            DrawerContent(
+                toggleDrawer = toogleDrawer,
+                theme = state.theme,
+                themeVariant = state.themeVariant,
+                onThemeChanged = onThemeChanged,
+                onThemeVariantChanged = onThemeVariantChanged,
+                onNavigateToAtoms = {
+                    navController.navigateToCatalogAtom()
+                },
+                onNavigateToMolecules = {
+                    navController.navigateToCatalogMolecule()
+                },
+                onNavigateToOrganisms = {
+                    navController.navigateToCatalogOrganism()
+                },
+            )
+        },
+    ) {
+        CatalogNavHost(
+            navController = navController,
+        )
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogContract.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2d52d435146d2368c2e00afa7595b9614c531d92
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogContract.kt
@@ -0,0 +1,33 @@
+package app.k9mail.ui.catalog.ui
+
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+
+interface CatalogContract {
+
+    enum class Theme(
+        val displayName: String,
+    ) {
+        K9("K-9"),
+        THUNDERBIRD("Thunderbird"),
+    }
+
+    enum class ThemeVariant(
+        val displayName: String,
+    ) {
+        LIGHT("Light"),
+        DARK("Dark"),
+    }
+
+    interface ViewModel : UnidirectionalViewModel<State, Event, Nothing>
+
+    data class State(
+        val theme: Theme = Theme.K9,
+        val themeVariant: ThemeVariant = ThemeVariant.LIGHT,
+    )
+
+    sealed interface Event {
+        object OnThemeChanged : Event
+
+        object OnThemeVariantChanged : Event
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogScreen.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..813c2bc09b44840d723627fb471412e03d9dafdd
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogScreen.kt
@@ -0,0 +1,39 @@
+package app.k9mail.ui.catalog.ui
+
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.common.mvi.observe
+import app.k9mail.core.ui.compose.designsystem.atom.Background
+import app.k9mail.ui.catalog.ui.CatalogContract.Event.OnThemeChanged
+import app.k9mail.ui.catalog.ui.CatalogContract.Event.OnThemeVariantChanged
+import app.k9mail.ui.catalog.ui.CatalogContract.ViewModel
+import app.k9mail.ui.catalog.ui.common.theme.ThemeSwitch
+import org.koin.androidx.compose.koinViewModel
+
+@Composable
+fun CatalogScreen(
+    modifier: Modifier = Modifier,
+    viewModel: ViewModel = koinViewModel<CatalogViewModel>(),
+) {
+    val (state, dispatch) = viewModel.observe(handleEffect = {})
+
+    ThemeSwitch(
+        theme = state.value.theme,
+        themeVariant = state.value.themeVariant,
+    ) {
+        Background(
+            modifier = Modifier
+                .fillMaxSize()
+                .safeDrawingPadding()
+                .then(modifier),
+        ) {
+            CatalogContent(
+                state = state.value,
+                onThemeChanged = { dispatch(OnThemeChanged) },
+                onThemeVariantChanged = { dispatch(OnThemeVariantChanged) },
+            )
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogUiModule.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogUiModule.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1df4100127bff76a2ab3cc7fdb02cd53c980cc82
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogUiModule.kt
@@ -0,0 +1,9 @@
+package app.k9mail.ui.catalog.ui
+
+import org.koin.androidx.viewmodel.dsl.viewModel
+import org.koin.core.module.Module
+import org.koin.dsl.module
+
+val catalogUiModule: Module = module {
+    viewModel { CatalogViewModel() }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogViewModel.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1f528198d8901a87712e3a07476cca34af5f6158
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogViewModel.kt
@@ -0,0 +1,34 @@
+package app.k9mail.ui.catalog.ui
+
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.ui.catalog.ui.CatalogContract.Event
+import app.k9mail.ui.catalog.ui.CatalogContract.Event.OnThemeChanged
+import app.k9mail.ui.catalog.ui.CatalogContract.Event.OnThemeVariantChanged
+import app.k9mail.ui.catalog.ui.CatalogContract.State
+import app.k9mail.ui.catalog.ui.CatalogContract.Theme.K9
+import app.k9mail.ui.catalog.ui.CatalogContract.Theme.THUNDERBIRD
+import app.k9mail.ui.catalog.ui.CatalogContract.ThemeVariant.DARK
+import app.k9mail.ui.catalog.ui.CatalogContract.ThemeVariant.LIGHT
+import app.k9mail.ui.catalog.ui.CatalogContract.ViewModel
+
+class CatalogViewModel(
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Nothing>(initialState), ViewModel {
+    override fun event(event: Event) {
+        when (event) {
+            is OnThemeChanged -> {
+                when (state.value.theme) {
+                    K9 -> updateState { it.copy(theme = THUNDERBIRD) }
+                    THUNDERBIRD -> updateState { it.copy(theme = K9) }
+                }
+            }
+
+            is OnThemeVariantChanged -> {
+                when (state.value.themeVariant) {
+                    LIGHT -> updateState { it.copy(themeVariant = DARK) }
+                    DARK -> updateState { it.copy(themeVariant = LIGHT) }
+                }
+            }
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomContent.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..537c14af6b2785846ec5648b280d89ab83901820
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomContent.kt
@@ -0,0 +1,69 @@
+package app.k9mail.ui.catalog.ui.atom
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.ui.catalog.ui.atom.CatalogAtomPage.BUTTON
+import app.k9mail.ui.catalog.ui.atom.CatalogAtomPage.COLOR
+import app.k9mail.ui.catalog.ui.atom.CatalogAtomPage.ICON
+import app.k9mail.ui.catalog.ui.atom.CatalogAtomPage.IMAGE
+import app.k9mail.ui.catalog.ui.atom.CatalogAtomPage.SELECTION_CONTROL
+import app.k9mail.ui.catalog.ui.atom.CatalogAtomPage.TEXT_FIELD
+import app.k9mail.ui.catalog.ui.atom.CatalogAtomPage.TYPOGRAPHY
+import app.k9mail.ui.catalog.ui.atom.items.buttonItems
+import app.k9mail.ui.catalog.ui.atom.items.colorItems
+import app.k9mail.ui.catalog.ui.atom.items.iconItems
+import app.k9mail.ui.catalog.ui.atom.items.imageItems
+import app.k9mail.ui.catalog.ui.atom.items.selectionControlItems
+import app.k9mail.ui.catalog.ui.atom.items.textFieldItems
+import app.k9mail.ui.catalog.ui.atom.items.typographyItems
+import app.k9mail.ui.catalog.ui.common.PagedContent
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+
+@Composable
+fun CatalogContent(
+    pages: ImmutableList<CatalogAtomPage>,
+    initialPage: CatalogAtomPage,
+    modifier: Modifier = Modifier,
+) {
+    PagedContent(
+        pages = pages,
+        initialPage = initialPage,
+        modifier = modifier,
+    ) {
+        when (it) {
+            TYPOGRAPHY -> typographyItems()
+            COLOR -> colorItems()
+            BUTTON -> buttonItems()
+            SELECTION_CONTROL -> selectionControlItems()
+            TEXT_FIELD -> textFieldItems()
+            ICON -> iconItems()
+            IMAGE -> imageItems()
+        }
+    }
+}
+
+@DevicePreviews
+@Composable
+internal fun CatalogContentK9ThemePreview() {
+    K9Theme {
+        CatalogContent(
+            pages = persistentListOf(TYPOGRAPHY, COLOR),
+            initialPage = TYPOGRAPHY,
+        )
+    }
+}
+
+@DevicePreviews
+@Composable
+internal fun CatalogContentThunderbirdThemePreview() {
+    ThunderbirdTheme {
+        CatalogContent(
+            pages = persistentListOf(TYPOGRAPHY, COLOR),
+            initialPage = TYPOGRAPHY,
+        )
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomNavigation.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomNavigation.kt
new file mode 100644
index 0000000000000000000000000000000000000000..18607d492c9882dc54ed81e842a984acbfd98ad5
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomNavigation.kt
@@ -0,0 +1,23 @@
+package app.k9mail.ui.catalog.ui.atom
+
+import androidx.navigation.NavController
+import androidx.navigation.NavGraphBuilder
+import androidx.navigation.NavOptions
+import androidx.navigation.compose.composable
+
+const val NAVIGATION_ROUTE_CATALOG_ATOM = "/catalog/atom"
+
+fun NavController.navigateToCatalogAtom() {
+    navigate(
+        route = NAVIGATION_ROUTE_CATALOG_ATOM,
+        navOptions = NavOptions.Builder()
+            .setLaunchSingleTop(true)
+            .build(),
+    )
+}
+
+fun NavGraphBuilder.catalogAtomRoute() {
+    composable(route = NAVIGATION_ROUTE_CATALOG_ATOM) {
+        CatalogAtomScreen()
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomPage.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomPage.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1eae2e27c5e31c930f0eac481a2112230b1ad011
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomPage.kt
@@ -0,0 +1,24 @@
+package app.k9mail.ui.catalog.ui.atom
+
+import kotlinx.collections.immutable.toImmutableList
+
+enum class CatalogAtomPage(
+    private val displayName: String,
+) {
+    TYPOGRAPHY("Typography"),
+    COLOR("Colors"),
+    BUTTON("Buttons"),
+    SELECTION_CONTROL("Selection Controls"),
+    TEXT_FIELD("TextFields"),
+    ICON("Icons"),
+    IMAGE("Images"),
+    ;
+
+    override fun toString(): String {
+        return displayName
+    }
+
+    companion object {
+        fun all() = values().toList().toImmutableList()
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomScreen.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ddf7c54e5ca3dc2be1e0437c10cad7d3218965c0
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomScreen.kt
@@ -0,0 +1,15 @@
+package app.k9mail.ui.catalog.ui.atom
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+
+@Composable
+fun CatalogAtomScreen(
+    modifier: Modifier = Modifier,
+) {
+    CatalogContent(
+        pages = CatalogAtomPage.all(),
+        initialPage = CatalogAtomPage.TYPOGRAPHY,
+        modifier = modifier,
+    )
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ButtonItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ButtonItems.kt
similarity index 54%
rename from app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ButtonItems.kt
rename to app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ButtonItems.kt
index c2f03df1467a1ea7656699b3ce98607b41b6f542..31fda531418de673d26963b1ec25bdbfc5372abc 100644
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ButtonItems.kt
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ButtonItems.kt
@@ -1,39 +1,50 @@
-package app.k9mail.ui.catalog.items
+package app.k9mail.ui.catalog.ui.atom.items
 
 import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
 import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
 import app.k9mail.core.ui.compose.designsystem.atom.button.Button
 import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonOutlined
 import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonText
 import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.ui.catalog.ui.common.list.itemDefaultPadding
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
 
+@OptIn(ExperimentalLayoutApi::class)
 fun LazyGridScope.buttonItems() {
-    sectionHeaderItem(text = "Buttons")
-    sectionSubtitleItem(text = "Contained")
+    sectionHeaderItem(text = "Buttons - Filled")
     item {
-        Row(
+        FlowRow(
             horizontalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+            modifier = Modifier.itemDefaultPadding(),
         ) {
             Button(text = "Enabled", onClick = { })
+            Button(text = "Colored", onClick = { }, color = Color.Magenta)
             Button(text = "Disabled", onClick = { }, enabled = false)
         }
     }
-    sectionSubtitleItem(text = "Outlined")
+    sectionHeaderItem(text = "Buttons - Outlined")
     item {
-        Row(
+        FlowRow(
             horizontalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+            modifier = Modifier.itemDefaultPadding(),
         ) {
             ButtonOutlined(text = "Enabled", onClick = { })
+            ButtonOutlined(text = "Colored", onClick = { }, color = Color.Magenta)
             ButtonOutlined(text = "Disabled", onClick = { }, enabled = false)
         }
     }
-    sectionSubtitleItem(text = "Text")
+    sectionHeaderItem(text = "Buttons - Text only")
     item {
-        Row(
+        FlowRow(
             horizontalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+            modifier = Modifier.itemDefaultPadding(),
         ) {
             ButtonText(text = "Enabled", onClick = { })
+            ButtonText(text = "Colored", onClick = { }, color = Color.Magenta)
             ButtonText(text = "Disabled", onClick = { }, enabled = false)
         }
     }
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ColorItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ColorItems.kt
similarity index 83%
rename from app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ColorItems.kt
rename to app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ColorItems.kt
index 34a49ce333d0fc9637843d84a144e4c0d2645a96..5a442ffae789d76bf187ee8bfca6f23a8e0ee079 100644
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ColorItems.kt
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ColorItems.kt
@@ -1,4 +1,4 @@
-package app.k9mail.ui.catalog.items
+package app.k9mail.ui.catalog.ui.atom.items
 
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Row
@@ -11,9 +11,11 @@ import androidx.compose.ui.graphics.Color
 import app.k9mail.core.ui.compose.designsystem.atom.Surface
 import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
 import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.ui.catalog.ui.common.list.itemDefaultPadding
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
 
 fun LazyGridScope.colorItems() {
-    sectionHeaderItem(text = "Colors")
+    sectionHeaderItem(text = "Material theme colors")
     item {
         ColorContent(
             name = "Primary",
@@ -66,11 +68,14 @@ private fun ColorContent(
 ) {
     Surface(
         color = color,
+        modifier = Modifier
+            .itemDefaultPadding()
+            .then(modifier),
     ) {
         Row(
             verticalAlignment = Alignment.CenterVertically,
             horizontalArrangement = Arrangement.Center,
-            modifier = modifier.padding(MainTheme.spacings.double),
+            modifier = Modifier.padding(MainTheme.spacings.double),
         ) {
             TextBody1(text = name)
         }
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/IconItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/IconItems.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3938d185dca83395fed02e40c4aba610bfa7e1d3
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/IconItems.kt
@@ -0,0 +1,65 @@
+package app.k9mail.ui.catalog.ui.atom.items
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import app.k9mail.core.ui.compose.designsystem.atom.Icon
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextCaption
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.ui.catalog.ui.common.list.itemDefaultPadding
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
+
+fun LazyGridScope.iconItems() {
+    sectionHeaderItem(text = "Filled")
+    getIconsFor(Icons.Filled)
+    sectionHeaderItem(text = "Outlined")
+    getIconsFor(Icons.Outlined)
+}
+
+private inline fun <reified T> LazyGridScope.getIconsFor(icons: T) {
+    for (field in T::class.java.declaredFields) {
+        if (field.name in exclusions) continue
+        item {
+            field.isAccessible = true
+            IconItem(
+                name = field.name.replaceFirstChar { it.uppercase() },
+                imageVector = field.get(icons) as ImageVector,
+            )
+        }
+    }
+}
+
+private val exclusions = listOf("\$stable", "INSTANCE")
+
+@Composable
+private fun IconItem(
+    name: String,
+    imageVector: ImageVector,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = Modifier
+            .itemDefaultPadding()
+            .then(modifier),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+    ) {
+        Row {
+            Icon(
+                imageVector = imageVector,
+            )
+            Icon(
+                imageVector = imageVector,
+                tint = Color.Magenta,
+            )
+        }
+        TextCaption(text = name)
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ImageItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ImageItems.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b3bae7d15565f5f73d1d925f1703310a9323b3a0
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ImageItems.kt
@@ -0,0 +1,20 @@
+package app.k9mail.ui.catalog.ui.atom.items
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.ui.catalog.ui.common.list.itemDefaultPadding
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
+
+fun LazyGridScope.imageItems() {
+    sectionHeaderItem(text = "Images")
+    item {
+        Image(
+            painter = painterResource(id = MainTheme.images.logo),
+            contentDescription = "logo",
+            modifier = Modifier.itemDefaultPadding(),
+        )
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SelectionControlItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/SelectionControlItems.kt
similarity index 56%
rename from app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SelectionControlItems.kt
rename to app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/SelectionControlItems.kt
index cd583cb9661dc15c723dfc9c5f2dd7b36f81ca8e..3633775ea23efb3ac5d86f0ecb0ae4964324c8ab 100644
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SelectionControlItems.kt
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/SelectionControlItems.kt
@@ -1,15 +1,18 @@
-package app.k9mail.ui.catalog.items
+package app.k9mail.ui.catalog.ui.atom.items
 
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.lazy.grid.LazyGridScope
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
 import app.k9mail.core.ui.compose.designsystem.atom.Checkbox
+import app.k9mail.core.ui.compose.designsystem.atom.Switch
 import app.k9mail.core.ui.compose.designsystem.atom.text.TextCaption
+import app.k9mail.ui.catalog.ui.common.list.itemDefaultPadding
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
 
 fun LazyGridScope.selectionControlItems() {
-    sectionHeaderItem(text = "Selection Controls")
-    sectionSubtitleItem(text = "Checkbox")
+    sectionHeaderItem(text = "Checkbox")
     captionItem(caption = "Checked") {
         Checkbox(checked = true, onCheckedChange = {})
     }
@@ -22,6 +25,19 @@ fun LazyGridScope.selectionControlItems() {
     captionItem(caption = "Disabled") {
         Checkbox(checked = false, onCheckedChange = {}, enabled = false)
     }
+    sectionHeaderItem(text = "Switch")
+    captionItem(caption = "Checked") {
+        Switch(checked = true, onCheckedChange = {})
+    }
+    captionItem(caption = "Unchecked") {
+        Switch(checked = false, onCheckedChange = {})
+    }
+    captionItem(caption = "Disabled Checked") {
+        Switch(checked = true, onCheckedChange = {}, enabled = false)
+    }
+    captionItem(caption = "Disabled") {
+        Switch(checked = false, onCheckedChange = {}, enabled = false)
+    }
 }
 
 private fun LazyGridScope.captionItem(
@@ -31,6 +47,7 @@ private fun LazyGridScope.captionItem(
     item {
         Column(
             horizontalAlignment = Alignment.CenterHorizontally,
+            modifier = Modifier.itemDefaultPadding(),
         ) {
             content()
             TextCaption(text = caption)
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/TextFieldItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/TextFieldItems.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c5196375315ea0a6369d76f54c83dcc0db28b488
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/TextFieldItems.kt
@@ -0,0 +1,275 @@
+package app.k9mail.ui.catalog.ui.atom.items
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.key
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import app.k9mail.core.ui.compose.designsystem.atom.Icon
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlined
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedEmailAddress
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedNumber
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedPassword
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedSelect
+import app.k9mail.core.ui.compose.designsystem.molecule.input.CheckboxInput
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.ui.catalog.ui.common.helper.WithRememberedState
+import app.k9mail.ui.catalog.ui.common.list.itemDefaultPadding
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
+import app.k9mail.ui.catalog.ui.common.list.sectionSubtitleItem
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+
+fun LazyGridScope.textFieldItems() {
+    sectionHeaderItem(text = "Text field - Outlined")
+    sectionSubtitleItem(text = "Default")
+    textFieldOutlinedItems()
+    sectionSubtitleItem(text = "Password")
+    passwordTextFieldOutlinedItems()
+    sectionSubtitleItem(text = "Email address")
+    emailTextFieldOutlinedItems()
+    sectionSubtitleItem(text = "Number")
+    numberTextFieldOutlinedItems()
+    sectionSubtitleItem(text = "Selection")
+    selectionTextFieldOutlinedItems()
+}
+
+@Stable
+data class TextFieldState<T>(
+    val input: T,
+    val label: String = "Label",
+    val showLabel: Boolean = false,
+    val showTrailingIcon: Boolean = false,
+    val isDisabled: Boolean = false,
+    val isReadOnly: Boolean = false,
+    val isRequired: Boolean = false,
+    val hasError: Boolean = false,
+    val isSingleLine: Boolean = false,
+)
+
+@Suppress("LongMethod")
+@Composable
+fun <T> TextFieldDemo(
+    initialState: TextFieldState<T>,
+    modifier: Modifier = Modifier,
+    hasTrailingIcon: Boolean = false,
+    hasSingleLine: Boolean = false,
+    content: @Composable (state: MutableState<TextFieldState<T>>) -> Unit,
+) {
+    WithRememberedState(input = initialState) { state ->
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .itemDefaultPadding()
+                .then(modifier),
+        ) {
+            key(state.value.showLabel, state.value.isRequired) {
+                content(state)
+            }
+
+            Column(modifier = Modifier.fillMaxWidth()) {
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(
+                            top = MainTheme.spacings.double,
+                            start = MainTheme.spacings.default,
+                        ),
+                ) {
+                    TextSubtitle1(text = "Configuration:")
+                }
+
+                CheckboxInput(
+                    text = "Show Label",
+                    checked = state.value.showLabel,
+                    onCheckedChange = { state.value = state.value.copy(showLabel = it) },
+                    contentPadding = defaultPadding,
+                )
+
+                if (hasTrailingIcon) {
+                    CheckboxInput(
+                        text = "Show Trailing Icon",
+                        checked = state.value.showTrailingIcon,
+                        onCheckedChange = { state.value = state.value.copy(showTrailingIcon = it) },
+                        contentPadding = defaultPadding,
+                    )
+                }
+
+                CheckboxInput(
+                    text = "Is required",
+                    checked = state.value.isRequired,
+                    onCheckedChange = { state.value = state.value.copy(isRequired = it) },
+                    contentPadding = defaultPadding,
+                )
+
+                CheckboxInput(
+                    text = "Is read-only",
+                    checked = state.value.isReadOnly,
+                    onCheckedChange = { state.value = state.value.copy(isReadOnly = it) },
+                    contentPadding = defaultPadding,
+                )
+
+                CheckboxInput(
+                    text = "Is disabled",
+                    checked = state.value.isDisabled,
+                    onCheckedChange = { state.value = state.value.copy(isDisabled = it) },
+                    contentPadding = defaultPadding,
+                )
+
+                CheckboxInput(
+                    text = "Has Error",
+                    checked = state.value.hasError,
+                    onCheckedChange = { state.value = state.value.copy(hasError = it) },
+                    contentPadding = defaultPadding,
+                )
+
+                if (hasSingleLine) {
+                    CheckboxInput(
+                        text = "Single line",
+                        checked = state.value.isSingleLine,
+                        onCheckedChange = { state.value = state.value.copy(isSingleLine = it) },
+                        contentPadding = defaultPadding,
+                    )
+                }
+            }
+        }
+    }
+}
+
+private val defaultPadding = PaddingValues(0.dp)
+
+private fun LazyGridScope.textFieldOutlinedItems() {
+    item {
+        TextFieldDemo(
+            hasTrailingIcon = true,
+            hasSingleLine = true,
+            initialState = TextFieldState(input = ""),
+        ) { state ->
+            TextFieldOutlined(
+                value = state.value.input,
+                label = if (state.value.showLabel) state.value.label else null,
+                onValueChange = { state.value = state.value.copy(input = it) },
+                trailingIcon = {
+                    if (state.value.showTrailingIcon) {
+                        Icon(imageVector = Icons.Filled.user)
+                    }
+                },
+                isEnabled = !state.value.isDisabled,
+                isReadOnly = state.value.isReadOnly,
+                isRequired = state.value.isRequired,
+                isSingleLine = state.value.isSingleLine,
+                hasError = state.value.hasError,
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+    }
+}
+
+private fun LazyGridScope.passwordTextFieldOutlinedItems() {
+    item {
+        TextFieldDemo(
+            initialState = TextFieldState(
+                input = "",
+                label = "Password",
+            ),
+        ) { state ->
+            TextFieldOutlinedPassword(
+                value = state.value.input,
+                label = if (state.value.showLabel) state.value.label else null,
+                onValueChange = { state.value = state.value.copy(input = it) },
+                isEnabled = !state.value.isDisabled,
+                isReadOnly = state.value.isReadOnly,
+                isRequired = state.value.isRequired,
+                hasError = state.value.hasError,
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+    }
+}
+
+private fun LazyGridScope.emailTextFieldOutlinedItems() {
+    item {
+        TextFieldDemo(
+            initialState = TextFieldState(
+                input = "",
+                label = "Email Address",
+            ),
+        ) { state ->
+            TextFieldOutlinedEmailAddress(
+                value = state.value.input,
+                label = if (state.value.showLabel) state.value.label else null,
+                onValueChange = { state.value = state.value.copy(input = it) },
+                isEnabled = !state.value.isDisabled,
+                isReadOnly = state.value.isReadOnly,
+                isRequired = state.value.isRequired,
+                hasError = state.value.hasError,
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+    }
+}
+
+private fun LazyGridScope.numberTextFieldOutlinedItems() {
+    item {
+        TextFieldDemo(
+            initialState = TextFieldState<Long?>(
+                input = 123L,
+                label = "Number",
+            ),
+        ) { state ->
+            TextFieldOutlinedNumber(
+                value = state.value.input,
+                label = if (state.value.showLabel) state.value.label else null,
+                onValueChange = { state.value = state.value.copy(input = it) },
+                isEnabled = !state.value.isDisabled,
+                isReadOnly = state.value.isReadOnly,
+                isRequired = state.value.isRequired,
+                hasError = state.value.hasError,
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+    }
+}
+
+private data class TextFieldSelectState(
+    val options: ImmutableList<String> = persistentListOf("Option 1", "Option 2", "Option 3"),
+    val selectedOption: String = options.first(),
+)
+
+private fun LazyGridScope.selectionTextFieldOutlinedItems() {
+    item {
+        TextFieldDemo(
+            initialState = TextFieldState(
+                input = TextFieldSelectState(),
+                label = "Select",
+            ),
+        ) { state ->
+            key(
+                state.value.input.selectedOption,
+            ) {
+                TextFieldOutlinedSelect(
+                    options = state.value.input.options,
+                    label = if (state.value.showLabel) state.value.label else null,
+                    onValueChange = {
+                        state.value = state.value.copy(input = state.value.input.copy(selectedOption = it))
+                    },
+                    selectedOption = state.value.input.selectedOption,
+                    isEnabled = !state.value.isDisabled,
+                    isReadOnly = state.value.isReadOnly,
+                    isRequired = state.value.isRequired,
+                    hasError = state.value.hasError,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+            }
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/TypographyItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/TypographyItems.kt
new file mode 100644
index 0000000000000000000000000000000000000000..343717b2bfbdaf1fbbba0adbf3783237949c441f
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/TypographyItems.kt
@@ -0,0 +1,147 @@
+package app.k9mail.ui.catalog.ui.atom.items
+
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.withStyle
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody2
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextButton
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextCaption
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline1
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline2
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline3
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline4
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline5
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline6
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextOverline
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle2
+import app.k9mail.ui.catalog.ui.common.list.itemDefaultPadding
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
+
+fun LazyGridScope.typographyItems() {
+    sectionHeaderItem(text = "Text styles")
+    textItems()
+
+    sectionHeaderItem(text = "Text styles - Colored")
+    textItems(color = Color.Magenta)
+
+    sectionHeaderItem(text = "Text styles - Annotated")
+    textItems(isAnnotated = true)
+}
+
+@Suppress("LongMethod")
+private fun LazyGridScope.textItems(
+    isAnnotated: Boolean = false,
+    color: Color = Color.Unspecified,
+) {
+    item {
+        TextHeadline1(
+            text = annotatedString("Headline1", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextHeadline2(
+            text = annotatedString("Headline2", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextHeadline3(
+            text = annotatedString("Headline3", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+
+        )
+    }
+    item {
+        TextHeadline4(
+            text = annotatedString("Headline4", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextHeadline5(
+            text = annotatedString("Headline5", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+
+    item {
+        TextHeadline6(
+            text = annotatedString("Headline6", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextSubtitle1(
+            text = annotatedString("Subtitle1", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextSubtitle2(
+            text = annotatedString("Subtitle2", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextBody1(
+            text = annotatedString("Body1", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextBody2(
+            text = annotatedString("Body2", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextButton(
+            text = annotatedString("Button", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextCaption(
+            text = annotatedString("Caption", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextOverline(
+            text = annotatedString("Overline", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+}
+
+private fun annotatedString(
+    name: String,
+    isAnnotated: Boolean,
+) = buildAnnotatedString {
+    append(name)
+    if (isAnnotated) {
+        withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+            append("Annotated")
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/PagedContent.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/PagedContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0a4515045703da93693cfa981acab904ebebfd46
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/PagedContent.kt
@@ -0,0 +1,76 @@
+package app.k9mail.ui.catalog.ui.common
+
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.pager.HorizontalPager
+import androidx.compose.foundation.pager.rememberPagerState
+import androidx.compose.material.ScrollableTabRow
+import androidx.compose.material.Tab
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveContentWithBackground
+import app.k9mail.core.ui.compose.theme.MainTheme
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.coroutines.launch
+
+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+fun <T> PagedContent(
+    pages: ImmutableList<T>,
+    initialPage: T,
+    modifier: Modifier = Modifier,
+    onRenderPage: LazyGridScope.(T) -> Unit,
+) {
+    val pagerState = rememberPagerState(initialPage = pages.indexOf(initialPage))
+    val coroutineScope = rememberCoroutineScope()
+
+    Column(
+        modifier = modifier,
+    ) {
+        ScrollableTabRow(
+            selectedTabIndex = pagerState.currentPage,
+        ) {
+            pages.forEachIndexed { index, title ->
+                Tab(
+                    selected = pagerState.currentPage == index,
+                    onClick = {
+                        coroutineScope.launch {
+                            pagerState.animateScrollToPage(index)
+                        }
+                    },
+                    text = { Text(text = title.toString()) },
+                )
+            }
+        }
+        ResponsiveContentWithBackground {
+            HorizontalPager(
+                pageCount = pages.size,
+                state = pagerState,
+                modifier = Modifier
+                    .fillMaxSize(),
+            ) { page ->
+                LazyVerticalGrid(
+                    columns = GridCells.Adaptive(300.dp),
+                    modifier = Modifier.fillMaxSize()
+                        .imePadding(),
+                    horizontalArrangement = Arrangement.spacedBy(MainTheme.spacings.double),
+                    verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.double),
+                ) {
+                    onRenderPage(pages[page])
+                    item { Spacer(modifier = Modifier.height(MainTheme.sizes.smaller)) }
+                }
+            }
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/ThemeTopAppBar.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/ThemeTopAppBar.kt
new file mode 100644
index 0000000000000000000000000000000000000000..908222286250e34acfd439af7af6e42512deea4d
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/ThemeTopAppBar.kt
@@ -0,0 +1,49 @@
+package app.k9mail.ui.catalog.ui.common
+
+import androidx.compose.material.icons.filled.DarkMode
+import androidx.compose.material.icons.filled.LightMode
+import androidx.compose.material.icons.filled.ShuffleOn
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonIcon
+import app.k9mail.core.ui.compose.designsystem.organism.TopAppBar
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.ui.catalog.ui.CatalogContract.Theme
+import app.k9mail.ui.catalog.ui.CatalogContract.ThemeVariant
+import androidx.compose.material.icons.Icons as MaterialIcons
+
+@Composable
+fun ThemeTopAppBar(
+    onNavigationClick: () -> Unit,
+    theme: Theme,
+    themeVariant: ThemeVariant,
+    onThemeClick: () -> Unit,
+    onThemeVariantClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    TopAppBar(
+        title = "${theme.displayName} Catalog",
+        navigationIcon = {
+            ButtonIcon(
+                onClick = onNavigationClick,
+                imageVector = Icons.Outlined.menu,
+            )
+        },
+        actions = {
+            ButtonIcon(
+                onClick = onThemeClick,
+                imageVector = MaterialIcons.Filled.ShuffleOn,
+                contentDescription = "${theme.displayName} Theme",
+            )
+            ButtonIcon(
+                onClick = onThemeVariantClick,
+                imageVector = when (themeVariant) {
+                    ThemeVariant.LIGHT -> MaterialIcons.Filled.DarkMode
+                    ThemeVariant.DARK -> MaterialIcons.Filled.LightMode
+                },
+                contentDescription = "${theme.displayName} Theme Variant",
+            )
+        },
+        modifier = modifier,
+    )
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerCategoryItem.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerCategoryItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a04959d942a2468c2427d7ee7eae6c3599208a3a
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerCategoryItem.kt
@@ -0,0 +1,45 @@
+package app.k9mail.ui.catalog.ui.common.drawer
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun DrawerCategoryItem(
+    text: String,
+    onItemClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable { onItemClick() }
+            .then(modifier),
+    ) {
+        TextSubtitle1(
+            text = text,
+            modifier = Modifier.padding(
+                horizontal = MainTheme.spacings.double,
+                vertical = MainTheme.spacings.default,
+            ),
+        )
+    }
+}
+
+@Preview
+@Composable
+fun DrawerCategoryItemPreview() {
+    PreviewWithThemes {
+        DrawerCategoryItem(
+            text = "Text",
+            onItemClick = {},
+        )
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerContent.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f33a77998dd986f28fb5f1b2c5b0cc222ff539c5
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerContent.kt
@@ -0,0 +1,89 @@
+package app.k9mail.ui.catalog.ui.common.drawer
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.ui.catalog.ui.CatalogContract.Theme
+import app.k9mail.ui.catalog.ui.CatalogContract.ThemeVariant
+import app.k9mail.ui.catalog.ui.common.theme.ThemeSelector
+import app.k9mail.ui.catalog.ui.common.theme.ThemeVariantSelector
+
+@Suppress("LongParameterList", "LongMethod")
+@Composable
+fun DrawerContent(
+    toggleDrawer: () -> Unit,
+    theme: Theme,
+    themeVariant: ThemeVariant,
+    onThemeChanged: () -> Unit,
+    onThemeVariantChanged: () -> Unit,
+    onNavigateToAtoms: () -> Unit,
+    onNavigateToMolecules: () -> Unit,
+    onNavigateToOrganisms: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    LazyColumn(
+        modifier = modifier,
+        verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+    ) {
+        item {
+            DrawerHeaderItem(
+                text = "Design system",
+            )
+        }
+        item {
+            DrawerCategoryItem(
+                text = "Atoms",
+                onItemClick = {
+                    toggleDrawer()
+                    onNavigateToAtoms()
+                },
+            )
+        }
+        item {
+            DrawerCategoryItem(
+                text = "Molecules",
+                onItemClick = {
+                    toggleDrawer()
+                    onNavigateToMolecules()
+                },
+            )
+        }
+        item {
+            DrawerCategoryItem(
+                text = "Organisms",
+                onItemClick = {
+                    toggleDrawer()
+                    onNavigateToOrganisms()
+                },
+            )
+        }
+
+        item {
+            DrawerHeaderItem(
+                text = "Theme selection",
+            )
+        }
+        item {
+            ThemeSelector(
+                theme = theme,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = MainTheme.spacings.double),
+                onThemeChangeClick = onThemeChanged,
+            )
+        }
+        item {
+            ThemeVariantSelector(
+                themeVariant = themeVariant,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = MainTheme.spacings.double),
+                onThemeVariantChange = onThemeVariantChanged,
+            )
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerHeaderItem.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerHeaderItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d176eb537281a39db2326755cbc96804324495bb
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerHeaderItem.kt
@@ -0,0 +1,44 @@
+package app.k9mail.ui.catalog.ui.common.drawer
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.Divider
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline6
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun DrawerHeaderItem(
+    text: String,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(
+                start = MainTheme.spacings.double,
+                top = MainTheme.spacings.double,
+                end = MainTheme.spacings.double,
+            )
+            .then(modifier),
+    ) {
+        TextHeadline6(
+            text = text,
+        )
+        Divider()
+    }
+}
+
+@Preview
+@Composable
+fun DrawerHeaderItemPreview() {
+    PreviewWithThemes {
+        DrawerHeaderItem(
+            text = "Category",
+        )
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/helper/WithRememberedState.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/helper/WithRememberedState.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3aa78eaf6122870cd6eb3a90c5ad50667435fa06
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/helper/WithRememberedState.kt
@@ -0,0 +1,15 @@
+package app.k9mail.ui.catalog.ui.common.helper
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+
+@Composable
+internal fun <T> WithRememberedState(
+    input: T,
+    content: @Composable (state: MutableState<T>) -> Unit,
+) {
+    val state = remember { mutableStateOf(input) }
+    content(state)
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/ItemDefaultPadding.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/ItemDefaultPadding.kt
new file mode 100644
index 0000000000000000000000000000000000000000..54a2cf5362975e7e2eed4687100bd86442ec6d1e
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/ItemDefaultPadding.kt
@@ -0,0 +1,12 @@
+package app.k9mail.ui.catalog.ui.common.list
+
+import androidx.compose.foundation.layout.padding
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.composed
+import app.k9mail.core.ui.compose.theme.MainTheme
+
+fun Modifier.itemDefaultPadding(): Modifier = composed {
+    padding(
+        horizontal = MainTheme.spacings.double,
+    )
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/ItemOutlined.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/ItemOutlined.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1fa775549e71ef63e204c9626f61da8f5394f7db
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/ItemOutlined.kt
@@ -0,0 +1,33 @@
+package app.k9mail.ui.catalog.ui.common.list
+
+import androidx.compose.foundation.border
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import app.k9mail.core.ui.compose.theme.MainTheme
+
+@Composable
+fun ItemOutlined(
+    modifier: Modifier = Modifier,
+    content: @Composable () -> Unit,
+) {
+    Column(
+        verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+        modifier = Modifier
+            .itemDefaultPadding()
+            .then(modifier),
+    ) {
+        Box(
+            modifier = Modifier
+                .border(1.dp, Color.Gray)
+                .fillMaxWidth(),
+        ) {
+            content()
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/SectionHeaderItem.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/SectionHeaderItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3d9cd8bc738581c8937e0b9243626b987122f1a3
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/SectionHeaderItem.kt
@@ -0,0 +1,32 @@
+package app.k9mail.ui.catalog.ui.common.list
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.grid.GridItemSpan
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.designsystem.atom.Divider
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline6
+import app.k9mail.core.ui.compose.theme.MainTheme
+
+fun LazyGridScope.sectionHeaderItem(
+    text: String,
+) {
+    item(span = { GridItemSpan(maxLineSpan) }) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(
+                    start = MainTheme.spacings.double,
+                    top = MainTheme.spacings.double,
+                    end = MainTheme.spacings.double,
+                ),
+        ) {
+            TextHeadline6(
+                text = text,
+            )
+            Divider()
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/SectionSubtitleItem.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/SectionSubtitleItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..be8432e20031450213ac5e44f7aeb4b77ab8eccf
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/SectionSubtitleItem.kt
@@ -0,0 +1,32 @@
+package app.k9mail.ui.catalog.ui.common.list
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.grid.GridItemSpan
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.designsystem.atom.Divider
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
+import app.k9mail.core.ui.compose.theme.MainTheme
+
+fun LazyGridScope.sectionSubtitleItem(
+    text: String,
+) {
+    item(span = { GridItemSpan(maxLineSpan) }) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(
+                    start = MainTheme.spacings.double,
+                    top = MainTheme.spacings.default,
+                    end = MainTheme.spacings.double,
+                ),
+        ) {
+            TextSubtitle1(
+                text = text,
+            )
+            Divider()
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeSelector.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeSelector.kt
similarity index 81%
rename from app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeSelector.kt
rename to app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeSelector.kt
index 88896fa40d17a5e9b8bec62defb293fe100920c9..80a37e14aa464d7dde49821fdc1a116eecbc6018 100644
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeSelector.kt
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeSelector.kt
@@ -1,4 +1,4 @@
-package app.k9mail.ui.catalog
+package app.k9mail.ui.catalog.ui.common.theme
 
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Row
@@ -8,10 +8,11 @@ import androidx.compose.ui.Modifier
 import app.k9mail.core.ui.compose.designsystem.atom.button.Button
 import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
 import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.ui.catalog.ui.CatalogContract.Theme
 
 @Composable
-fun CatalogThemeSelector(
-    catalogTheme: CatalogTheme,
+fun ThemeSelector(
+    theme: Theme,
     modifier: Modifier = Modifier,
     onThemeChangeClick: () -> Unit,
 ) {
@@ -22,7 +23,7 @@ fun CatalogThemeSelector(
     ) {
         TextBody1(text = "Change theme:")
         Button(
-            text = catalogTheme.toString(),
+            text = theme.toString(),
             onClick = onThemeChangeClick,
         )
     }
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeSwitch.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeSwitch.kt
similarity index 62%
rename from app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeSwitch.kt
rename to app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeSwitch.kt
index 116c05a4d1cbd34de873ff72bc7a57063cc33f2d..5d5e8098f6271c5be7b9542b96a3f0e20e5e42a9 100644
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeSwitch.kt
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeSwitch.kt
@@ -1,21 +1,23 @@
-package app.k9mail.ui.catalog
+package app.k9mail.ui.catalog.ui.common.theme
 
 import androidx.compose.runtime.Composable
 import app.k9mail.core.ui.compose.theme.K9Theme
 import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.ui.catalog.ui.CatalogContract.Theme
+import app.k9mail.ui.catalog.ui.CatalogContract.ThemeVariant
 
 @Composable
-fun CatalogThemeSwitch(
-    theme: CatalogTheme,
-    themeVariant: CatalogThemeVariant,
+fun ThemeSwitch(
+    theme: Theme,
+    themeVariant: ThemeVariant,
     content: @Composable () -> Unit,
 ) {
     when (theme) {
-        CatalogTheme.K9 -> K9ThemeSwitch(
+        Theme.K9 -> K9ThemeSwitch(
             themeVariant = themeVariant,
             content = content,
         )
-        CatalogTheme.THUNDERBIRD -> ThunderbirdThemeSwitch(
+        Theme.THUNDERBIRD -> ThunderbirdThemeSwitch(
             themeVariant = themeVariant,
             content = content,
         )
@@ -24,15 +26,15 @@ fun CatalogThemeSwitch(
 
 @Composable
 private fun K9ThemeSwitch(
-    themeVariant: CatalogThemeVariant,
+    themeVariant: ThemeVariant,
     content: @Composable () -> Unit,
 ) {
     when (themeVariant) {
-        CatalogThemeVariant.LIGHT -> K9Theme(
+        ThemeVariant.LIGHT -> K9Theme(
             darkTheme = false,
             content = content,
         )
-        CatalogThemeVariant.DARK -> K9Theme(
+        ThemeVariant.DARK -> K9Theme(
             darkTheme = true,
             content = content,
         )
@@ -41,15 +43,15 @@ private fun K9ThemeSwitch(
 
 @Composable
 private fun ThunderbirdThemeSwitch(
-    themeVariant: CatalogThemeVariant,
+    themeVariant: ThemeVariant,
     content: @Composable () -> Unit,
 ) {
     when (themeVariant) {
-        CatalogThemeVariant.LIGHT -> ThunderbirdTheme(
+        ThemeVariant.LIGHT -> ThunderbirdTheme(
             darkTheme = false,
             content = content,
         )
-        CatalogThemeVariant.DARK -> ThunderbirdTheme(
+        ThemeVariant.DARK -> ThunderbirdTheme(
             darkTheme = true,
             content = content,
         )
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeVariantSelector.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeVariantSelector.kt
similarity index 74%
rename from app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeVariantSelector.kt
rename to app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeVariantSelector.kt
index aeafed5c0da5953eb4fbc2b94952d465874ebec7..5bc12a522047c6a14a33e1aa085a822e6ee8edba 100644
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeVariantSelector.kt
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeVariantSelector.kt
@@ -1,4 +1,4 @@
-package app.k9mail.ui.catalog
+package app.k9mail.ui.catalog.ui.common.theme
 
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Row
@@ -8,10 +8,11 @@ import androidx.compose.ui.Modifier
 import app.k9mail.core.ui.compose.designsystem.atom.Checkbox
 import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
 import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.ui.catalog.ui.CatalogContract.ThemeVariant
 
 @Composable
-fun CatalogThemeVariantSelector(
-    catalogThemeVariant: CatalogThemeVariant,
+fun ThemeVariantSelector(
+    themeVariant: ThemeVariant,
     modifier: Modifier = Modifier,
     onThemeVariantChange: () -> Unit,
 ) {
@@ -20,9 +21,9 @@ fun CatalogThemeVariantSelector(
         verticalAlignment = Alignment.CenterVertically,
         horizontalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
     ) {
-        TextBody1(text = "Dark mode:")
+        TextBody1(text = "Enable dark mode:")
         Checkbox(
-            checked = catalogThemeVariant == CatalogThemeVariant.DARK,
+            checked = themeVariant == ThemeVariant.DARK,
             onCheckedChange = { onThemeVariantChange() },
         )
     }
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeContent.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..caa1241f1d883516537c9f9dd19cb09a162d279d
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeContent.kt
@@ -0,0 +1,28 @@
+package app.k9mail.ui.catalog.ui.molecule
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.ui.catalog.ui.common.PagedContent
+import app.k9mail.ui.catalog.ui.molecule.CatalogMoleculePage.INPUT
+import app.k9mail.ui.catalog.ui.molecule.CatalogMoleculePage.STATE
+import app.k9mail.ui.catalog.ui.molecule.items.inputItems
+import app.k9mail.ui.catalog.ui.molecule.items.stateItems
+import kotlinx.collections.immutable.ImmutableList
+
+@Composable
+fun CatalogMoleculeContent(
+    pages: ImmutableList<CatalogMoleculePage>,
+    initialPage: CatalogMoleculePage,
+    modifier: Modifier = Modifier,
+) {
+    PagedContent(
+        pages = pages,
+        initialPage = initialPage,
+        modifier = modifier,
+    ) {
+        when (it) {
+            INPUT -> inputItems()
+            STATE -> stateItems()
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeNavigation.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeNavigation.kt
new file mode 100644
index 0000000000000000000000000000000000000000..aa28844c96a0d5da3b2026782dcdb032a53c3bd7
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeNavigation.kt
@@ -0,0 +1,23 @@
+package app.k9mail.ui.catalog.ui.molecule
+
+import androidx.navigation.NavController
+import androidx.navigation.NavGraphBuilder
+import androidx.navigation.NavOptions
+import androidx.navigation.compose.composable
+
+const val NAVIGATION_ROUTE_CATALOG_MOLECULE = "/catalog/molecule"
+
+fun NavController.navigateToCatalogMolecule() {
+    navigate(
+        route = NAVIGATION_ROUTE_CATALOG_MOLECULE,
+        navOptions = NavOptions.Builder()
+            .setLaunchSingleTop(true)
+            .build(),
+    )
+}
+
+fun NavGraphBuilder.catalogMoleculeRoute() {
+    composable(route = NAVIGATION_ROUTE_CATALOG_MOLECULE) {
+        CatalogMoleculeScreen()
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculePage.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculePage.kt
new file mode 100644
index 0000000000000000000000000000000000000000..cfd4018c21c769187ed09cea7bc64dfd53a472f3
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculePage.kt
@@ -0,0 +1,19 @@
+package app.k9mail.ui.catalog.ui.molecule
+
+import kotlinx.collections.immutable.toImmutableList
+
+enum class CatalogMoleculePage(
+    private val displayName: String,
+) {
+    INPUT("Inputs"),
+    STATE("States"),
+    ;
+
+    override fun toString(): String {
+        return displayName
+    }
+
+    companion object {
+        fun all() = values().toList().toImmutableList()
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeScreen.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b51282ae963a59b4be448e96b2f4685beb3c8893
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeScreen.kt
@@ -0,0 +1,15 @@
+package app.k9mail.ui.catalog.ui.molecule
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+
+@Composable
+fun CatalogMoleculeScreen(
+    modifier: Modifier = Modifier,
+) {
+    CatalogMoleculeContent(
+        pages = CatalogMoleculePage.all(),
+        initialPage = CatalogMoleculePage.INPUT,
+        modifier = modifier,
+    )
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/items/InputItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/items/InputItems.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f186d871b34460db746c56237694afc9163fce7a
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/items/InputItems.kt
@@ -0,0 +1,186 @@
+package app.k9mail.ui.catalog.ui.molecule.items
+
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import app.k9mail.core.ui.compose.designsystem.molecule.input.CheckboxInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.EmailAddressInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.NumberInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.PasswordInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.SelectInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.SwitchInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.TextInput
+import app.k9mail.ui.catalog.ui.common.helper.WithRememberedState
+import app.k9mail.ui.catalog.ui.common.list.ItemOutlined
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
+import app.k9mail.ui.catalog.ui.common.list.sectionSubtitleItem
+import kotlinx.collections.immutable.persistentListOf
+
+@Suppress("LongMethod")
+fun LazyGridScope.inputItems() {
+    sectionHeaderItem(text = "TextInput")
+    sectionSubtitleItem(text = "Default")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = "") { state ->
+                TextInput(
+                    text = state.value,
+                    onTextChange = { state.value = it },
+                )
+            }
+        }
+    }
+    sectionSubtitleItem(text = "With error")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = "") { state ->
+                TextInput(
+                    text = state.value,
+                    onTextChange = { state.value = it },
+                    errorMessage = "Invalid input",
+                )
+            }
+        }
+    }
+
+    sectionHeaderItem(text = "EmailAddressInput")
+    sectionSubtitleItem(text = "Default")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = "") { state ->
+                EmailAddressInput(
+                    emailAddress = state.value,
+                    onEmailAddressChange = { state.value = it },
+                )
+            }
+        }
+    }
+    sectionSubtitleItem(text = "With error")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = "wrong email address") { state ->
+                EmailAddressInput(
+                    emailAddress = state.value,
+                    onEmailAddressChange = { state.value = it },
+                    errorMessage = "Invalid email address",
+                )
+            }
+        }
+    }
+
+    sectionHeaderItem(text = "NumberInput")
+    sectionSubtitleItem(text = "Default")
+    item {
+        ItemOutlined {
+            WithRememberedState<Long?>(input = null) { state ->
+                NumberInput(
+                    value = state.value,
+                    onValueChange = { state.value = it },
+                )
+            }
+        }
+    }
+    sectionSubtitleItem(text = "With error")
+    item {
+        ItemOutlined {
+            WithRememberedState<Long?>(input = 123L) { state ->
+                NumberInput(
+                    value = state.value,
+                    onValueChange = { state.value = it },
+                    errorMessage = "Invalid number",
+                )
+            }
+        }
+    }
+
+    sectionHeaderItem(text = "PasswordInput")
+    sectionSubtitleItem(text = "Default")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = "") { state ->
+                PasswordInput(
+                    password = state.value,
+                    onPasswordChange = { state.value = it },
+                )
+            }
+        }
+    }
+    sectionSubtitleItem(text = "With error")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = "wrong password") { state ->
+                PasswordInput(
+                    password = state.value,
+                    onPasswordChange = { state.value = it },
+                    errorMessage = "Invalid password",
+                )
+            }
+        }
+    }
+
+    sectionHeaderItem(text = "SelectInput")
+    item {
+        val options = persistentListOf("Option 1", "Option 2", "Option 3")
+        ItemOutlined {
+            WithRememberedState(input = options.first()) { state ->
+                SelectInput(
+                    options = options,
+                    selectedOption = state.value,
+                    onOptionChange = { state.value = it },
+                )
+            }
+        }
+    }
+
+    sectionHeaderItem(text = "CheckboxInput")
+    sectionSubtitleItem(text = "Default")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = false) { state ->
+                CheckboxInput(
+                    text = "Check the box",
+                    checked = state.value,
+                    onCheckedChange = { state.value = it },
+                )
+            }
+        }
+    }
+    sectionSubtitleItem(text = "With error")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = false) { state ->
+                CheckboxInput(
+                    text = "Check the box",
+                    checked = state.value,
+                    onCheckedChange = { state.value = it },
+                    errorMessage = "Checkbox must be checked",
+                )
+            }
+        }
+    }
+
+    sectionHeaderItem(text = "SwitchInput")
+    sectionSubtitleItem(text = "Default")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = false) { state ->
+                SwitchInput(
+                    text = "Switch the toggle",
+                    checked = state.value,
+                    onCheckedChange = { state.value = it },
+                )
+            }
+        }
+    }
+    sectionSubtitleItem(text = "With error")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = false) { state ->
+                SwitchInput(
+                    text = "Switch the toggle",
+                    checked = state.value,
+                    onCheckedChange = { state.value = it },
+                    errorMessage = "Switch must be checked",
+                )
+            }
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/items/StateItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/items/StateItems.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3bd37e2fa1aecf6f5890c1828ad602a9af9733c4
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/items/StateItems.kt
@@ -0,0 +1,36 @@
+package app.k9mail.ui.catalog.ui.molecule.items
+
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import app.k9mail.core.ui.compose.designsystem.molecule.ErrorView
+import app.k9mail.core.ui.compose.designsystem.molecule.LoadingView
+import app.k9mail.ui.catalog.ui.common.list.ItemOutlined
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
+import app.k9mail.ui.catalog.ui.common.list.sectionSubtitleItem
+
+fun LazyGridScope.stateItems() {
+    sectionHeaderItem(text = "ErrorView")
+    item {
+        ItemOutlined {
+            ErrorView(
+                title = "Error",
+                message = "Something went wrong",
+            )
+        }
+    }
+
+    sectionHeaderItem(text = "LoadingView")
+    sectionSubtitleItem(text = "Default")
+    item {
+        ItemOutlined {
+            LoadingView()
+        }
+    }
+    sectionSubtitleItem(text = "With message")
+    item {
+        ItemOutlined {
+            LoadingView(
+                message = "Loading...",
+            )
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/navigation/CatalogNavHost.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/navigation/CatalogNavHost.kt
new file mode 100644
index 0000000000000000000000000000000000000000..50487d8aeacc0594b135ab310da08804d03dc186
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/navigation/CatalogNavHost.kt
@@ -0,0 +1,27 @@
+package app.k9mail.ui.catalog.ui.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.navigation.NavHostController
+import androidx.navigation.compose.NavHost
+import app.k9mail.ui.catalog.ui.atom.NAVIGATION_ROUTE_CATALOG_ATOM
+import app.k9mail.ui.catalog.ui.atom.catalogAtomRoute
+import app.k9mail.ui.catalog.ui.molecule.catalogMoleculeRoute
+import app.k9mail.ui.catalog.ui.organism.catalogOrganismRoute
+
+@Composable
+fun CatalogNavHost(
+    navController: NavHostController,
+    modifier: Modifier = Modifier,
+    startDestination: String = NAVIGATION_ROUTE_CATALOG_ATOM,
+) {
+    NavHost(
+        navController = navController,
+        startDestination = startDestination,
+        modifier = modifier,
+    ) {
+        catalogAtomRoute()
+        catalogMoleculeRoute()
+        catalogOrganismRoute()
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogMoleculeContent.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogMoleculeContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9a15d23e28f172abdd001cbd79873dcd16024c6a
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogMoleculeContent.kt
@@ -0,0 +1,25 @@
+package app.k9mail.ui.catalog.ui.organism
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.ui.catalog.ui.common.PagedContent
+import app.k9mail.ui.catalog.ui.organism.CatalogOrganismPage.APP_BAR
+import app.k9mail.ui.catalog.ui.organism.items.appBarItems
+import kotlinx.collections.immutable.ImmutableList
+
+@Composable
+fun CatalogOrganismContent(
+    pages: ImmutableList<CatalogOrganismPage>,
+    initialPage: CatalogOrganismPage,
+    modifier: Modifier = Modifier,
+) {
+    PagedContent(
+        pages = pages,
+        initialPage = initialPage,
+        modifier = modifier,
+    ) {
+        when (it) {
+            APP_BAR -> appBarItems()
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogMoleculeNavigation.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogMoleculeNavigation.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9ff63c3f6df00cd790aea70e1250cc59ff468388
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogMoleculeNavigation.kt
@@ -0,0 +1,23 @@
+package app.k9mail.ui.catalog.ui.organism
+
+import androidx.navigation.NavController
+import androidx.navigation.NavGraphBuilder
+import androidx.navigation.NavOptions
+import androidx.navigation.compose.composable
+
+const val NAVIGATION_ROUTE_CATALOG_ORGANISM = "/catalog/organism"
+
+fun NavController.navigateToCatalogOrganism() {
+    navigate(
+        route = NAVIGATION_ROUTE_CATALOG_ORGANISM,
+        navOptions = NavOptions.Builder()
+            .setLaunchSingleTop(true)
+            .build(),
+    )
+}
+
+fun NavGraphBuilder.catalogOrganismRoute() {
+    composable(route = NAVIGATION_ROUTE_CATALOG_ORGANISM) {
+        CatalogOrganismScreen()
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogOrganismPage.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogOrganismPage.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1f2c4a405941df493a2da44576554ce92ef09dd0
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogOrganismPage.kt
@@ -0,0 +1,18 @@
+package app.k9mail.ui.catalog.ui.organism
+
+import kotlinx.collections.immutable.toImmutableList
+
+enum class CatalogOrganismPage(
+    private val displayName: String,
+) {
+    APP_BAR("App Bars"),
+    ;
+
+    override fun toString(): String {
+        return displayName
+    }
+
+    companion object {
+        fun all() = values().toList().toImmutableList()
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogOrganismScreen.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogOrganismScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7c6fb5e2e5df7aac7e8352b04188eeb6ed1370a5
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogOrganismScreen.kt
@@ -0,0 +1,15 @@
+package app.k9mail.ui.catalog.ui.organism
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+
+@Composable
+fun CatalogOrganismScreen(
+    modifier: Modifier = Modifier,
+) {
+    CatalogOrganismContent(
+        pages = CatalogOrganismPage.all(),
+        initialPage = CatalogOrganismPage.APP_BAR,
+        modifier = modifier,
+    )
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/items/AppBarItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/items/AppBarItems.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c87d1a326557c3436a98719d65b5fb4df1cdfb23
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/items/AppBarItems.kt
@@ -0,0 +1,94 @@
+package app.k9mail.ui.catalog.ui.organism.items
+
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.material.Icon
+import androidx.compose.material.IconButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import app.k9mail.core.ui.compose.designsystem.organism.TopAppBar
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.ui.catalog.ui.common.list.ItemOutlined
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
+import app.k9mail.ui.catalog.ui.common.list.sectionSubtitleItem
+
+fun LazyGridScope.appBarItems() {
+    sectionHeaderItem(text = "TopAppBar")
+    sectionSubtitleItem(text = "With menu icon")
+    item {
+        ItemOutlined {
+            TopAppBarItem(
+                title = "Title",
+                navIcon = Icons.Outlined.menu,
+                actionIcon = Icons.Filled.user,
+            )
+        }
+    }
+    sectionSubtitleItem(text = "With back icon")
+    item {
+        ItemOutlined {
+            TopAppBarItem(
+                title = "Title",
+                navIcon = Icons.Outlined.arrowBack,
+                actionIcon = Icons.Filled.inbox,
+            )
+        }
+    }
+    sectionSubtitleItem(text = "With subtitle")
+    item {
+        ItemOutlined {
+            TopAppBarItem(
+                title = "Title",
+                subtitle = "Subtitle",
+                navIcon = Icons.Outlined.menu,
+                actionIcon = Icons.Filled.user,
+            )
+        }
+    }
+    sectionSubtitleItem(text = "With subtitle and no nav icon")
+    item {
+        ItemOutlined {
+            TopAppBarItem(
+                title = "Title",
+                subtitle = "Subtitle",
+                navIcon = null,
+                actionIcon = Icons.Filled.user,
+            )
+        }
+    }
+}
+
+@Composable
+fun TopAppBarItem(
+    title: String,
+    actionIcon: ImageVector,
+    modifier: Modifier = Modifier,
+    subtitle: String? = null,
+    navIcon: ImageVector? = null,
+) {
+    TopAppBar(
+        title = title,
+        subtitle = subtitle,
+        navigationIcon = if (navIcon != null) {
+            {
+                IconButton(onClick = {}) {
+                    Icon(
+                        imageVector = navIcon,
+                        contentDescription = null,
+                    )
+                }
+            }
+        } else {
+            null
+        },
+        actions = {
+            IconButton(onClick = {}) {
+                Icon(
+                    imageVector = actionIcon,
+                    contentDescription = null,
+                )
+            }
+        },
+        modifier = modifier,
+    )
+}
diff --git a/app-ui-catalog/src/main/res/values/themes.xml b/app-ui-catalog/src/main/res/values/themes.xml
index 5bfdb913ac697a755a7c0ebd6608b5b006c53330..b784534a72714ddc8861f4cbd13ade270e46671d 100644
--- a/app-ui-catalog/src/main/res/values/themes.xml
+++ b/app-ui-catalog/src/main/res/values/themes.xml
@@ -1,6 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <style name="Theme.Thunderbird" parent="Theme.MaterialComponents.DayNight.NoActionBar" />
+    <style name="Theme.Thunderbird" parent="Theme.MaterialComponents.DayNight.NoActionBar">
+        <item name="android:statusBarColor">@android:color/transparent</item>
+        <item name="android:navigationBarColor">@android:color/transparent</item>
+    </style>
 
     <style name="Theme.Thunderbird.Splashscreen" parent="Theme.SplashScreen">
         <item name="windowSplashScreenAnimatedIcon">@drawable/ic_launcher_foreground</item>
diff --git a/app/core/src/main/java/com/fsck/k9/helper/ContactNameProvider.kt b/app/core/src/main/java/com/fsck/k9/helper/ContactNameProvider.kt
index 4d16061b9649f81ec408b54a21b488ffcafdfc57..1e354c987b690892b07a09db3cd26e2259a4ad93 100644
--- a/app/core/src/main/java/com/fsck/k9/helper/ContactNameProvider.kt
+++ b/app/core/src/main/java/com/fsck/k9/helper/ContactNameProvider.kt
@@ -1,7 +1,7 @@
 package com.fsck.k9.helper
 
 import app.k9mail.core.android.common.contact.ContactRepository
-import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toEmailAddressOrNull
 
 interface ContactNameProvider {
     fun getNameForAddress(address: String): String?
@@ -11,6 +11,8 @@ class RealContactNameProvider(
     private val contactRepository: ContactRepository,
 ) : ContactNameProvider {
     override fun getNameForAddress(address: String): String? {
-        return contactRepository.getContactFor(EmailAddress(address))?.name
+        return address.toEmailAddressOrNull()?.let { emailAddress ->
+            contactRepository.getContactFor(emailAddress)?.name
+        }
     }
 }
diff --git a/app/core/src/main/java/com/fsck/k9/helper/MessageHelper.kt b/app/core/src/main/java/com/fsck/k9/helper/MessageHelper.kt
index f5a7a160d96340fcd8a9c6c66ce23a6836ab68c5..a36dc77909d5602561aa59fdd199a68ed6e53d52 100644
--- a/app/core/src/main/java/com/fsck/k9/helper/MessageHelper.kt
+++ b/app/core/src/main/java/com/fsck/k9/helper/MessageHelper.kt
@@ -6,7 +6,7 @@ import android.text.SpannableStringBuilder
 import android.text.TextUtils
 import android.text.style.ForegroundColorSpan
 import app.k9mail.core.android.common.contact.ContactRepository
-import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toEmailAddressOrNull
 import com.fsck.k9.CoreResourceProvider
 import com.fsck.k9.K9.contactNameColor
 import com.fsck.k9.K9.isChangeContactNameColor
@@ -101,7 +101,7 @@ class MessageHelper(
             if (!showCorrespondentNames) {
                 return address.address
             } else if (contactRepository != null) {
-                val name = contactRepository.getContactFor(EmailAddress(address.address))?.name
+                val name = contactRepository.getContactName(address)
                 if (name != null) {
                     return if (changeContactNameColor) {
                         val coloredName = SpannableString(name)
@@ -124,6 +124,12 @@ class MessageHelper(
             }
         }
 
+        private fun ContactRepository.getContactName(address: Address): String? {
+            return address.address.toEmailAddressOrNull()?.let { emailAddress ->
+                getContactFor(emailAddress)?.name
+            }
+        }
+
         private fun isSpoofAddress(displayName: String): Boolean {
             return displayName.contains("@") && SPOOF_ADDRESS_PATTERN.matcher(displayName).find()
         }
diff --git a/app/core/src/main/java/com/fsck/k9/message/ReplyActionStrategy.kt b/app/core/src/main/java/com/fsck/k9/message/ReplyActionStrategy.kt
index 462d354deef27dbe90aa68123b27e7df3e905fab..403a8209e861fa2cf74e5db3bcc978e1c0952463 100644
--- a/app/core/src/main/java/com/fsck/k9/message/ReplyActionStrategy.kt
+++ b/app/core/src/main/java/com/fsck/k9/message/ReplyActionStrategy.kt
@@ -20,7 +20,7 @@ class ReplyActionStrategy(private val replyRoParser: ReplyToParser) {
                 ReplyActions(defaultAction = ReplyAction.REPLY)
             }
         } else {
-            ReplyActions(defaultAction = ReplyAction.REPLY_ALL, additionalActions = listOf(ReplyAction.REPLY))
+            ReplyActions(defaultAction = ReplyAction.REPLY, additionalActions = listOf(ReplyAction.REPLY_ALL))
         }
     }
 }
diff --git a/app/core/src/main/java/com/fsck/k9/preferences/SettingsExporter.kt b/app/core/src/main/java/com/fsck/k9/preferences/SettingsExporter.kt
index 2f32b1885455f86cbdaa4619ba4debccc964695a..3ac742a8d29a7bac627ee5dee1bb9507444d5b70 100644
--- a/app/core/src/main/java/com/fsck/k9/preferences/SettingsExporter.kt
+++ b/app/core/src/main/java/com/fsck/k9/preferences/SettingsExporter.kt
@@ -206,7 +206,7 @@ class SettingsExporter(
             if (hasThirdPart) {
                 val secondPart = keyPart.substring(0, indexOfLastDot)
                 val thirdPart = keyPart.substring(indexOfLastDot + 1)
-                if (secondPart == IDENTITY_DESCRIPTION_KEY) {
+                if (secondPart == IDENTITY_EMAIL_KEY) {
                     // This is an identity key. Save identity index for later...
                     thirdPart.toIntOrNull()?.let {
                         identities.add(it)
diff --git a/app/core/src/main/java/com/fsck/k9/preferences/SettingsImporter.java b/app/core/src/main/java/com/fsck/k9/preferences/SettingsImporter.java
index 88e4a5a298dca3037ca25889dcb6dfd370495ed4..3d9b26170445dccade571c7ace6325fc2bb93480 100644
--- a/app/core/src/main/java/com/fsck/k9/preferences/SettingsImporter.java
+++ b/app/core/src/main/java/com/fsck/k9/preferences/SettingsImporter.java
@@ -533,19 +533,6 @@ public class SettingsImporter {
                 nextIdentityIndex++;
             }
 
-            String identityDescription = (identity.description == null) ? "Imported" : identity.description;
-            if (isIdentityDescriptionUsed(identityDescription, existingIdentities)) {
-                // Identity description is already in use. So generate a new one by appending
-                // " (x)", where x is the first number >= 1 that results in an unused identity
-                // description.
-                for (int i = 1; i <= existingIdentities.size(); i++) {
-                    identityDescription = identity.description + " (" + i + ")";
-                    if (!isIdentityDescriptionUsed(identityDescription, existingIdentities)) {
-                        break;
-                    }
-                }
-            }
-
             String identitySuffix = "." + writeIdentityIndex;
 
             // Write name used in identity
@@ -561,8 +548,10 @@ public class SettingsImporter {
             putString(editor, accountKeyPrefix + AccountPreferenceSerializer.IDENTITY_EMAIL_KEY + identitySuffix, identity.email);
 
             // Write identity description
-            putString(editor, accountKeyPrefix + AccountPreferenceSerializer.IDENTITY_DESCRIPTION_KEY + identitySuffix,
-                    identityDescription);
+            if (identity.description != null) {
+                putString(editor, accountKeyPrefix + AccountPreferenceSerializer.IDENTITY_DESCRIPTION_KEY + identitySuffix,
+                        identity.description);
+            }
 
             if (identity.settings != null) {
                 // Validate identity settings
@@ -610,15 +599,6 @@ public class SettingsImporter {
         return false;
     }
 
-    private static boolean isIdentityDescriptionUsed(String description, List<Identity> identities) {
-        for (Identity identity : identities) {
-            if (identity.getDescription().equals(description)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
     private static int findIdentity(ImportedIdentity identity, List<Identity> identities) {
         for (int i = 0; i < identities.size(); i++) {
             Identity existingIdentity = identities.get(i);
diff --git a/app/core/src/test/java/com/fsck/k9/EmailAddressValidatorTest.kt b/app/core/src/test/java/com/fsck/k9/EmailAddressValidatorTest.kt
index f839dec1de318805f7dc8a6af605a8a03060ff27..1e03aaeed62d11663914ed801bb43be55551b0b5 100644
--- a/app/core/src/test/java/com/fsck/k9/EmailAddressValidatorTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/EmailAddressValidatorTest.kt
@@ -1,36 +1,46 @@
 package com.fsck.k9
 
-import org.junit.Assert
+import assertk.assertThat
+import assertk.assertions.isFalse
+import assertk.assertions.isTrue
 import org.junit.Test
 
 class EmailAddressValidatorTest {
+    private val validator = EmailAddressValidator()
 
     @Test
     fun testEmailValidation() {
         // Most of the tests based on https://en.wikipedia.org/wiki/Email_address#Examples
-        val validator = EmailAddressValidator()
-        Assert.assertTrue(validator.isValidAddressOnly("simple@example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("very.common@example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("disposable.style.email.with+symbol@example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("other.email-with-hyphen@example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("fully-qualified-domain@example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("user.name+tag+sorting@example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("example-indeed@strange-example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("example-indeed@strange_example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("example@1.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("admin@mailserver1"))
-        Assert.assertTrue(validator.isValidAddressOnly("user@localserver"))
-        Assert.assertTrue(validator.isValidAddressOnly("\"very.(),:;<>[]\\\".VERY.\\\"very@\\\\ \\\"very\\\".unusual\"@strange.example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("\"()<>[]:,;@\\\\\\\"!#$%&'-/=?^_`{}| ~.a\"@example.org"))
-        Assert.assertTrue(validator.isValidAddressOnly("\" \"@example.org"))
-        Assert.assertTrue(validator.isValidAddressOnly("x@example.com"))
+        assertValidAddress("simple@example.com")
+        assertValidAddress("very.common@example.com")
+        assertValidAddress("disposable.style.email.with+symbol@example.com")
+        assertValidAddress("other.email-with-hyphen@example.com")
+        assertValidAddress("fully-qualified-domain@example.com")
+        assertValidAddress("user.name+tag+sorting@example.com")
+        assertValidAddress("example-indeed@strange-example.com")
+        assertValidAddress("example-indeed@strange_example.com")
+        assertValidAddress("example@1.com")
+        assertValidAddress("admin@mailserver1")
+        assertValidAddress("user@localserver")
+        assertValidAddress("\"very.(),:;<>[]\\\".VERY.\\\"very@\\\\ \\\"very\\\".unusual\"@strange.example.com")
+        assertValidAddress("\"()<>[]:,;@\\\\\\\"!#$%&'-/=?^_`{}| ~.a\"@example.org")
+        assertValidAddress("\" \"@example.org")
+        assertValidAddress("x@example.com")
 
-        Assert.assertFalse(validator.isValidAddressOnly("Abc.example.com"))
-        Assert.assertFalse(validator.isValidAddressOnly("\"not\"right@example.com"))
-        Assert.assertFalse(validator.isValidAddressOnly("john.doe@example..com"))
-        Assert.assertFalse(validator.isValidAddressOnly("example@c.2"))
-        Assert.assertFalse(validator.isValidAddressOnly("this\\ still\\\"not\\\\allowed@example.com"))
-        Assert.assertFalse(validator.isValidAddressOnly("john..doe@example.com"))
-        Assert.assertFalse(validator.isValidAddressOnly("invalidperiod.@example.com"))
+        assertInvalidAddress("Abc.example.com")
+        assertInvalidAddress("\"not\"right@example.com")
+        assertInvalidAddress("john.doe@example..com")
+        assertInvalidAddress("example@c.2")
+        assertInvalidAddress("this\\ still\\\"not\\\\allowed@example.com")
+        assertInvalidAddress("john..doe@example.com")
+        assertInvalidAddress("invalidperiod.@example.com")
+    }
+
+    private fun assertValidAddress(input: String) {
+        assertThat(input).transform { validator.isValidAddressOnly(it) }.isTrue()
+    }
+
+    private fun assertInvalidAddress(input: String) {
+        assertThat(input).transform { validator.isValidAddressOnly(it) }.isFalse()
     }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/QuietTimeCheckerTest.kt b/app/core/src/test/java/com/fsck/k9/QuietTimeCheckerTest.kt
index 854f3dc2f8a5019a8e994b5f4f0b1ae8093987b0..d664e60ff1989f686ee709805b35b8a7200d74aa 100644
--- a/app/core/src/test/java/com/fsck/k9/QuietTimeCheckerTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/QuietTimeCheckerTest.kt
@@ -1,10 +1,11 @@
 package com.fsck.k9
 
 import app.k9mail.core.testing.TestClock
+import assertk.assertThat
+import assertk.assertions.isFalse
+import assertk.assertions.isTrue
 import java.util.Calendar
 import kotlinx.datetime.Instant
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class QuietTimeCheckerTest {
@@ -15,7 +16,7 @@ class QuietTimeCheckerTest {
         setClockTo("02:00")
         val quietTimeChecker = QuietTimeChecker(clock, "22:30", "06:45")
 
-        assertTrue(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isTrue()
     }
 
     @Test
@@ -23,7 +24,7 @@ class QuietTimeCheckerTest {
         setClockTo("10:00")
         val quietTimeChecker = QuietTimeChecker(clock, "22:30", "06:45")
 
-        assertFalse(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isFalse()
     }
 
     @Test
@@ -31,7 +32,7 @@ class QuietTimeCheckerTest {
         setClockTo("23:00")
         val quietTimeChecker = QuietTimeChecker(clock, "22:30", "06:45")
 
-        assertTrue(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isTrue()
     }
 
     @Test
@@ -39,7 +40,7 @@ class QuietTimeCheckerTest {
         setClockTo("22:30")
         val quietTimeChecker = QuietTimeChecker(clock, "22:30", "06:45")
 
-        assertTrue(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isTrue()
     }
 
     @Test
@@ -47,7 +48,7 @@ class QuietTimeCheckerTest {
         setClockTo("06:45")
         val quietTimeChecker = QuietTimeChecker(clock, "22:30", "06:45")
 
-        assertTrue(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isTrue()
     }
 
     @Test
@@ -55,7 +56,7 @@ class QuietTimeCheckerTest {
         setClockTo("02:00")
         val quietTimeChecker = QuietTimeChecker(clock, "09:00", "17:00")
 
-        assertFalse(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isFalse()
     }
 
     @Test
@@ -63,7 +64,7 @@ class QuietTimeCheckerTest {
         setClockTo("10:00")
         val quietTimeChecker = QuietTimeChecker(clock, "09:00", "17:00")
 
-        assertTrue(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isTrue()
     }
 
     @Test
@@ -71,7 +72,7 @@ class QuietTimeCheckerTest {
         setClockTo("20:00")
         val quietTimeChecker = QuietTimeChecker(clock, "09:00", "17:00")
 
-        assertFalse(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isFalse()
     }
 
     @Test
@@ -79,7 +80,7 @@ class QuietTimeCheckerTest {
         setClockTo("09:00")
         val quietTimeChecker = QuietTimeChecker(clock, "09:00", "17:00")
 
-        assertTrue(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isTrue()
     }
 
     @Test
@@ -87,7 +88,7 @@ class QuietTimeCheckerTest {
         setClockTo("17:00")
         val quietTimeChecker = QuietTimeChecker(clock, "09:00", "17:00")
 
-        assertTrue(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isTrue()
     }
 
     @Test
@@ -95,7 +96,7 @@ class QuietTimeCheckerTest {
         setClockTo("10:00")
         val quietTimeChecker = QuietTimeChecker(clock, "06:00", "06:00")
 
-        assertFalse(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isFalse()
     }
 
     @Test
@@ -103,7 +104,7 @@ class QuietTimeCheckerTest {
         setClockTo("06:00")
         val quietTimeChecker = QuietTimeChecker(clock, "06:00", "06:00")
 
-        assertFalse(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isFalse()
     }
 
     private fun setClockTo(time: String) {
diff --git a/app/core/src/test/java/com/fsck/k9/ServerSettingsSerializerTest.kt b/app/core/src/test/java/com/fsck/k9/ServerSettingsSerializerTest.kt
index 21666945b40567bfde24ab7270a0c41f2f2df772..d2e97ea3c7249ac66b85a9329ae06f08d32e9a27 100644
--- a/app/core/src/test/java/com/fsck/k9/ServerSettingsSerializerTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/ServerSettingsSerializerTest.kt
@@ -1,9 +1,9 @@
 package com.fsck.k9
 
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
 import com.fsck.k9.mail.AuthType
 import com.fsck.k9.mail.ConnectionSecurity
@@ -67,10 +67,9 @@ class ServerSettingsSerializerTest {
             }
         """.trimIndent()
 
-        assertThat {
+        assertFailure {
             serverSettingsSerializer.deserialize(json)
-        }.isFailure()
-            .isInstanceOf(IllegalArgumentException::class)
+        }.isInstanceOf<IllegalArgumentException>()
             .hasMessage("'type' must not be missing")
     }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/autocrypt/AutocryptGossipHeaderParserTest.kt b/app/core/src/test/java/com/fsck/k9/autocrypt/AutocryptGossipHeaderParserTest.kt
index 40ccbf523bff4ca36332d2a83946912202196488..59f3fb3461e704decf94694fbec275ff798fbbdb 100644
--- a/app/core/src/test/java/com/fsck/k9/autocrypt/AutocryptGossipHeaderParserTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/autocrypt/AutocryptGossipHeaderParserTest.kt
@@ -1,12 +1,16 @@
 package com.fsck.k9.autocrypt
 
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.extracting
+import assertk.assertions.index
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
 import com.fsck.k9.mail.crlf
 import com.fsck.k9.mail.filter.Base64
 import com.fsck.k9.mailstore.MimePartStreamParser
-import org.junit.Assert.assertArrayEquals
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertNull
 import org.junit.Test
 
 class AutocryptGossipHeaderParserTest {
@@ -56,20 +60,24 @@ class AutocryptGossipHeaderParserTest {
         val gossipPart = MimePartStreamParser.parse(null, GOSSIP_PART.byteInputStream())
         val allAutocryptGossipHeaders = autocryptGossipHeaderParser.getAllAutocryptGossipHeaders(gossipPart)
 
-        assertEquals("text/plain", gossipPart.mimeType)
-        assertEquals(2, allAutocryptGossipHeaders.size)
-        assertEquals("bob@autocrypt.example", allAutocryptGossipHeaders[0].addr)
-        assertEquals("carol@autocrypt.example", allAutocryptGossipHeaders[1].addr)
-        assertArrayEquals(GOSSIP_DATA_BOB, allAutocryptGossipHeaders[0].keyData)
+        assertThat(gossipPart.mimeType).isEqualTo("text/plain")
+        assertThat(allAutocryptGossipHeaders).all {
+            extracting { it.addr }.containsExactly(
+                "bob@autocrypt.example",
+                "carol@autocrypt.example",
+            )
+            index(0).transform { it.keyData }.isEqualTo(GOSSIP_DATA_BOB)
+        }
     }
 
     @Test
     fun parseString() {
         val gossipHeader = autocryptGossipHeaderParser.parseAutocryptGossipHeader(GOSSIP_HEADER_BOB)
 
-        gossipHeader!!
-        assertArrayEquals(GOSSIP_DATA_BOB, gossipHeader.keyData)
-        assertEquals(GOSSIP_RAW_HEADER_BOB, gossipHeader.toRawHeaderString())
+        assertThat(gossipHeader).isNotNull().all {
+            transform { it.keyData }.isEqualTo(GOSSIP_DATA_BOB)
+            transform { it.toRawHeaderString() }.isEqualTo(GOSSIP_RAW_HEADER_BOB)
+        }
     }
 
     @Test
@@ -78,7 +86,7 @@ class AutocryptGossipHeaderParserTest {
             "addr=CDEF",
         )
 
-        assertNull(gossipHeader)
+        assertThat(gossipHeader).isNull()
     }
 
     @Test
@@ -87,7 +95,7 @@ class AutocryptGossipHeaderParserTest {
             "addr=bawb; somecritical=value; keydata=aGk",
         )
 
-        assertNull(gossipHeader)
+        assertThat(gossipHeader).isNull()
     }
 
     @Test
@@ -96,7 +104,7 @@ class AutocryptGossipHeaderParserTest {
             "addr=bawb; _somenoncritical=value; keydata=aGk",
         )
 
-        assertNotNull(gossipHeader)
+        assertThat(gossipHeader).isNotNull()
     }
 
     @Test
@@ -105,6 +113,6 @@ class AutocryptGossipHeaderParserTest {
             "addr=bawb; _somenoncritical=value; keydata=X",
         )
 
-        assertNull(gossipHeader)
+        assertThat(gossipHeader).isNull()
     }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/crypto/OpenPgpApiHelperTest.kt b/app/core/src/test/java/com/fsck/k9/crypto/OpenPgpApiHelperTest.kt
index b55959e849c6768c56d2beeae7fa0d4412da3a1f..0d54de0edf7c914822455afb824644c41ce129e9 100644
--- a/app/core/src/test/java/com/fsck/k9/crypto/OpenPgpApiHelperTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/crypto/OpenPgpApiHelperTest.kt
@@ -1,7 +1,8 @@
 package com.fsck.k9.crypto
 
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import com.fsck.k9.Identity
-import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class OpenPgpApiHelperTest {
@@ -15,7 +16,7 @@ class OpenPgpApiHelperTest {
 
         val result = OpenPgpApiHelper.buildUserId(identity)
 
-        assertEquals("Name <user@domain.com>", result)
+        assertThat(result).isEqualTo("Name <user@domain.com>")
     }
 
     @Test
@@ -26,6 +27,6 @@ class OpenPgpApiHelperTest {
 
         val result = OpenPgpApiHelper.buildUserId(identity)
 
-        assertEquals("<user@domain.com>", result)
+        assertThat(result).isEqualTo("<user@domain.com>")
     }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/helper/ListUnsubscribeHelperTest.kt b/app/core/src/test/java/com/fsck/k9/helper/ListUnsubscribeHelperTest.kt
index 6b8419d2511d54e5b8759b267719bd9d50c61d1f..3af5acc4408b384db88f5bf648a817b0ced1bf96 100644
--- a/app/core/src/test/java/com/fsck/k9/helper/ListUnsubscribeHelperTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/helper/ListUnsubscribeHelperTest.kt
@@ -3,9 +3,9 @@ package com.fsck.k9.helper
 import androidx.core.net.toUri
 import assertk.assertThat
 import assertk.assertions.isEqualTo
+import assertk.assertions.isNull
 import com.fsck.k9.RobolectricTest
 import com.fsck.k9.mail.internet.MimeMessage
-import kotlin.test.assertNull
 import org.junit.Test
 
 class ListUnsubscribeHelperTest : RobolectricTest() {
@@ -60,7 +60,7 @@ class ListUnsubscribeHelperTest : RobolectricTest() {
             "<http://example.com/unsubscribe>",
         )
         val result = ListUnsubscribeHelper.getPreferredListUnsubscribeUri(message)
-        assertNull(result)
+        assertThat(result).isNull()
     }
 
     @Test
@@ -78,14 +78,14 @@ class ListUnsubscribeHelperTest : RobolectricTest() {
             "",
         )
         val result = ListUnsubscribeHelper.getPreferredListUnsubscribeUri(message)
-        assertNull(result)
+        assertThat(result).isNull()
     }
 
     @Test
     fun `get list unsubscribe url - should ignore missing header`() {
         val message = MimeMessage()
         val result = ListUnsubscribeHelper.getPreferredListUnsubscribeUri(message)
-        assertNull(result)
+        assertThat(result).isNull()
     }
 
     private fun buildMimeMessageWithListUnsubscribeValue(value: String): MimeMessage {
diff --git a/app/core/src/test/java/com/fsck/k9/helper/MessageHelperTest.kt b/app/core/src/test/java/com/fsck/k9/helper/MessageHelperTest.kt
index 2f31e774fbde4f61b8fb3ac4fe7fb414ad36d29c..b34ab5d7187a14115254ee9bc4f0e2436f48e88e 100644
--- a/app/core/src/test/java/com/fsck/k9/helper/MessageHelperTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/helper/MessageHelperTest.kt
@@ -5,6 +5,7 @@ import android.text.SpannableString
 import app.k9mail.core.android.common.contact.Contact
 import app.k9mail.core.android.common.contact.ContactRepository
 import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toEmailAddressOrThrow
 import assertk.assertThat
 import assertk.assertions.isEqualTo
 import assertk.assertions.isInstanceOf
@@ -60,7 +61,7 @@ class MessageHelperTest : RobolectricTest() {
             changeContactNameColor = true,
             contactNameColor = Color.RED,
         )
-        assertThat(friendly).isInstanceOf(SpannableString::class.java)
+        assertThat(friendly).isInstanceOf<SpannableString>()
         assertThat(friendly.toString()).isEqualTo("Tim Testor")
     }
 
@@ -142,6 +143,6 @@ class MessageHelperTest : RobolectricTest() {
     }
 
     private companion object {
-        val EMAIL_ADDRESS = EmailAddress("test@testor.com")
+        val EMAIL_ADDRESS = "test@testor.com".toEmailAddressOrThrow()
     }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendFolderTest.kt b/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendFolderTest.kt
index 081a53ac300ab0206ea00447d85850873cc6daa5..b4d03d9529ab3eea24732cbb9c19fd68af93a45f 100644
--- a/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendFolderTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendFolderTest.kt
@@ -2,6 +2,13 @@ package com.fsck.k9.mailstore
 
 import android.database.sqlite.SQLiteDatabase
 import androidx.core.content.contentValuesOf
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.contains
+import assertk.assertions.hasMessage
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.isTrue
 import com.fsck.k9.Account
 import com.fsck.k9.K9RobolectricTest
 import com.fsck.k9.Preferences
@@ -17,9 +24,6 @@ import com.fsck.k9.mail.internet.MimeMessage
 import com.fsck.k9.mail.internet.MimeMessageHelper
 import com.fsck.k9.mail.internet.TextBody
 import org.junit.After
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Assert.fail
 import org.junit.Test
 import org.koin.core.component.inject
 
@@ -45,7 +49,7 @@ class K9BackendFolderTest : K9RobolectricTest() {
 
         val messageFlags = backendFolder.getMessageFlags(MESSAGE_SERVER_ID)
 
-        assertEquals(flags, messageFlags)
+        assertThat(messageFlags).isEqualTo(flags)
     }
 
     @Test
@@ -55,7 +59,7 @@ class K9BackendFolderTest : K9RobolectricTest() {
 
         val messageFlags = backendFolder.getMessageFlags(MESSAGE_SERVER_ID)
 
-        assertTrue(messageFlags.isEmpty())
+        assertThat(messageFlags.isEmpty()).isTrue()
     }
 
     @Test
@@ -66,29 +70,27 @@ class K9BackendFolderTest : K9RobolectricTest() {
 
         val messageFlags = backendFolder.getMessageFlags(MESSAGE_SERVER_ID)
 
-        assertEquals(flags, messageFlags)
+        assertThat(messageFlags).isEqualTo(flags)
     }
 
     @Test
     fun saveCompleteMessage_withoutServerId_shouldThrow() {
         val message = createMessage(messageServerId = null)
 
-        try {
+        assertFailure {
             backendFolder.saveMessage(message, MessageDownloadState.FULL)
-            fail("Expected exception")
-        } catch (e: IllegalStateException) {
-        }
+        }.isInstanceOf<IllegalStateException>()
+            .hasMessage("Message requires a server ID to be set")
     }
 
     @Test
     fun savePartialMessage_withoutServerId_shouldThrow() {
         val message = createMessage(messageServerId = null)
 
-        try {
+        assertFailure {
             backendFolder.saveMessage(message, MessageDownloadState.PARTIAL)
-            fail("Expected exception")
-        } catch (e: IllegalStateException) {
-        }
+        }.isInstanceOf<IllegalStateException>()
+            .hasMessage("Message requires a server ID to be set")
     }
 
     fun createAccount(): Account {
@@ -111,7 +113,7 @@ class K9BackendFolderTest : K9RobolectricTest() {
         }
 
         val folderServerIds = backendStorage.getFolderServerIds()
-        assertTrue(FOLDER_SERVER_ID in folderServerIds)
+        assertThat(folderServerIds).contains(FOLDER_SERVER_ID)
 
         return K9BackendFolder(messageStore, saveMessageDataCreator, FOLDER_SERVER_ID)
     }
@@ -121,7 +123,7 @@ class K9BackendFolderTest : K9RobolectricTest() {
         backendFolder.saveMessage(message, MessageDownloadState.FULL)
 
         val messageServerIds = backendFolder.getMessageServerIds()
-        assertTrue(messageServerId in messageServerIds)
+        assertThat(messageServerIds).contains(messageServerId)
     }
 
     private fun createMessage(messageServerId: String?, flags: Set<Flag> = emptySet()): Message {
@@ -144,7 +146,7 @@ class K9BackendFolderTest : K9RobolectricTest() {
                 "uid = ?",
                 arrayOf(MESSAGE_SERVER_ID),
             )
-            assertEquals(1, numberOfUpdatedRows)
+            assertThat(numberOfUpdatedRows).isEqualTo(1)
         }
     }
 
diff --git a/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendStorageTest.kt b/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendStorageTest.kt
index ed0009a78eb3494b29e3ad520a9a326c8cf6ca1c..f2f0202f481c420093b99c52fbf7cd7d1852bdee 100644
--- a/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendStorageTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendStorageTest.kt
@@ -1,12 +1,13 @@
 package com.fsck.k9.mailstore
 
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import com.fsck.k9.Account
 import com.fsck.k9.K9RobolectricTest
 import com.fsck.k9.Preferences
 import com.fsck.k9.backend.api.BackendStorage
 import com.fsck.k9.mail.FolderClass
 import org.junit.After
-import org.junit.Assert.assertEquals
 import org.junit.Test
 import org.koin.core.component.inject
 import org.mockito.kotlin.any
@@ -15,12 +16,10 @@ import org.mockito.kotlin.mock
 
 class K9BackendStorageTest : K9RobolectricTest() {
     val preferences: Preferences by inject()
-    val localStoreProvider: LocalStoreProvider by inject()
     val messageStoreManager: MessageStoreManager by inject()
     val saveMessageDataCreator: SaveMessageDataCreator by inject()
 
     val account: Account = createAccount()
-    val database: LockableDatabase = localStoreProvider.getInstance(account).database
     val backendStorage = createBackendStorage()
 
     @After
@@ -33,7 +32,7 @@ class K9BackendStorageTest : K9RobolectricTest() {
         backendStorage.setExtraString("testString", "someValue")
         val value = backendStorage.getExtraString("testString")
 
-        assertEquals("someValue", value)
+        assertThat(value).isEqualTo("someValue")
     }
 
     @Test
@@ -42,7 +41,7 @@ class K9BackendStorageTest : K9RobolectricTest() {
         backendStorage.setExtraString("testString", "newValue")
 
         val value = backendStorage.getExtraString("testString")
-        assertEquals("newValue", value)
+        assertThat(value).isEqualTo("newValue")
     }
 
     @Test
@@ -50,7 +49,7 @@ class K9BackendStorageTest : K9RobolectricTest() {
         backendStorage.setExtraNumber("testNumber", 42)
         val value = backendStorage.getExtraNumber("testNumber")
 
-        assertEquals(42L, value)
+        assertThat(value).isEqualTo(42L)
     }
 
     @Test
@@ -59,7 +58,7 @@ class K9BackendStorageTest : K9RobolectricTest() {
         backendStorage.setExtraNumber("testNumber", 23)
 
         val value = backendStorage.getExtraNumber("testNumber")
-        assertEquals(23L, value)
+        assertThat(value).isEqualTo(23L)
     }
 
     fun createAccount(): Account {
diff --git a/app/core/src/test/java/com/fsck/k9/mailstore/MimePartStreamParserTest.kt b/app/core/src/test/java/com/fsck/k9/mailstore/MimePartStreamParserTest.kt
index 2371b5a1aeae7ad7e5ba5a183dec563b8f19b82e..bfaae6b7e1ff7165c5ce09ce0d2c08e36668842b 100644
--- a/app/core/src/test/java/com/fsck/k9/mailstore/MimePartStreamParserTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/mailstore/MimePartStreamParserTest.kt
@@ -1,12 +1,18 @@
 package com.fsck.k9.mailstore
 
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import com.fsck.k9.mail.assertk.body
+import com.fsck.k9.mail.assertk.bodyPart
+import com.fsck.k9.mail.assertk.bodyParts
+import com.fsck.k9.mail.assertk.mimeType
 import com.fsck.k9.mail.crlf
-import com.fsck.k9.mail.internet.MimeBodyPart
 import com.fsck.k9.mail.internet.MimeMessage
 import com.fsck.k9.mail.internet.MimeMultipart
 import java.io.ByteArrayInputStream
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class MimePartStreamParserTest {
@@ -35,14 +41,15 @@ class MimePartStreamParserTest {
             --1--
             """.trimIndent().crlf()
 
-        val msg = MimePartStreamParser.parse(null, ByteArrayInputStream(messageContent.toByteArray()))
+        val bodyPart = MimePartStreamParser.parse(null, ByteArrayInputStream(messageContent.toByteArray()))
 
-        val body = msg.body as MimeMultipart
-        assertEquals(2, body.count.toLong())
-
-        val messagePart = body.getBodyPart(1) as MimeBodyPart
-        assertEquals("message/rfc822", messagePart.mimeType)
-        assertTrue(messagePart.body is MimeMessage)
+        assertThat(bodyPart.body).isInstanceOf<MimeMultipart>().all {
+            bodyParts().hasSize(2)
+            bodyPart(1).all {
+                mimeType().isEqualTo("message/rfc822")
+                body().isInstanceOf<MimeMessage>()
+            }
+        }
     }
 
     @Test
@@ -71,13 +78,14 @@ class MimePartStreamParserTest {
             --1--
             """.trimIndent().crlf()
 
-        val msg = MimePartStreamParser.parse(null, ByteArrayInputStream(messageContent.toByteArray()))
-
-        val body = msg.body as MimeMultipart
-        assertEquals(2, body.count)
+        val bodyPart = MimePartStreamParser.parse(null, ByteArrayInputStream(messageContent.toByteArray()))
 
-        val messagePart = body.getBodyPart(1) as MimeBodyPart
-        assertEquals("message/rfc822", messagePart.mimeType)
-        assertTrue(messagePart.body is DeferredFileBody)
+        assertThat(bodyPart.body).isInstanceOf<MimeMultipart>().all {
+            bodyParts().hasSize(2)
+            bodyPart(1).all {
+                mimeType().isEqualTo("message/rfc822")
+                body().isInstanceOf<DeferredFileBody>()
+            }
+        }
     }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/message/ReplyActionStrategyTest.kt b/app/core/src/test/java/com/fsck/k9/message/ReplyActionStrategyTest.kt
index 868ab0718c4990e0e69a193c1e879077d1abe151..44aeea32c25221be1334a4281c587964936254e3 100644
--- a/app/core/src/test/java/com/fsck/k9/message/ReplyActionStrategyTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/message/ReplyActionStrategyTest.kt
@@ -39,8 +39,8 @@ class ReplyActionStrategyTest {
 
         val replyActions = replyActionStrategy.getReplyActions(account, message)
 
-        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY_ALL)
-        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY)
+        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY)
+        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY_ALL)
     }
 
     @Test
@@ -52,8 +52,8 @@ class ReplyActionStrategyTest {
 
         val replyActions = replyActionStrategy.getReplyActions(account, message)
 
-        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY_ALL)
-        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY)
+        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY)
+        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY_ALL)
     }
 
     @Test
@@ -66,8 +66,8 @@ class ReplyActionStrategyTest {
 
         val replyActions = replyActionStrategy.getReplyActions(account, message)
 
-        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY_ALL)
-        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY)
+        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY)
+        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY_ALL)
     }
 
     @Test
@@ -80,8 +80,8 @@ class ReplyActionStrategyTest {
 
         val replyActions = replyActionStrategy.getReplyActions(account, message)
 
-        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY_ALL)
-        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY)
+        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY)
+        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY_ALL)
     }
 
     @Test
@@ -93,8 +93,8 @@ class ReplyActionStrategyTest {
 
         val replyActions = replyActionStrategy.getReplyActions(account, message)
 
-        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY_ALL)
-        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY)
+        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY)
+        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY_ALL)
     }
 
     @Test
diff --git a/app/core/src/test/java/com/fsck/k9/message/html/DisplayHtmlTest.kt b/app/core/src/test/java/com/fsck/k9/message/html/DisplayHtmlTest.kt
index 6dcb06aa35b946c376a7bc129b55fe691e0ac2f5..41132e96c85a1787f405dcbe96e9de9079cc265b 100644
--- a/app/core/src/test/java/com/fsck/k9/message/html/DisplayHtmlTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/message/html/DisplayHtmlTest.kt
@@ -1,7 +1,10 @@
 package com.fsck.k9.message.html
 
+import assertk.Assert
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
 import org.jsoup.Jsoup
-import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class DisplayHtmlTest {
@@ -11,21 +14,21 @@ class DisplayHtmlTest {
     fun wrapMessageContent_addsViewportMetaElement() {
         val html = displayHtml.wrapMessageContent("Some text")
 
-        assertHtmlContainsElement(html, "head > meta[name=viewport]")
+        assertThat(html).containsHtmlElement("head > meta[name=viewport]")
     }
 
     @Test
     fun wrapMessageContent_setsDirToAuto() {
         val html = displayHtml.wrapMessageContent("Some text")
 
-        assertHtmlContainsElement(html, "html[dir=auto]")
+        assertThat(html).containsHtmlElement("html[dir=auto]")
     }
 
     @Test
     fun wrapMessageContent_addsPreCSS() {
         val html = displayHtml.wrapMessageContent("Some text")
 
-        assertHtmlContainsElement(html, "head > style")
+        assertThat(html).containsHtmlElement("head > style")
     }
 
     @Test
@@ -34,7 +37,7 @@ class DisplayHtmlTest {
 
         val html = darkModeDisplayHtml.wrapMessageContent("Some text")
 
-        assertHtmlContainsElement(html, "head > style", 2)
+        assertThat(html).htmlElements("head > style").hasSize(2)
     }
 
     @Test
@@ -43,16 +46,18 @@ class DisplayHtmlTest {
 
         val html = displayHtml.wrapMessageContent(content)
 
-        assertEquals(content, Jsoup.parse(html).body().text())
+        assertThat(html).bodyText().isEqualTo(content)
     }
 
-    private fun assertHtmlContainsElement(html: String, cssQuery: String, numberOfExpectedOccurrences: Int = 1) {
-        val document = Jsoup.parse(html)
-        val numberOfFoundElements = document.select(cssQuery).size
-        assertEquals(
-            "Expected to find '$cssQuery' $numberOfExpectedOccurrences time(s) in:\n$html",
-            numberOfExpectedOccurrences,
-            numberOfFoundElements,
-        )
+    private fun Assert<String>.containsHtmlElement(cssQuery: String) = given { actual ->
+        assertThat(actual).htmlElements(cssQuery).hasSize(1)
+    }
+
+    private fun Assert<String>.htmlElements(cssQuery: String) = transform { html ->
+        Jsoup.parse(html).select(cssQuery)
+    }
+
+    private fun Assert<String>.bodyText() = transform { html ->
+        Jsoup.parse(html).body().text()
     }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/message/html/GenericUriParserTest.kt b/app/core/src/test/java/com/fsck/k9/message/html/GenericUriParserTest.kt
index 7ec7312d90b1236b7a7e4968d97c1afc2603b241..9787809c5fe0f1be5a7ddc8d5adabc88999da902 100644
--- a/app/core/src/test/java/com/fsck/k9/message/html/GenericUriParserTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/message/html/GenericUriParserTest.kt
@@ -1,11 +1,12 @@
 package com.fsck.k9.message.html
 
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
-import kotlin.test.assertNotNull
+import assertk.assertions.isNotNull
+import assertk.assertions.prop
 import org.junit.Test
 
 class GenericUriParserTest {
@@ -67,27 +68,24 @@ class GenericUriParserTest {
 
     @Test
     fun `negative 'startPos' value`() {
-        assertThat {
+        assertFailure {
             parser.parseUri("test", -1)
-        }.isFailure()
-            .isInstanceOf(IllegalArgumentException::class)
+        }.isInstanceOf<IllegalArgumentException>()
             .hasMessage("Invalid 'startPos' value")
     }
 
     @Test
     fun `out of bounds 'startPos' value`() {
-        assertThat {
+        assertFailure {
             parser.parseUri("test", 4)
-        }.isFailure()
-            .isInstanceOf(IllegalArgumentException::class)
+        }.isInstanceOf<IllegalArgumentException>()
             .hasMessage("Invalid 'startPos' value")
     }
 
     private fun assertUriValid(input: String) {
         val result = parser.parseUri(input, 0)
 
-        assertNotNull(result) { uriMatch ->
-            assertThat(uriMatch.uri).isEqualTo(input)
-        }
+        assertThat(result).isNotNull()
+            .prop(UriMatch::uri).isEqualTo(input)
     }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/message/html/HttpUriParserTest.kt b/app/core/src/test/java/com/fsck/k9/message/html/HttpUriParserTest.kt
index 235b6c24f594c730d79b3bcbc79d161b5e5320f9..3c8a61842a71796b5fc6ae9a1f25020b91cadec4 100644
--- a/app/core/src/test/java/com/fsck/k9/message/html/HttpUriParserTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/message/html/HttpUriParserTest.kt
@@ -1,9 +1,9 @@
 package com.fsck.k9.message.html
 
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
 import assertk.assertions.isNull
@@ -287,19 +287,17 @@ class HttpUriParserTest {
 
     @Test
     fun `negative 'startPos' value`() {
-        assertThat {
+        assertFailure {
             parser.parseUri("test", -1)
-        }.isFailure()
-            .isInstanceOf(IllegalArgumentException::class)
+        }.isInstanceOf<IllegalArgumentException>()
             .hasMessage("Invalid 'startPos' value")
     }
 
     @Test
     fun `out of bounds 'startPos' value`() {
-        assertThat {
+        assertFailure {
             parser.parseUri("test", 4)
-        }.isFailure()
-            .isInstanceOf(IllegalArgumentException::class)
+        }.isInstanceOf<IllegalArgumentException>()
             .hasMessage("Invalid 'startPos' value")
     }
 
diff --git a/app/core/src/test/java/com/fsck/k9/notification/BaseNotificationDataCreatorTest.kt b/app/core/src/test/java/com/fsck/k9/notification/BaseNotificationDataCreatorTest.kt
index 43e56a824daf928d2b42012e2345d31fa1f17614..1483f69864000e03d4537b640987d64c60fc57ac 100644
--- a/app/core/src/test/java/com/fsck/k9/notification/BaseNotificationDataCreatorTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/notification/BaseNotificationDataCreatorTest.kt
@@ -127,7 +127,7 @@ class BaseNotificationDataCreatorTest {
 
         val result = notificationDataCreator.createBaseNotificationData(notificationData)
 
-        assertThat(result.lockScreenNotificationData).isInstanceOf(LockScreenNotificationData.SenderNames::class.java)
+        assertThat(result.lockScreenNotificationData).isInstanceOf<LockScreenNotificationData.SenderNames>()
         val senderNamesData = result.lockScreenNotificationData as LockScreenNotificationData.SenderNames
         assertThat(senderNamesData.senderNames).isEqualTo("Sender One, Sender Two, Sender Three")
     }
diff --git a/app/core/src/test/java/com/fsck/k9/notification/NewMailNotificationManagerTest.kt b/app/core/src/test/java/com/fsck/k9/notification/NewMailNotificationManagerTest.kt
index aec8dcfbb15c08485dd74165505f48da6a5e959c..b7c4ee1151e3573da7d4bee79e28103d0b8ed579 100644
--- a/app/core/src/test/java/com/fsck/k9/notification/NewMailNotificationManagerTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/notification/NewMailNotificationManagerTest.kt
@@ -70,7 +70,7 @@ class NewMailNotificationManagerTest {
                 summary = "summary",
             ),
         )
-        assertThat(result.summaryNotificationData).isNotNull().isInstanceOf(SummarySingleNotificationData::class.java)
+        assertThat(result.summaryNotificationData).isNotNull().isInstanceOf<SummarySingleNotificationData>()
         val summaryNotificationData = result.summaryNotificationData as SummarySingleNotificationData
         assertThat(summaryNotificationData.singleNotificationData.isSilent).isFalse()
     }
@@ -108,7 +108,7 @@ class NewMailNotificationManagerTest {
             ),
         )
         assertThat(result.baseNotificationData.newMessagesCount).isEqualTo(2)
-        assertThat(result.summaryNotificationData).isNotNull().isInstanceOf(SummaryInboxNotificationData::class.java)
+        assertThat(result.summaryNotificationData).isNotNull().isInstanceOf<SummaryInboxNotificationData>()
         val summaryNotificationData = result.summaryNotificationData as SummaryInboxNotificationData
         assertThat(summaryNotificationData.content).isEqualTo(listOf("Zoe Meeting", "Alice Hi Bob"))
         assertThat(summaryNotificationData.messageReferences).isEqualTo(
@@ -229,7 +229,7 @@ class NewMailNotificationManagerTest {
             assertThat(data.cancelNotificationIds).isEqualTo(listOf(notificationIdTwo))
             assertThat(data.singleNotificationData).isEmpty()
             assertThat(data.baseNotificationData.newMessagesCount).isEqualTo(2)
-            assertThat(data.summaryNotificationData).isNotNull().isInstanceOf(SummaryInboxNotificationData::class.java)
+            assertThat(data.summaryNotificationData).isNotNull().isInstanceOf<SummaryInboxNotificationData>()
             val summaryNotificationData = data.summaryNotificationData as SummaryInboxNotificationData
             assertThat(summaryNotificationData.content).isEqualTo(listOf("Alice Three", "Alice One"))
             assertThat(summaryNotificationData.messageReferences).isEqualTo(
@@ -317,7 +317,7 @@ class NewMailNotificationManagerTest {
                 ),
             )
 
-            assertThat(data.summaryNotificationData).isNotNull().isInstanceOf(SummarySingleNotificationData::class.java)
+            assertThat(data.summaryNotificationData).isNotNull().isInstanceOf<SummarySingleNotificationData>()
             val summaryNotificationData = data.summaryNotificationData as SummarySingleNotificationData
             assertThat(summaryNotificationData.singleNotificationData.isSilent).isTrue()
             assertThat(summaryNotificationData.singleNotificationData.content).isEqualTo(
@@ -354,7 +354,7 @@ class NewMailNotificationManagerTest {
             assertThat(data.singleNotificationData).hasSize(MAX_NUMBER_OF_NEW_MESSAGE_NOTIFICATIONS)
             assertThat(data.singleNotificationData.map { it.content.sender }).doesNotContain("inactive")
 
-            assertThat(data.summaryNotificationData).isNotNull().isInstanceOf(SummaryInboxNotificationData::class.java)
+            assertThat(data.summaryNotificationData).isNotNull().isInstanceOf<SummaryInboxNotificationData>()
             val summaryNotificationData = data.summaryNotificationData as SummaryInboxNotificationData
             assertThat(summaryNotificationData.isSilent).isTrue()
         }
diff --git a/app/core/src/test/java/com/fsck/k9/notification/NotificationDataStoreTest.kt b/app/core/src/test/java/com/fsck/k9/notification/NotificationDataStoreTest.kt
index 781acaf6554248e4a1791f70b603be8ad02a49d5..ec310362047da87c7a141f8f49cfef9908906d53 100644
--- a/app/core/src/test/java/com/fsck/k9/notification/NotificationDataStoreTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/notification/NotificationDataStoreTest.kt
@@ -131,7 +131,7 @@ class NotificationDataStoreTest : RobolectricTest() {
             assertThat(removeResult.notificationHolders).hasSize(0)
             assertThat(removeResult.notificationStoreOperations).hasSize(MAX_NUMBER_OF_NEW_MESSAGE_NOTIFICATIONS + 1)
             for (notificationStoreOperation in removeResult.notificationStoreOperations) {
-                assertThat(notificationStoreOperation).isInstanceOf(NotificationStoreOperation.Remove::class.java)
+                assertThat(notificationStoreOperation).isInstanceOf<NotificationStoreOperation.Remove>()
             }
         }
     }
diff --git a/app/core/src/test/java/com/fsck/k9/notification/SummaryNotificationDataCreatorTest.kt b/app/core/src/test/java/com/fsck/k9/notification/SummaryNotificationDataCreatorTest.kt
index ed50ac4f3f614ab4a7fc954f31460c0280c18f82..48db6d7d97fc2a97c7cbb7b5778a0c0d7e8726ac 100644
--- a/app/core/src/test/java/com/fsck/k9/notification/SummaryNotificationDataCreatorTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/notification/SummaryNotificationDataCreatorTest.kt
@@ -51,7 +51,7 @@ class SummaryNotificationDataCreatorTest {
             silent = false,
         )
 
-        assertThat(result).isInstanceOf(SummarySingleNotificationData::class.java)
+        assertThat(result).isInstanceOf<SummarySingleNotificationData>()
     }
 
     @Test
diff --git a/app/core/src/test/java/com/fsck/k9/preferences/SettingsExporterTest.kt b/app/core/src/test/java/com/fsck/k9/preferences/SettingsExporterTest.kt
index 79f24f2d09b52dec5056faf4241743a5396e088a..b098ab1b3e3e51f6fbce9051f037a488f9f7e445 100644
--- a/app/core/src/test/java/com/fsck/k9/preferences/SettingsExporterTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/preferences/SettingsExporterTest.kt
@@ -1,14 +1,15 @@
 package com.fsck.k9.preferences
 
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
 import com.fsck.k9.K9RobolectricTest
 import com.fsck.k9.Preferences
 import com.fsck.k9.mailstore.FolderRepository
 import java.io.ByteArrayOutputStream
 import org.jdom2.Document
 import org.jdom2.input.SAXBuilder
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertNull
 import org.junit.Test
 import org.koin.core.component.inject
 import org.mockito.kotlin.mock
@@ -31,35 +32,35 @@ class SettingsExporterTest : K9RobolectricTest() {
     fun exportPreferences_producesXML() {
         val document = exportPreferences(false, emptySet())
 
-        assertEquals("k9settings", document.rootElement.name)
+        assertThat(document.rootElement.name).isEqualTo("k9settings")
     }
 
     @Test
     fun exportPreferences_setsVersionToLatest() {
         val document = exportPreferences(false, emptySet())
 
-        assertEquals(Settings.VERSION.toString(), document.rootElement.getAttributeValue("version"))
+        assertThat(document.rootElement.getAttributeValue("version")).isEqualTo(Settings.VERSION.toString())
     }
 
     @Test
     fun exportPreferences_setsFormatTo1() {
         val document = exportPreferences(false, emptySet())
 
-        assertEquals("1", document.rootElement.getAttributeValue("format"))
+        assertThat(document.rootElement.getAttributeValue("format")).isEqualTo("1")
     }
 
     @Test
     fun exportPreferences_exportsGlobalSettingsWhenRequested() {
         val document = exportPreferences(true, emptySet())
 
-        assertNotNull(document.rootElement.getChild("global"))
+        assertThat(document.rootElement.getChild("global")).isNotNull()
     }
 
     @Test
     fun exportPreferences_ignoresGlobalSettingsWhenRequested() {
         val document = exportPreferences(false, emptySet())
 
-        assertNull(document.rootElement.getChild("global"))
+        assertThat(document.rootElement.getChild("global")).isNull()
     }
 
     private fun exportPreferences(globalSettings: Boolean, accounts: Set<String>): Document {
diff --git a/app/core/src/test/java/com/fsck/k9/sasl/OAuthBearerTest.kt b/app/core/src/test/java/com/fsck/k9/sasl/OAuthBearerTest.kt
index fbb10d62622e280a58f76a953bb51868122f4479..e0b38dd83d3520466c8d7ac71cec01c403287282 100644
--- a/app/core/src/test/java/com/fsck/k9/sasl/OAuthBearerTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/sasl/OAuthBearerTest.kt
@@ -29,4 +29,15 @@ class OAuthBearerTest {
         assertThat(result.decodeBase64()?.utf8())
             .isEqualTo("n,a=user=3Dname@domain.example,\u0001auth=Bearer token\u0001\u0001")
     }
+
+    @Test
+    fun `username contains comma that needs to be encoded`() {
+        val username = "user,name"
+        val token = "token"
+
+        val result = buildOAuthBearerInitialClientResponse(username, token)
+
+        assertThat(result).isEqualTo("bixhPXVzZXI9MkNuYW1lLAFhdXRoPUJlYXJlciB0b2tlbgEB")
+        assertThat(result.decodeBase64()?.utf8()).isEqualTo("n,a=user=2Cname,\u0001auth=Bearer token\u0001\u0001")
+    }
 }
diff --git a/app/k9mail/build.gradle.kts b/app/k9mail/build.gradle.kts
index 311a981a97b8ba0423ac69a0cda53ea1e1eb567b..6d3979dd77b98ea888f81fd4fabf2c57efd2891a 100644
--- a/app/k9mail/build.gradle.kts
+++ b/app/k9mail/build.gradle.kts
@@ -46,8 +46,8 @@ android {
         applicationId = "foundation.e.mail"
         testApplicationId = "foundation.e.mail.tests"
 
-        versionCode = 37003
-        versionName = "6.703"
+        versionCode = 37007
+        versionName = "6.707"
 
         // Keep in sync with the resource string array "supported_languages"
         resourceConfigurations.addAll(
diff --git a/app/k9mail/src/main/java/com/fsck/k9/notification/K9NotificationStrategy.kt b/app/k9mail/src/main/java/com/fsck/k9/notification/K9NotificationStrategy.kt
index 242569abf112c9e2c63e28b6c435c95a6703b5ab..005a8e125086890481b8d119c4ca26f4a7ea399d 100644
--- a/app/k9mail/src/main/java/com/fsck/k9/notification/K9NotificationStrategy.kt
+++ b/app/k9mail/src/main/java/com/fsck/k9/notification/K9NotificationStrategy.kt
@@ -1,7 +1,7 @@
 package com.fsck.k9.notification
 
 import app.k9mail.core.android.common.contact.ContactRepository
-import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toEmailAddressOrNull
 import com.fsck.k9.Account
 import com.fsck.k9.K9
 import com.fsck.k9.mail.Flag
@@ -88,7 +88,7 @@ class K9NotificationStrategy(
         }
 
         if (account.isNotifyContactsMailOnly &&
-            !contactRepository.hasAnyContactFor(message.from.asList().mapNotNull { EmailAddress(it.address) })
+            !contactRepository.hasAnyContactFor(message.from.asList().mapNotNull { it.address.toEmailAddressOrNull() })
         ) {
             Timber.v("No notification: Message is not from a known contact")
             return false
diff --git a/app/storage/src/test/java/com/fsck/k9/preferences/StoragePersisterTest.kt b/app/storage/src/test/java/com/fsck/k9/preferences/StoragePersisterTest.kt
index d54347151e6b96fecbb5c6f424d76ec0dd8a31f9..02417aecc6310641ebcbc0649707f8540e4cbbbd 100644
--- a/app/storage/src/test/java/com/fsck/k9/preferences/StoragePersisterTest.kt
+++ b/app/storage/src/test/java/com/fsck/k9/preferences/StoragePersisterTest.kt
@@ -1,13 +1,16 @@
 package com.fsck.k9.preferences
 
 import android.content.Context
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.contains
+import assertk.assertions.containsOnly
+import assertk.assertions.isEmpty
+import assertk.assertions.isSameAs
+import assertk.assertions.isTrue
 import com.fsck.k9.preferences.K9StoragePersister.StoragePersistOperationCallback
 import com.fsck.k9.preferences.K9StoragePersister.StoragePersistOperations
 import com.fsck.k9.storage.K9RobolectricTest
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertSame
-import org.junit.Assert.assertTrue
-import org.junit.Assert.fail
 import org.junit.Test
 import org.mockito.kotlin.any
 import org.mockito.kotlin.inOrder
@@ -39,16 +42,15 @@ class StoragePersisterTest : K9RobolectricTest() {
         val operationCallback = prepareCallback(
             persistOp = { ops -> ops.put("x", "y") },
             onSuccess = { map ->
-                assertEquals(1, map.size)
-                assertEquals("y", map["x"])
+                assertThat(map).containsOnly("x" to "y")
             },
         )
 
         storagePersister.doInTransaction(operationCallback)
 
         val values = storagePersister.loadValues().all
-        assertEquals(1, values.size)
-        assertEquals("y", values["x"])
+
+        assertThat(values).containsOnly("x" to "y")
     }
 
     @Test
@@ -61,15 +63,13 @@ class StoragePersisterTest : K9RobolectricTest() {
             },
         )
 
-        try {
+        assertFailure {
             storagePersister.doInTransaction(operationCallback)
-            fail("expected exception")
-        } catch (e: Exception) {
-            assertSame(exception, e)
-        }
+        }.isSameAs(exception)
 
         val values = storagePersister.loadValues()
-        assertTrue(values.isEmpty())
+
+        assertThat(values.isEmpty).isTrue()
         verify(operationCallback, never()).onPersistTransactionSuccess(any())
     }
 
@@ -78,26 +78,32 @@ class StoragePersisterTest : K9RobolectricTest() {
         val operationCallback = prepareCallback(
             before = { map -> map["x"] = "y" },
             persistOp = { ops -> ops.remove("x") },
-            onSuccess = { map -> assertTrue(map.isEmpty()) },
+            onSuccess = { map ->
+                assertThat(map).isEmpty()
+            },
         )
 
         storagePersister.doInTransaction(operationCallback)
 
         val values = storagePersister.loadValues()
-        assertTrue(values.isEmpty())
+
+        assertThat(values.isEmpty).isTrue()
     }
 
     @Test
     fun doInTransaction_before_preserveButNotPersist() {
         val operationCallback = prepareCallback(
             before = { map -> map["x"] = "y" },
-            onSuccess = { map -> assertEquals("y", map["x"]) },
+            onSuccess = { map ->
+                assertThat(map).contains(key = "x", value = "y")
+            },
         )
 
         storagePersister.doInTransaction(operationCallback)
 
         val values = storagePersister.loadValues()
-        assertTrue(values.isEmpty())
+
+        assertThat(values.isEmpty).isTrue()
     }
 
     private fun prepareCallback(
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/ChunkedDatabaseOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/ChunkedDatabaseOperationsTest.kt
index 9c4814f0fd0167360e7d12e394acd22ac9c67a26..ba93095f269812489f45eb5b767a1b3565f7f99e 100644
--- a/app/storage/src/test/java/com/fsck/k9/storage/messages/ChunkedDatabaseOperationsTest.kt
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/ChunkedDatabaseOperationsTest.kt
@@ -3,7 +3,7 @@ package com.fsck.k9.storage.messages
 import assertk.assertThat
 import assertk.assertions.hasSize
 import assertk.assertions.isEqualTo
-import org.junit.Assert.fail
+import assertk.fail
 import org.junit.Test
 
 class ChunkedDatabaseOperationsTest {
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/MoveMessageOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/MoveMessageOperationsTest.kt
index 9b79cc33422f4878e83469aeb1d4c4e2c5805226..8f85f08bf279f76d500e7f4a6b28c668b346f383 100644
--- a/app/storage/src/test/java/com/fsck/k9/storage/messages/MoveMessageOperationsTest.kt
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/MoveMessageOperationsTest.kt
@@ -9,7 +9,6 @@ import assertk.assertions.startsWith
 import com.fsck.k9.K9
 import com.fsck.k9.storage.RobolectricTest
 import org.junit.Test
-import org.junit.Assert.fail as junitFail
 
 private const val SOURCE_FOLDER_ID = 3L
 private const val DESTINATION_FOLDER_ID = 23L
@@ -211,6 +210,4 @@ class MoveMessageOperationsTest : RobolectricTest() {
         assertThat(message.messagePartId).isNull()
         assertThat(message.encryptionType).isNull()
     }
-
-    private fun fail(message: String): Nothing = junitFail(message) as Nothing
 }
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveFolderOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveFolderOperationsTest.kt
index ea6c03913dcd3fcd5631b5265b3ae1ae3605c2ea..1dba4a96a2182f77b60a2c5b1a940e72fb1f75f5 100644
--- a/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveFolderOperationsTest.kt
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveFolderOperationsTest.kt
@@ -1,10 +1,10 @@
 package com.fsck.k9.storage.messages
 
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.hasSize
 import assertk.assertions.isEmpty
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
 import assertk.assertions.isNull
@@ -482,10 +482,9 @@ class RetrieveFolderOperationsTest : RobolectricTest() {
 
     @Test
     fun `get 'more messages' value from non-existent folder`() {
-        assertThat {
+        assertFailure {
             retrieveFolderOperations.hasMoreMessages(23)
-        }.isFailure()
-            .isInstanceOf(FolderNotFoundException::class)
+        }.isInstanceOf<FolderNotFoundException>()
             .transform { it.folderId }.isEqualTo(23)
     }
 
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientLoader.java b/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientLoader.java
index e5fd41de2a374c429b69bd27516e6c9ca920c1b6..e3931375fe236f98b5b0fd444018362a21e085a3 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientLoader.java
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientLoader.java
@@ -72,11 +72,9 @@ public class RecipientLoader extends AsyncTaskLoader<List<Recipient>> {
 
     private static final String[] PROJECTION_NICKNAME = {
             ContactsContract.Data.CONTACT_ID,
-            ContactsContract.CommonDataKinds.Nickname.NAME
     };
 
     private static final int INDEX_CONTACT_ID_FOR_NICKNAME = 0;
-    private static final int INDEX_NICKNAME = 1;
 
     private static final String[] PROJECTION_CRYPTO_ADDRESSES = {
             "address",
@@ -377,8 +375,7 @@ public class RecipientLoader extends AsyncTaskLoader<List<Recipient>> {
                 Cursor cursor = contentResolver
                         .query(queryUri, PROJECTION, selection, new String[] { id }, SORT_ORDER);
 
-                String contactNickname = nicknameCursor.getString(INDEX_NICKNAME);
-                fillContactDataFromCursor(cursor, recipients, recipientMap, contactNickname, null);
+                fillContactDataFromCursor(cursor, recipients, recipientMap, null);
 
                 hasContact = true;
             }
@@ -403,7 +400,7 @@ public class RecipientLoader extends AsyncTaskLoader<List<Recipient>> {
             return recipients;
         }
 
-        fillContactDataFromCursor(cursor, recipients, new HashMap<>(), null, maxRecipients);
+        fillContactDataFromCursor(cursor, recipients, new HashMap<>(), maxRecipients);
 
         return recipients;
     }
@@ -437,15 +434,14 @@ public class RecipientLoader extends AsyncTaskLoader<List<Recipient>> {
 
     private void fillContactDataFromCursor(Cursor cursor, List<Recipient> recipients,
             Map<String, Recipient> recipientMap) {
-        fillContactDataFromCursor(cursor, recipients, recipientMap, null, null);
+        fillContactDataFromCursor(cursor, recipients, recipientMap, null);
     }
 
     private void fillContactDataFromCursor(Cursor cursor, List<Recipient> recipients,
-            Map<String, Recipient> recipientMap, @Nullable String prefilledName, @Nullable Integer maxRecipients) {
+            Map<String, Recipient> recipientMap, @Nullable Integer maxRecipients) {
 
         while (cursor.moveToNext() && (maxRecipients == null || recipients.size() < maxRecipients)) {
-            String name = prefilledName != null ? prefilledName : cursor.getString(INDEX_NAME);
-
+            String name = cursor.getString(INDEX_NAME);
             String email = cursor.getString(INDEX_EMAIL);
 
             // already exists? just skip then
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientMvpView.kt b/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientMvpView.kt
index 87be24e20d07a35f9a2f2bcf808a149d4dbc4b02..043470e167e29f36d18d77634e09264c3eaa8038 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientMvpView.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientMvpView.kt
@@ -192,6 +192,30 @@ class RecipientMvpView(private val activity: MessageCompose) : View.OnFocusChang
         }
     }
 
+    fun silentlyAddRecipients(recipientType: RecipientType, vararg recipients: Recipient) {
+        removeAllTextListenersFromView(recipientType)
+        addRecipients(recipientType, *recipients)
+        addAllTextListenersToView(recipientType)
+    }
+
+    private fun removeAllTextListenersFromView(recipientType: RecipientType) {
+        when (recipientType) {
+            RecipientType.TO -> removeAllTextChangedListeners(toView)
+            RecipientType.CC -> removeAllTextChangedListeners(ccView)
+            RecipientType.BCC -> removeAllTextChangedListeners(bccView)
+            else -> throw AssertionError("Unsupported type: $recipientType")
+        }
+    }
+
+    private fun addAllTextListenersToView(recipientType: RecipientType) {
+        when (recipientType) {
+            RecipientType.TO -> addAllTextChangedListeners(toView)
+            RecipientType.CC -> addAllTextChangedListeners(ccView)
+            RecipientType.BCC -> addAllTextChangedListeners(bccView)
+            else -> throw AssertionError("Unsupported type: $recipientType")
+        }
+    }
+
     fun silentlyAddBccAddresses(vararg recipients: Recipient) {
         removeAllTextChangedListeners(bccView)
 
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientPresenter.kt b/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientPresenter.kt
index b95a4ab1bbd0641295265bfe85c78bbdf957fa88..06215a7acdab181eef98f3231f63daabe19f4f3e 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientPresenter.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientPresenter.kt
@@ -98,6 +98,24 @@ class RecipientPresenter(
 
     private var openPgpKeySetupUtil : OpenPgpKeySetupUtil? = null
 
+    private val openPgpCallback = object : OpenPgpApiManagerCallback {
+        override fun onOpenPgpProviderStatusChanged() {
+            if (openPgpApiManager.openPgpProviderState == OpenPgpProviderState.UI_REQUIRED) {
+                recipientMvpView.showErrorOpenPgpUserInteractionRequired()
+            }
+            asyncUpdateCryptoStatus()
+        }
+
+        override fun onOpenPgpProviderError(error: OpenPgpProviderError) {
+            when (error) {
+                OpenPgpProviderError.ConnectionLost -> openPgpApiManager.refreshConnection()
+                OpenPgpProviderError.VersionIncompatible -> recipientMvpView.showErrorOpenPgpIncompatible()
+                OpenPgpProviderError.ConnectionFailed -> recipientMvpView.showErrorOpenPgpConnection()
+                else -> recipientMvpView.showErrorOpenPgpConnection()
+            }
+        }
+    }
+
     init {
         recipientMvpView.setPresenter(this)
         recipientMvpView.setLoaderManager(loaderManager)
@@ -485,7 +503,7 @@ class RecipientPresenter(
         object : RecipientLoader(context, account.openPgpProvider, *addresses) {
             override fun deliverResult(result: List<Recipient>?) {
                 val recipientArray = result!!.toTypedArray()
-                recipientMvpView.addRecipients(recipientType, *recipientArray)
+                recipientMvpView.silentlyAddRecipients(recipientType, *recipientArray)
 
                 stopLoading()
                 abandon()
@@ -813,25 +831,6 @@ class RecipientPresenter(
         }
     }
 
-    private val openPgpCallback = object : OpenPgpApiManagerCallback {
-        override fun onOpenPgpProviderStatusChanged() {
-            if (openPgpApiManager.openPgpProviderState == OpenPgpProviderState.UI_REQUIRED) {
-                recipientMvpView.showErrorOpenPgpUserInteractionRequired()
-            }
-
-            asyncUpdateCryptoStatus()
-        }
-
-        override fun onOpenPgpProviderError(error: OpenPgpProviderError) {
-            when (error) {
-                OpenPgpProviderError.ConnectionLost -> openPgpApiManager.refreshConnection()
-                OpenPgpProviderError.VersionIncompatible -> recipientMvpView.showErrorOpenPgpIncompatible()
-                OpenPgpProviderError.ConnectionFailed -> recipientMvpView.showErrorOpenPgpConnection()
-                else -> recipientMvpView.showErrorOpenPgpConnection()
-            }
-        }
-    }
-
     private fun Array<String>.toAddressArray(): Array<Address> {
         return flatMap { addressString ->
             Address.parseUnencoded(addressString).toList()
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/contacts/ContactPhotoLoader.kt b/app/ui/legacy/src/main/java/com/fsck/k9/contacts/ContactPhotoLoader.kt
index 29b88aeedb274a8c3eab9bb8d2e478eae5753e38..363d4890c2f1c763146d3c7c8ba1cb098b64aaf6 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/contacts/ContactPhotoLoader.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/contacts/ContactPhotoLoader.kt
@@ -3,8 +3,9 @@ package com.fsck.k9.contacts
 import android.content.ContentResolver
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
+import android.net.Uri
 import app.k9mail.core.android.common.contact.ContactRepository
-import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toEmailAddressOrNull
 import timber.log.Timber
 
 internal class ContactPhotoLoader(
@@ -12,7 +13,7 @@ internal class ContactPhotoLoader(
     private val contactRepository: ContactRepository,
 ) {
     fun loadContactPhoto(emailAddress: String): Bitmap? {
-        val photoUri = contactRepository.getContactFor(EmailAddress(emailAddress))?.photoUri ?: return null
+        val photoUri = getPhotoUri(emailAddress) ?: return null
         return try {
             contentResolver.openInputStream(photoUri).use { inputStream ->
                 BitmapFactory.decodeStream(inputStream)
@@ -22,4 +23,10 @@ internal class ContactPhotoLoader(
             null
         }
     }
+
+    private fun getPhotoUri(email: String): Uri? {
+        return email.toEmailAddressOrNull()?.let { emailAddress ->
+            contactRepository.getContactFor(emailAddress)?.photoUri
+        }
+    }
 }
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagedetails/AddToContactsLauncher.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagedetails/AddToContactsLauncher.kt
index 399883c40c587fe0c0be8c0b4e9c7df2aefb6c7a..72a6b2fd547321160a86d21904ef1b6b313b20a4 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagedetails/AddToContactsLauncher.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagedetails/AddToContactsLauncher.kt
@@ -6,8 +6,8 @@ import android.provider.ContactsContract
 
 internal class AddToContactsLauncher {
     fun launch(context: Context, name: String?, email: String) {
-        val intent = Intent(Intent.ACTION_INSERT).apply {
-            type = ContactsContract.Contacts.CONTENT_TYPE
+        val intent = Intent(Intent.ACTION_INSERT_OR_EDIT).apply {
+            type = ContactsContract.Contacts.CONTENT_ITEM_TYPE
 
             putExtra(ContactsContract.Intents.Insert.EMAIL, email)
 
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagedetails/MessageDetailsViewModel.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagedetails/MessageDetailsViewModel.kt
index 9b3b5faa4ff9ac2af603f71bf5b546d1c32c95cb..63b46ed532847148a7c2dd1e957ad13175dea76a 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagedetails/MessageDetailsViewModel.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagedetails/MessageDetailsViewModel.kt
@@ -2,12 +2,13 @@ package com.fsck.k9.ui.messagedetails
 
 import android.app.PendingIntent
 import android.content.res.Resources
+import android.net.Uri
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import app.k9mail.core.android.common.contact.CachingRepository
 import app.k9mail.core.android.common.contact.ContactPermissionResolver
 import app.k9mail.core.android.common.contact.ContactRepository
-import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toEmailAddressOrNull
 import com.fsck.k9.Account
 import com.fsck.k9.controller.MessageReference
 import com.fsck.k9.helper.ClipboardManager
@@ -30,6 +31,7 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.receiveAsFlow
 import kotlinx.coroutines.launch
 
+@Suppress("TooManyFunctions")
 internal class MessageDetailsViewModel(
     private val resources: Resources,
     private val messageRepository: MessageRepository,
@@ -130,11 +132,17 @@ internal class MessageDetailsViewModel(
             Participant(
                 displayName = displayName,
                 emailAddress = emailAddress,
-                contactLookupUri = contactRepository.getContactFor(EmailAddress(emailAddress))?.uri,
+                contactLookupUri = getContactLookupUri(emailAddress),
             )
         }
     }
 
+    private fun getContactLookupUri(email: String): Uri? {
+        return email.toEmailAddressOrNull()?.let { emailAddress ->
+            contactRepository.getContactFor(emailAddress)?.uri
+        }
+    }
+
     private fun Folder.toFolderInfo(): FolderInfoUi {
         return FolderInfoUi(
             displayName = folderNameFormatter.displayName(this),
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messageview/DisplayRecipientsExtractor.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messageview/DisplayRecipientsExtractor.kt
index 95a10e4925fbe7629b409f2f3fb5b1c61be4059f..d56e02eadbb5693f1399dfc1c98a21b0d298927c 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messageview/DisplayRecipientsExtractor.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messageview/DisplayRecipientsExtractor.kt
@@ -1,7 +1,6 @@
 package com.fsck.k9.ui.messageview
 
 import com.fsck.k9.Account
-import com.fsck.k9.mail.Address
 import com.fsck.k9.mail.Message
 
 /**
@@ -21,13 +20,12 @@ internal class DisplayRecipientsExtractor(
 
         val numberOfRecipients = toRecipients.size + ccRecipients.size + bccRecipients.size
 
-        val identity = sequenceOf(toRecipients, ccRecipients, bccRecipients)
+        val identityAddress = sequenceOf(toRecipients, ccRecipients, bccRecipients)
             .flatMap { addressArray -> addressArray.asSequence() }
-            .mapNotNull { address -> account.findIdentity(address) }
+            .filter { address -> account.isAnIdentity(address) }
             .firstOrNull()
 
-        val identityEmail = identity?.email
-        val maxAdditionalRecipients = if (identity != null) {
+        val maxAdditionalRecipients = if (identityAddress != null) {
             maxNumberOfDisplayRecipients - 1
         } else {
             maxNumberOfDisplayRecipients
@@ -35,13 +33,12 @@ internal class DisplayRecipientsExtractor(
 
         val recipientNames = sequenceOf(toRecipients, ccRecipients, bccRecipients)
             .flatMap { addressArray -> addressArray.asSequence() }
-            .filter { address -> address.address != identityEmail }
+            .filter { address -> address !== identityAddress }
             .map { address -> recipientFormatter.getDisplayName(address, account) }
             .take(maxAdditionalRecipients)
             .toList()
 
-        return if (identity != null) {
-            val identityAddress = Address(identity.email)
+        return if (identityAddress != null) {
             val meName = recipientFormatter.getDisplayName(identityAddress, account)
             val recipients = listOf(meName) + recipientNames
 
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messageview/MessageTopView.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messageview/MessageTopView.kt
index 35352bfa29644887a993951935412f3f28d4ab75..c55613365a294f99785548c40378e1a2a30a4e5b 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messageview/MessageTopView.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messageview/MessageTopView.kt
@@ -19,6 +19,7 @@ import android.widget.ProgressBar
 import android.widget.TextView
 import app.k9mail.core.android.common.contact.ContactRepository
 import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toEmailAddressOrNull
 import com.fsck.k9.Account
 import com.fsck.k9.Account.ShowPictures
 import com.fsck.k9.mail.Message
@@ -262,15 +263,15 @@ class MessageTopView(
             return false
         }
         val senderEmailAddress = getSenderEmailAddress(message) ?: return false
-        return contactRepository.hasContactFor(EmailAddress(senderEmailAddress))
+        return contactRepository.hasContactFor(senderEmailAddress)
     }
 
-    private fun getSenderEmailAddress(message: Message): String? {
+    private fun getSenderEmailAddress(message: Message): EmailAddress? {
         val from = message.from
         return if (from == null || from.isEmpty()) {
             null
         } else {
-            from[0].address
+            from[0].address.toEmailAddressOrNull()
         }
     }
 
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/view/KoinModule.kt b/app/ui/legacy/src/main/java/com/fsck/k9/view/KoinModule.kt
index 39f7fd1a65bddb115e66c977eb035352763602a8..89a209b7c2e4b5a228c1e4db56fa3dcad3120904 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/view/KoinModule.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/view/KoinModule.kt
@@ -16,4 +16,5 @@ val viewModule = module {
         K9WebViewClient(clipboardManager = get(), attachmentResolver, onPageFinishedListener)
     }
     factory { WebViewClientFactory() }
+    factory { UserInputEmailAddressParser() }
 }
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/view/RecipientSelectView.java b/app/ui/legacy/src/main/java/com/fsck/k9/view/RecipientSelectView.java
index ea9118b7abad582d191c92381e543bf0840cc7f4..c34297c52e1f05cb1522b5a3229d15e856d07644 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/view/RecipientSelectView.java
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/view/RecipientSelectView.java
@@ -33,6 +33,7 @@ import android.widget.ListPopupWindow;
 import android.widget.ListView;
 import android.widget.TextView;
 
+import com.fsck.k9.DI;
 import com.fsck.k9.K9;
 import com.fsck.k9.ui.R;
 import com.fsck.k9.activity.AlternateRecipientAdapter;
@@ -43,7 +44,6 @@ import com.fsck.k9.mail.Address;
 import com.fsck.k9.ui.compose.RecipientCircleImageView;
 import com.fsck.k9.view.RecipientSelectView.Recipient;
 import com.tokenautocomplete.TokenCompleteTextView;
-import org.apache.james.mime4j.util.CharsetUtil;
 import timber.log.Timber;
 import de.hdodenhof.circleimageview.CircleImageView;
 
@@ -61,6 +61,8 @@ public class RecipientSelectView extends TokenCompleteTextView<Recipient> implem
     private static final int LOADER_ID_ALTERNATES = 1;
 
 
+    private final UserInputEmailAddressParser emailAddressParser = DI.get(UserInputEmailAddressParser.class);
+
     private RecipientAdapter adapter;
     @Nullable
     private String cryptoProvider;
@@ -171,17 +173,19 @@ public class RecipientSelectView extends TokenCompleteTextView<Recipient> implem
 
     @Override
     protected Recipient defaultObject(String completionText) {
-        Address[] parsedAddresses = Address.parse(completionText);
-        if (!CharsetUtil.isASCII(completionText)) {
+        try {
+            List<Address> parsedAddresses = emailAddressParser.parse(completionText);
+
+            if (parsedAddresses.isEmpty()) {
+                setError(getContext().getString(R.string.recipient_error_parse_failed));
+                return null;
+            }
+
+            return new Recipient(parsedAddresses.get(0));
+        } catch (NonAsciiEmailAddressException e) {
             setError(getContext().getString(R.string.recipient_error_non_ascii));
             return null;
         }
-        if (parsedAddresses.length == 0 || parsedAddresses[0].getAddress() == null) {
-            setError(getContext().getString(R.string.recipient_error_parse_failed));
-            return null;
-        }
-
-        return new Recipient(parsedAddresses[0]);
     }
 
     public void setLoaderManager(@Nullable LoaderManager loaderManager) {
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/view/UserInputEmailAddressParser.kt b/app/ui/legacy/src/main/java/com/fsck/k9/view/UserInputEmailAddressParser.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a14cb14bdb277abfae52045b613c1fbd740004b5
--- /dev/null
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/view/UserInputEmailAddressParser.kt
@@ -0,0 +1,31 @@
+package com.fsck.k9.view
+
+import com.fsck.k9.mail.Address
+import org.apache.james.mime4j.util.CharsetUtil
+
+/**
+ * Used to parse name & email address pairs entered by the user.
+ *
+ * TODO: Build a custom implementation that can deal with typical inputs from users who are not familiar with the
+ *  RFC 5322 address-list syntax. See (ignored) tests in `UserInputEmailAddressParserTest`.
+ */
+internal class UserInputEmailAddressParser {
+
+    @Throws(NonAsciiEmailAddressException::class)
+    fun parse(input: String): List<Address> {
+        return Address.parseUnencoded(input)
+            .mapNotNull { address ->
+                when {
+                    address.isIncomplete() -> null
+                    address.isNonAsciiAddress() -> throw NonAsciiEmailAddressException(address.address)
+                    else -> Address.parse(address.toEncodedString()).firstOrNull()
+                }
+            }
+    }
+
+    private fun Address.isIncomplete() = hostname.isNullOrBlank()
+
+    private fun Address.isNonAsciiAddress() = !CharsetUtil.isASCII(address)
+}
+
+internal class NonAsciiEmailAddressException(message: String) : Exception(message)
diff --git a/app/ui/legacy/src/main/res/layout/account_setup_oauth.xml b/app/ui/legacy/src/main/res/layout/account_setup_oauth.xml
index fae9a2d8f69ab9089a0c2dcdbd6bb2f38d0759f0..a373e73f64ee87a40f20a13324e4373c47d3eefd 100644
--- a/app/ui/legacy/src/main/res/layout/account_setup_oauth.xml
+++ b/app/ui/legacy/src/main/res/layout/account_setup_oauth.xml
@@ -37,7 +37,7 @@
                 android:text="@string/account_setup_oauth_sign_in"
                 android:visibility="gone" />
 
-            <Button
+            <androidx.appcompat.widget.AppCompatButton
                 android:id="@+id/google_sign_in_button"
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
diff --git a/app/ui/legacy/src/main/res/layout/fragment_settings_import.xml b/app/ui/legacy/src/main/res/layout/fragment_settings_import.xml
index e340107ef85d7703a7d8fa8d31df53a18f067356..87bf2a328a6cd639e703d2813f563a45b2e2e57e 100644
--- a/app/ui/legacy/src/main/res/layout/fragment_settings_import.xml
+++ b/app/ui/legacy/src/main/res/layout/fragment_settings_import.xml
@@ -28,7 +28,7 @@
         android:layout_marginEnd="16dp"
         android:layout_marginBottom="16dp"
         android:text="@string/settings_import_pick_document_button"
-        android:textColor="@android:color/white"
+        android:textColor="@color/color_default_background"
         app:layout_constraintBottom_toTopOf="@+id/bottomBar"
         app:layout_constraintEnd_toEndOf="parent"
         app:layout_constraintStart_toStartOf="parent"
@@ -65,7 +65,7 @@
             android:layout_marginBottom="4dp"
             android:enabled="false"
             android:text="@string/settings_import_button"
-            android:textColor="@android:color/white"
+            android:textColor="@color/color_default_background"
             app:layout_constraintBottom_toBottomOf="parent"
             app:layout_constraintEnd_toEndOf="parent"
             app:layout_constraintTop_toTopOf="parent"
@@ -80,7 +80,7 @@
             android:layout_marginEnd="8dp"
             android:layout_marginBottom="4dp"
             android:text="@string/okay_action"
-            android:textColor="@android:color/white"
+            android:textColor="@color/color_default_background"
             android:visibility="gone"
             app:layout_constraintBottom_toBottomOf="parent"
             app:layout_constraintEnd_toEndOf="parent"
diff --git a/app/ui/legacy/src/main/res/raw/changelog_master.xml b/app/ui/legacy/src/main/res/raw/changelog_master.xml
index e89efbbdc60ec8268bfa2f75a17b1685848293a2..aba1a483b11d85596e2e615eebb76d123bbbf7e0 100644
--- a/app/ui/legacy/src/main/res/raw/changelog_master.xml
+++ b/app/ui/legacy/src/main/res/raw/changelog_master.xml
@@ -5,6 +5,28 @@
      Locale-specific versions are kept in res/raw-<locale qualifier>/changelog.xml.
 -->
 <changelog>
+    <release version="6.707" versioncode="37007" date="2023-06-19">
+        <change>Fixed bug where navigating to a different screen after using the system back button/gesture could crash the app</change>
+    </release>
+    <release version="6.706" versioncode="37006" date="2023-06-16">
+        <change>Fixed a bug that lead to folders appearing to be empty</change>
+        <change>Don't use nickname as display name when auto-completing recipient using the nickname</change>
+    </release>
+    <release version="6.705" versioncode="37005" date="2023-06-12">
+        <change>Adding to contacts should now allow you again to add the email address to an existing contact</change>
+        <change>Fixed display issue with recipients in message view screen</change>
+        <change>Fixed appearance of "Sign in with Google" button</change>
+        <change>Fixed bugs with importing and exporting identities</change>
+        <change>Manually entering names containing non-latin characters is now possible when composing messages</change>
+        <change>The app will no longer ask to save a draft when no changes have been made to an existing draft message</change>
+        <change>Updated translations</change>
+    </release>
+    <release version="6.704" versioncode="37004" date="2023-05-23">
+        <change>Changed primary action in message view header from "reply all" to "reply"</change>
+        <change>Fixed the app so it runs on devices that don't support home screen widgets</change>
+        <change>Fixed bug where "Cannot connect to crypto provider" was displayed when the problem wasn't the crypto provider</change>
+        <change>Updated translations</change>
+    </release>
     <release version="6.703" versioncode="37003" date="2023-05-08">
         <change>Internal changes</change>
         <change>Updated translations</change>
@@ -24,6 +46,9 @@
         <change>Fixed various crashes</change>
         <change>Updated translations</change>
     </release>
+    <release version="6.602" versioncode="36002" date="2023-05-11">
+        <change>Change primary action in message view header from "reply all" to "reply"</change>
+    </release>
     <release version="6.601" versioncode="36001" date="2023-04-18">
         <change>Reverted changes to home screen widgets because apparently not every device vendor has incorporated the relevant fixes in Android 12+</change>
     </release>
diff --git a/app/ui/legacy/src/main/res/values-et/strings.xml b/app/ui/legacy/src/main/res/values-et/strings.xml
index fcd681b70282ac411a5d8f8e12cb1a248eb37b01..8e54fbb92c4cef5cbd497260b4dcc74ea56c0e72 100644
--- a/app/ui/legacy/src/main/res/values-et/strings.xml
+++ b/app/ui/legacy/src/main/res/values-et/strings.xml
@@ -386,6 +386,9 @@
     <string name="account_setup_failed_dlg_certificate_message_fmt">Server esitles vigast SSL sertifikaati. Mõnikord juhtub see serveri vale konfiguratsiooni tõttu. Mõnikord seetõttu, et keegi proovib rünnata Sind või Sinu meiliserverit. Kui Sa ei ole kindel mis toimub, klõpsa Tühista ja võta ühendust tegelastega, kes haldavad su meiliserverit.
 
 (<xliff:g id="error">%s</xliff:g>)</string>
+    <!--Title of an error notification that is displayed when creating a notification for a new message has failed-->
+    <string name="notification_notify_error_title">Viga teavitusel</string>
+    <string name="notification_channel_push_title">Sünkroniseeri (kasuta tõuketeenust)</string>
     <string name="account_setup_failed_dlg_server_message_fmt">Ei saa serveriga ühendust.\n(<xliff:g id="error">%s</xliff:g>)</string>
     <string name="account_setup_failed_dlg_oauth_flow_canceled">Autentimine on katkenud</string>
     <string name="account_setup_failed_dlg_oauth_flow_failed">Autentimine ei õnnestunud ja tekkis järgnev viga: <xliff:g id="error">%s</xliff:g></string>
@@ -1071,4 +1074,4 @@ Palun jäta see kiri alles ning kasuta seda muu hulgas oma krüptovõtme varunda
     <string name="clipboard_label_email_address">E-posti aadress</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
     <string name="clipboard_label_name_and_email_address">Nimi ja e-posti aadress</string>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-hu/strings.xml b/app/ui/legacy/src/main/res/values-hu/strings.xml
index 8800e9cd096ccc26454536fb3521f0e1e66bc8ba..5e0ea99c6eedc35ba881a41900e334b2ab4c9f50 100644
--- a/app/ui/legacy/src/main/res/values-hu/strings.xml
+++ b/app/ui/legacy/src/main/res/values-hu/strings.xml
@@ -1004,6 +1004,28 @@ Az új eszköz Autocrypthez történő beállításához kövesse az utasításo
 
 Megtarthatja ezt az üzenetet, és felhasználhatja a titkos kulcs biztonsági mentéséhez. Ha ezt szeretné tenni, akkor fel kell írnia a jelszót, és biztonságosan kell tárolnia.
 </string>
+    <!--Button text of the "snack bar" that is displayed when the app was updated.-->
+    <string name="changelog_snackbar_button_text">Megtekintés</string>
+    <string name="choose_folder_move_title">Áthelyezés…</string>
+    <string name="choose_folder_copy_title">Másolás…</string>
+    <!--Displayed in the message view screen in front of the recipient list. For most languages this should end with a space.-->
+    <string name="message_view_recipient_prefix">-&gt;</string>
+    <!--Displayed in the message view screen in front of the number of additional recipients (the ones that are not displayed).-->
+    <string name="message_view_additional_recipient_prefix">+</string>
+    <!--Displayed in the message view screen if the message was addressed to the user. Make sure this works with 'message_view_recipient_prefix'. In English it's "to me".-->
+    <string name="message_view_me_text">Számomra</string>
+    <!--Text of the button that is displayed below the message header when the message body references one or more remote images-->
+    <string name="message_view_show_remote_images_action">Távoli képek megjelenítése</string>
+    <!--Title of the setting to specify the density of the message list-->
+    <string name="general_settings_message_list_density_title">Sűrűség</string>
+    <string name="general_settings_ui_density_compact">Kompakt</string>
+    <string name="general_settings_ui_density_relaxed">Relaxált</string>
+    <string name="account_setup_check_settings_title" />
+    <string name="account_setup_incoming_send_client_id">Ügyfélazonosítót kell küldeni</string>
+    <string name="account_settings_notification_channels_label">Értesítési kategóriák</string>
+    <string name="account_settings_open_notification_settings_messages_summary">Értesítési beállítások az új üzenetekhez</string>
+    <string name="account_settings_open_notification_settings_miscellaneous_summary">Hiba- és állapotértesítések beállítása</string>
+    <string name="font_size_message_view_recipients">Címzettek</string>
     <string name="ac_transfer_error_send">Hiba történt az üzenet elküldése során. Ellenőrizze a hálózati kapcsolatot és a kimenő kiszolgáló beállítását.</string>
     <string name="switch_on">Be</string>
     <string name="switch_off">Ki</string>
@@ -1066,5 +1088,28 @@ Megtarthatja ezt az üzenetet, és felhasználhatja a titkos kulcs biztonsági m
     <!--Name of the action to copy a name and email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">E-mail-cím</string>
+    <!--Name of setting to configure whether to show a "compose" floating action button on top of the message list-->
+    <string name="general_settings_show_compose_button_title">Lebegő levélírás-gomb megjelenítése</string>
+    <!--Displayed in the toolbar when there was an error loading the message list, e.g. because the folder no longer exists.-->
+    <string name="message_list_error_title">Hiba</string>
+    <!--Displayed instead of the message list when a folder couldn't be found, e.g. due to an outdated home screen shortcut.-->
+    <string name="message_list_error_folder_not_found">A mappa nem található</string>
+    <!--Title of the toolbar that is displayed when the message details bottom sheet has been expanded-->
+    <string name="message_details_toolbar_title">Üzenet részletei</string>
+    <!--Displayed when an email is missing the 'Date' header field and no date can be displayed in the message details bottom sheet.-->
+    <string name="message_details_missing_date">Hiányzik a „Dátum” fejléc</string>
+    <!--Title of the "Sender" section in the message details bottom sheet. This refers to the 'Sender' header. Be careful with translations.-->
+    <string name="message_details_sender_section_title">Feladó</string>
+    <!--Displayed when loading the message details has failed-->
+    <string name="message_details_loading_error">Hiba történt az üzenet részleteinek betöltése közben.</string>
+    <!--Name of the action to add a person to contacts. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_add_to_contacts">Hozzáadás a Kapcsolatokhoz</string>
+    <!--Name of the action to compose a new message to a particular address. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_compose_message_to">Üzenet írása, címzett:</string>
+    <!--Name of the action to copy an email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_copy_email_address">E-mail cím másolása</string>
+    <!--Name of the action to copy a name and email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_copy_name_and_email_address">Név és e-mail cím másolása</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <string name="clipboard_label_name_and_email_address">Név és e-mail cím</string>
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-is/strings.xml b/app/ui/legacy/src/main/res/values-is/strings.xml
index d993c0258244ec70b198c4963b98ecb831a4fc48..4f6c755654646842c649531965130b99ad643a08 100644
--- a/app/ui/legacy/src/main/res/values-is/strings.xml
+++ b/app/ui/legacy/src/main/res/values-is/strings.xml
@@ -312,7 +312,6 @@
     <string name="account_setup_incoming_client_certificate_label">Skilríki forritsins</string>
     <string name="account_setup_incoming_pop_server_label">POP3-þjónn</string>
     <string name="account_setup_incoming_imap_server_label">IMAP-þjónn</string>
-    <string name="account_setup_incoming_webdav_server_label">Exchange-þjónn</string>
     <string name="account_setup_incoming_port_label">Gátt</string>
     <string name="account_setup_incoming_security_label">Öryggi</string>
     <string name="account_setup_incoming_auth_type_label">Auðkenning</string>
@@ -338,9 +337,6 @@
     <string name="spam_folder_label">Ruslpóstmappa</string>
     <string name="account_setup_incoming_subscribed_folders_only_label">Sýna einungis möppur í áskrift</string>
     <string name="account_setup_auto_expand_folder">Fletta möppu út sjálfvirkt</string>
-    <string name="account_setup_incoming_webdav_path_prefix_label">OWA-slóð</string>
-    <string name="account_setup_incoming_webdav_auth_path_label">Slóð auðkenningar</string>
-    <string name="account_setup_incoming_webdav_mailbox_path_label">Samnefni pósthólfs</string>
     <string name="account_setup_outgoing_title">Stillingar sendinga-póstþjóns</string>
     <string name="account_setup_outgoing_smtp_server_label">SMTP-þjónn</string>
     <string name="account_setup_outgoing_port_label">Gátt</string>
@@ -1106,4 +1102,4 @@
     <string name="account_setup_incoming_send_client_id">Senda auðkenni biðlara</string>
     <string name="font_size_message_view_account">Nafn aðgangsins</string>
     <string name="action_compose_message_to">Semja póst til</string>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-pt-rPT/strings.xml b/app/ui/legacy/src/main/res/values-pt-rPT/strings.xml
index b98d295c94d8548e91e8a91f2709d4e9256a9e51..109f8c8786c57ce1c16ebd2dab7a5fb412f97180 100644
--- a/app/ui/legacy/src/main/res/values-pt-rPT/strings.xml
+++ b/app/ui/legacy/src/main/res/values-pt-rPT/strings.xml
@@ -27,6 +27,7 @@
   <!--Displayed in a "snack bar" at the bottom of the screen when the app was updated.-->
   <string name="changelog_snackbar_text">Descubra o que há de novo nesta versão</string>
   <!--Button text of the "snack bar" that is displayed when the app was updated.-->
+  <string name="changelog_snackbar_button_text">Ver</string>
   <!--Welcome message-->
   <string name="welcome_message_title">Welcome to Mail</string>
   <string name="accounts_welcome">Mail is the default mail client for /e/</string>
@@ -201,9 +202,13 @@
   <string name="message_view_bcc_label">Bcc:</string>
   <string name="message_view_status_attachment_not_saved">Não foi possível guardar o anexo</string>
   <!--Displayed in the message view screen in front of the recipient list. For most languages this should end with a space.-->
+  <string name="message_view_recipient_prefix">"para "</string>
   <!--Displayed in the message view screen in front of the number of additional recipients (the ones that are not displayed).-->
+  <string name="message_view_additional_recipient_prefix">+</string>
   <!--Displayed in the message view screen if the message was addressed to the user. Make sure this works with 'message_view_recipient_prefix'. In English it's "to me".-->
+  <string name="message_view_me_text">eu</string>
   <!--Text of the button that is displayed below the message header when the message body references one or more remote images-->
+  <string name="message_view_show_remote_images_action">Mostrar imagens remotas</string>
   <string name="message_view_no_viewer">Incapaz de encontrar visualizador para <xliff:g id="mimetype">%s</xliff:g>.</string>
   <string name="message_view_download_remainder">Transferir mensagem completa</string>
   <string name="message_view_sender_label">via %1$s</string>
@@ -239,6 +244,7 @@
   <string name="global_settings_confirm_menu_mark_all_read">Marcar todas as mensagens como lidas</string>
   <string name="global_settings_confirm_action_delete_notif">Eliminar (a partir da notificação)</string>
   <!--Title of the screen to configure swipe actions-->
+  <string name="general_settings_swipe_actions_title">Ações de deslize</string>
   <!--Name of the setting to configure the right swipe action-->
   <string name="general_settings_right_swipe_title">Deslizo para a direita</string>
   <!--Name of the setting to configure the left swipe action-->
@@ -246,9 +252,11 @@
   <!--The list item users select to not use a swipe action for a particular direction-->
   <string name="general_settings_swipe_action_none">Nenhuma</string>
   <!--Name of the swipe action to select/deselect a message-->
+  <string name="general_settings_swipe_action_toggle_selection">Seleção alternada</string>
   <!--Name of the swipe action to mark as message as read/unread-->
   <string name="general_settings_swipe_action_toggle_read">Marcar como lida/não-lida</string>
   <!--Name of the swipe action to add/remove a star-->
+  <string name="general_settings_swipe_action_toggle_star">Adicionar/remover estrela</string>
   <!--Name of the swipe action to archive a message-->
   <string name="general_settings_swipe_action_archive">Arquivo</string>
   <!--Name of the swipe action to delete a message-->
@@ -258,7 +266,10 @@
   <!--Name of the swipe action to move a message to another folder-->
   <string name="general_settings_swipe_action_move">Mover</string>
   <!--Title of the setting to specify the density of the message list-->
+  <string name="general_settings_message_list_density_title">Densidade</string>
+  <string name="general_settings_ui_density_compact">Compacto</string>
   <string name="general_settings_ui_density_default">Predefinição</string>
+  <string name="general_settings_ui_density_relaxed">Relaxado</string>
   <string name="global_settings_privacy_hide_useragent">Ocultar cliente de email</string>
   <string name="global_settings_privacy_hide_useragent_detail">Remove Mail User-Agent from mail headers</string>
   <string name="global_settings_privacy_hide_timezone">Ocultar fuso horário</string>
@@ -329,6 +340,7 @@
   <string name="account_setup_incoming_delete_policy_delete_label">Eliminar no servidor</string>
   <string name="account_setup_incoming_delete_policy_markread_label">Marcar como lido no servidor</string>
   <string name="account_setup_incoming_use_compression">Usar compressão</string>
+  <string name="account_setup_incoming_send_client_id">Enviar ID do client</string>
   <string name="account_setup_expunge_policy_label">Apagar mensagens eliminadas no servidor</string>
   <string name="account_setup_expunge_policy_immediately">Imediatamente</string>
   <string name="account_setup_expunge_policy_on_poll">Na verificação</string>
@@ -534,6 +546,7 @@
   <string name="folder_settings_folder_push_mode_normal">Sem Classe</string>
   <string name="folder_settings_folder_push_mode_first_class">1ª classe</string>
   <string name="folder_settings_folder_push_mode_second_class">2ª classe</string>
+  <string name="folder_settings_folder_push_mode_inherited">Igual à classe de sondagem</string>
   <string name="folder_settings_folder_notify_mode_label">Classe de notificação da pasta</string>
   <string name="folder_settings_folder_notify_mode_normal">Sem Classe</string>
   <string name="folder_settings_folder_notify_mode_first_class">1ª classe</string>
@@ -676,6 +689,7 @@
   <string name="animations_summary">Usar efeitos visuais exuberantes</string>
   <string name="volume_navigation_title">Navegação com os botões de volume na visualização de mensagens</string>
   <string name="show_unified_inbox_title">Mostrar caixa de entrada unificada</string>
+  <string name="show_starred_count_title">Mostrar contagem de estrelas</string>
   <string name="integrated_inbox_title">Caixa de entrada unificada</string>
   <string name="integrated_inbox_detail">Todas as mensagens em pastas unificadas</string>
   <string name="folder_settings_include_in_integrated_inbox_label">Unificar</string>
@@ -697,6 +711,7 @@
   <!--Displayed in the font size settings screen to configure the font size of the account name in the message view.-->
   <string name="font_size_message_view_account">Nome da conta</string>
   <string name="font_size_message_view_sender">Remetente</string>
+  <string name="font_size_message_view_recipients">Destinatários</string>
   <string name="font_size_message_view_subject">Assunto</string>
   <string name="font_size_message_view_date">Data e hora</string>
   <string name="font_size_message_view_content">Corpo da mensagem</string>
@@ -1053,10 +1068,15 @@ Pode manter esta mensagem e usá-la como uma cópia de segurança para a sua cha
   <!--Name of the swipe action to move a message. The ellipsis (…) indicates that there is another step (selecting a folder) before the action is performed. Try to keep it short.-->
   <string name="swipe_action_move">Mover…</string>
   <!--Name of setting to configure whether to show a "compose" floating action button on top of the message list-->
+  <string name="general_settings_show_compose_button_title">Mostrar botão de composição flutuante</string>
   <!--Displayed in the toolbar when there was an error loading the message list, e.g. because the folder no longer exists.-->
+  <string name="message_list_error_title">Erro</string>
   <!--Displayed instead of the message list when a folder couldn't be found, e.g. due to an outdated home screen shortcut.-->
+  <string name="message_list_error_folder_not_found">Pasta não encontrada</string>
   <!--Title of the toolbar that is displayed when the message details bottom sheet has been expanded-->
+  <string name="message_details_toolbar_title">Detalhes da mensagem</string>
   <!--Displayed when an email is missing the 'Date' header field and no date can be displayed in the message details bottom sheet.-->
+  <string name="message_details_missing_date">Cabeçalho \"Data\" em falta</string>
   <!--Title of the "From" section in the message details bottom sheet. This should probably be the same as the string 'recipient_from'.-->
   <string name="message_details_from_section_title">De</string>
   <!--Title of the "Sender" section in the message details bottom sheet. This refers to the 'Sender' header. Be careful with translations.-->
@@ -1070,11 +1090,17 @@ Pode manter esta mensagem e usá-la como uma cópia de segurança para a sua cha
   <!--Title of the "Bcc" section in the message details bottom sheet. This should probably be the same as the string 'recipient_bcc'.-->
   <string name="message_details_bcc_section_title">Bcc</string>
   <!--Displayed when loading the message details has failed-->
+  <string name="message_details_loading_error">Ocorreu um erro ao carregar os detalhes da mensagem.</string>
   <!--Name of the action to add a person to contacts. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+  <string name="action_add_to_contacts">Adicionar aos contactos</string>
   <!--Name of the action to compose a new message to a particular address. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+  <string name="action_compose_message_to">Compor mensagem para</string>
   <!--Name of the action to copy an email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+  <string name="action_copy_email_address">Copiar o endereço de email</string>
   <!--Name of the action to copy a name and email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+  <string name="action_copy_name_and_email_address">Copiar o nome e o endereço de email</string>
   <!--A user visible label for the email address copied to the clipboard-->
   <string name="clipboard_label_email_address">Endereço de email</string>
   <!--A user visible label for the name and email address copied to the clipboard-->
+  <string name="clipboard_label_name_and_email_address">Nome e endereço de email</string>
 </resources>
diff --git a/app/ui/legacy/src/main/res/values-ru/strings.xml b/app/ui/legacy/src/main/res/values-ru/strings.xml
index 71df738ab7f79921aa15db5746c968e867ac69eb..1ada3d8ab453a082da9a9113734a0fc2af223695 100644
--- a/app/ui/legacy/src/main/res/values-ru/strings.xml
+++ b/app/ui/legacy/src/main/res/values-ru/strings.xml
@@ -310,7 +310,6 @@
     <string name="account_setup_incoming_client_certificate_label">Сертификат клиента</string>
     <string name="account_setup_incoming_pop_server_label">Сервер POP3</string>
     <string name="account_setup_incoming_imap_server_label">Сервер IMAP</string>
-    <string name="account_setup_incoming_webdav_server_label">Сервер Exchange</string>
     <string name="account_setup_incoming_port_label">Порт</string>
     <string name="account_setup_incoming_security_label">Безопасность</string>
     <string name="account_setup_incoming_auth_type_label">Аутентификация</string>
@@ -336,9 +335,6 @@
     <string name="spam_folder_label">Папка спам</string>
     <string name="account_setup_incoming_subscribed_folders_only_label">Только подписанные папки</string>
     <string name="account_setup_auto_expand_folder">Автопереход в папку</string>
-    <string name="account_setup_incoming_webdav_path_prefix_label">Путь OWA</string>
-    <string name="account_setup_incoming_webdav_auth_path_label">Путь аутентификации</string>
-    <string name="account_setup_incoming_webdav_mailbox_path_label">Псевдоним ящика</string>
     <string name="account_setup_outgoing_title">Сервер исходящей почты</string>
     <string name="account_setup_outgoing_smtp_server_label">Сервер SMTP</string>
     <string name="account_setup_outgoing_port_label">Порт</string>
@@ -1015,6 +1011,12 @@
 Для настройки взаимного автошифрования на новом устройстве, следуйте инструкциям, отображаемым на новом устройстве.
 Это сообщение можно сохранить и использовать в качестве резервной копии своего секретного ключа. Запишите и надёжно сохраните пароль.
 </string>
+  <!--Title of the setting to specify the density of the message list-->
+  <string name="general_settings_message_list_density_title">Плотность</string>
+  <string name="general_settings_ui_density_compact">Компактная</string>
+  <string name="general_settings_ui_density_default">По умолчанию</string>
+  <string name="general_settings_ui_density_relaxed">Ослабленная</string>
+  <string name="account_setup_check_settings_title"/>
     <string name="ac_transfer_error_send">Сбой при отправке сообщения. Проверьте соединение с сетью и настройки сервера исходящей почты.</string>
     <string name="switch_on">Вкл</string>
     <string name="switch_off">Откл</string>
diff --git a/app/ui/legacy/src/main/res/values-zh-rTW/strings.xml b/app/ui/legacy/src/main/res/values-zh-rTW/strings.xml
index 1cf00686ce5c0d6b337c920ba9adc7657364470b..4cdaa0a57bfa16f42bba8c57e53890d624c1cca8 100644
--- a/app/ui/legacy/src/main/res/values-zh-rTW/strings.xml
+++ b/app/ui/legacy/src/main/res/values-zh-rTW/strings.xml
@@ -330,6 +330,7 @@
   <string name="account_setup_incoming_delete_policy_delete_label">立刻從伺服器上刪除</string>
   <string name="account_setup_incoming_delete_policy_markread_label">在伺服器上將郵件標記為已讀</string>
   <string name="account_setup_incoming_use_compression">使用壓縮</string>
+  <string name="account_setup_incoming_send_client_id">傳送客戶端 ID</string>
   <string name="account_setup_expunge_policy_label">抹除刪除的郵件</string>
   <string name="account_setup_expunge_policy_immediately">立刻</string>
   <string name="account_setup_expunge_policy_on_poll">接收郵件時</string>
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/activity/compose/RecipientLoaderTest.java b/app/ui/legacy/src/test/java/com/fsck/k9/activity/compose/RecipientLoaderTest.java
index 6d989455222af3f5161073fbd642e111f201626d..c16e444c89cd81222d9b2b6c78a6fbbcbe7614a9 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/activity/compose/RecipientLoaderTest.java
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/activity/compose/RecipientLoaderTest.java
@@ -49,8 +49,7 @@ public class RecipientLoaderTest extends RobolectricTest {
             ContactsContract.Contacts.STARRED
     };
     static final String[] PROJECTION_NICKNAME = {
-            ContactsContract.Data.CONTACT_ID,
-            ContactsContract.CommonDataKinds.Nickname.NAME
+            ContactsContract.Data.CONTACT_ID
     };
     static final String[] PROJECTION_CRYPTO_ADDRESSES = { "address", "uid_address" };
     static final String[] PROJECTION_CRYPTO_STATUS = { "address", "uid_key_status", "autocrypt_key_status" };
@@ -66,7 +65,7 @@ public class RecipientLoaderTest extends RobolectricTest {
     static final String[] CONTACT_WITH_NICKNAME_NOT_CONTACTED =
             new String[] { "0", "Eve_notContacted", "eve_notContacted", "eve_notContacted@host.com", TYPE, null, "2",
                     null, "0", "Eve", "0" };
-    static final String[] NICKNAME_NOT_CONTACTED = new String[] { "2", "Eves_Nickname_Bob" };
+    static final String[] NICKNAME_NOT_CONTACTED = new String[] { "2" };
 
     static final String QUERYSTRING = "querystring";
 
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/contacts/ContactLetterExtractorTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/contacts/ContactLetterExtractorTest.kt
index cc793c47fe53f58eabd90d2d49a4ec1260abffe1..6c302aa44830093daf090d79a1440b35337f51ef 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/contacts/ContactLetterExtractorTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/contacts/ContactLetterExtractorTest.kt
@@ -1,8 +1,9 @@
 package com.fsck.k9.contacts
 
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import com.fsck.k9.RobolectricTest
 import com.fsck.k9.mail.Address
-import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class ContactLetterExtractorTest : RobolectricTest() {
@@ -54,6 +55,6 @@ class ContactLetterExtractorTest : RobolectricTest() {
     }
 
     private fun assertExtractedLetterEquals(expected: String, address: String) {
-        assertEquals(expected, letterExtractor.extractContactLetter(Address(address)))
+        assertThat(letterExtractor.extractContactLetter(Address(address))).isEqualTo(expected)
     }
 }
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/message/PgpMessageBuilderTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/message/PgpMessageBuilderTest.kt
index 03e7ad1a3f932e9393c57a702c43ed86753bf0fc..f74368b333709d31c2906a080c99b3419bb962e1 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/message/PgpMessageBuilderTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/message/PgpMessageBuilderTest.kt
@@ -4,6 +4,17 @@ import android.app.Activity
 import android.app.PendingIntent
 import android.content.Intent
 import android.os.Parcelable
+import assertk.Assert
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.hasSize
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
+import assertk.assertions.isSameAs
 import com.fsck.k9.Account.QuoteStyle
 import com.fsck.k9.CoreResourceProvider
 import com.fsck.k9.Identity
@@ -15,29 +26,29 @@ import com.fsck.k9.autocrypt.AutocryptOpenPgpApiInteractor
 import com.fsck.k9.autocrypt.AutocryptOperations
 import com.fsck.k9.autocrypt.AutocryptOperationsHelper.assertMessageHasAutocryptHeader
 import com.fsck.k9.mail.Address
-import com.fsck.k9.mail.BodyPart
 import com.fsck.k9.mail.BoundaryGenerator
 import com.fsck.k9.mail.MessagingException
+import com.fsck.k9.mail.assertk.asBytes
+import com.fsck.k9.mail.assertk.asText
+import com.fsck.k9.mail.assertk.body
+import com.fsck.k9.mail.assertk.bodyPart
+import com.fsck.k9.mail.assertk.bodyParts
+import com.fsck.k9.mail.assertk.contentTransferEncoding
+import com.fsck.k9.mail.assertk.contentType
+import com.fsck.k9.mail.assertk.mimeType
+import com.fsck.k9.mail.assertk.parameter
+import com.fsck.k9.mail.assertk.value
 import com.fsck.k9.mail.internet.BinaryTempFileBody
 import com.fsck.k9.mail.internet.MessageIdGenerator
 import com.fsck.k9.mail.internet.MimeMessage
 import com.fsck.k9.mail.internet.MimeMultipart
-import com.fsck.k9.mail.internet.MimeUtility
 import com.fsck.k9.mail.internet.TextBody
 import com.fsck.k9.message.MessageBuilder.Callback
 import com.fsck.k9.message.quote.InsertableHtmlContent
 import com.fsck.k9.view.RecipientSelectView
-import java.io.ByteArrayOutputStream
-import java.io.IOException
 import java.io.OutputStream
 import java.util.Date
-import org.apache.commons.io.Charsets
-import org.apache.commons.io.IOUtils
 import org.apache.james.mime4j.util.MimeUtil
-import org.junit.Assert
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
 import org.koin.core.component.inject
@@ -143,7 +154,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
         verifyNoMoreInteractions(mockCallback)
 
         val message = captor.value
-        assertEquals("text/plain", message.mimeType)
+        assertThat(message.mimeType).isEqualTo("text/plain")
     }
 
     @Test
@@ -159,7 +170,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
 
         val message = captor.value
         assertMessageHasAutocryptHeader(message, SENDER_EMAIL, false, AUTOCRYPT_KEY_MATERIAL)
-        assertEquals(0, message.getHeader("Autocrypt-Draft-State").size)
+        assertThat(message.getHeader("Autocrypt-Draft-State")).isEmpty()
     }
 
     @Test
@@ -206,45 +217,32 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
         val expectedIntent = Intent(OpenPgpApi.ACTION_DETACHED_SIGN)
         expectedIntent.putExtra(OpenPgpApi.EXTRA_SIGN_KEY_ID, TEST_KEY_ID)
         expectedIntent.putExtra(OpenPgpApi.EXTRA_REQUEST_ASCII_ARMOR, true)
-        assertIntentEqualsActionAndExtras(expectedIntent, capturedApiIntent.value)
+        assertThat(capturedApiIntent.value).matches(expectedIntent)
 
         val captor = ArgumentCaptor.forClass(MimeMessage::class.java)
         verify(mockCallback).onMessageBuildSuccess(captor.capture(), eq(false))
         verifyNoMoreInteractions(mockCallback)
 
         val message = captor.value
-        Assert.assertEquals("message must be multipart/signed", "multipart/signed", message.mimeType)
-
-        val multipart = message.body as MimeMultipart
-        Assert.assertEquals("multipart/signed must consist of two parts", 2, multipart.count.toLong())
-
-        val contentBodyPart = multipart.getBodyPart(0)
-        Assert.assertEquals(
-            "first part must have content type text/plain",
-            "text/plain",
-            MimeUtility.getHeaderParameter(contentBodyPart.contentType, null),
-        )
-        assertTrue("signed message body must be TextBody", contentBodyPart.body is TextBody)
-        Assert.assertEquals(MimeUtil.ENC_QUOTED_PRINTABLE, (contentBodyPart.body as TextBody).encoding)
-        assertContentOfBodyPartEquals("content must match the message text", contentBodyPart, TEST_MESSAGE_TEXT)
-
-        val signatureBodyPart = multipart.getBodyPart(1)
-        val contentType = signatureBodyPart.contentType
-        Assert.assertEquals(
-            "second part must be pgp signature",
-            "application/pgp-signature",
-            MimeUtility.getHeaderParameter(contentType, null),
-        )
-        Assert.assertEquals(
-            "second part must be called signature.asc",
-            "signature.asc",
-            MimeUtility.getHeaderParameter(contentType, "name"),
-        )
-        assertContentOfBodyPartEquals(
-            "content must match the supplied detached signature",
-            signatureBodyPart,
-            byteArrayOf(1, 2, 3),
-        )
+        assertThat(message.mimeType).isEqualTo("multipart/signed")
+
+        assertThat(message.body).isInstanceOf<MimeMultipart>().all {
+            bodyParts().hasSize(2)
+            bodyPart(0).all {
+                contentType().value().isEqualTo("text/plain")
+                body().isInstanceOf<TextBody>().all {
+                    contentTransferEncoding().isEqualTo(MimeUtil.ENC_QUOTED_PRINTABLE)
+                    asText().isEqualTo(TEST_MESSAGE_TEXT)
+                }
+            }
+            bodyPart(1).all {
+                contentType().all {
+                    value().isEqualTo("application/pgp-signature")
+                    parameter("name").isEqualTo("signature.asc")
+                }
+                body().asBytes().isEqualTo(byteArrayOf(1, 2, 3))
+            }
+        }
 
         assertMessageHasAutocryptHeader(message, SENDER_EMAIL, false, AUTOCRYPT_KEY_MATERIAL)
     }
@@ -274,7 +272,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
         verifyNoMoreInteractions(mockCallback)
 
         val pendingIntent = captor.value
-        Assert.assertSame(pendingIntent, mockPendingIntent)
+        assertThat(pendingIntent).isSameAs(mockPendingIntent)
     }
 
     @Test
@@ -306,7 +304,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
             verifyNoMoreInteractions(mockCallback)
 
             returnedRequestCode = rcCaptor.value
-            Assert.assertSame(mockPendingIntent, piCaptor.value)
+            assertThat(piCaptor.value).isEqualTo(mockPendingIntent)
         }
 
         run {
@@ -367,7 +365,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
 
         val mimeMessage = buildMessage()
 
-        assertEquals("encrypt=no; ", mimeMessage.getHeader("Autocrypt-Draft-State").get(0))
+        assertThat(mimeMessage.getHeader("Autocrypt-Draft-State")).containsExactly("encrypt=no; ")
     }
 
     @Test
@@ -382,7 +380,8 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
 
         val mimeMessage = buildMessage()
 
-        assertEquals("encrypt=yes; _is-reply-to-encrypted=yes; ", mimeMessage.getHeader("Autocrypt-Draft-State").get(0))
+        assertThat(mimeMessage.getHeader("Autocrypt-Draft-State"))
+            .containsExactly("encrypt=yes; _is-reply-to-encrypted=yes; ")
     }
 
     @Test
@@ -394,7 +393,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
 
         val mimeMessage = buildMessage()
 
-        assertEquals("encrypt=yes; _by-choice=yes; ", mimeMessage.getHeader("Autocrypt-Draft-State").get(0))
+        assertThat(mimeMessage.getHeader("Autocrypt-Draft-State")).containsExactly("encrypt=yes; _by-choice=yes; ")
     }
 
     @Test
@@ -406,10 +405,8 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
 
         val mimeMessage = buildMessage()
 
-        assertEquals(
-            "encrypt=no; _sign-only=yes; _by-choice=yes; ",
-            mimeMessage.getHeader("Autocrypt-Draft-State").get(0),
-        )
+        assertThat(mimeMessage.getHeader("Autocrypt-Draft-State"))
+            .containsExactly("encrypt=no; _sign-only=yes; _by-choice=yes; ")
     }
 
     private fun buildMessage(): MimeMessage {
@@ -431,7 +428,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
         verify(mockCallback).onMessageBuildSuccess(mimeMessageCaptor.capture(), eq(true))
         verifyNoMoreInteractions(mockCallback)
 
-        assertNotNull(mimeMessageCaptor.value)
+        assertThat(mimeMessageCaptor.value).isNotNull()
         return mimeMessageCaptor.value
     }
 
@@ -552,7 +549,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
         expectedApiIntent.putExtra(OpenPgpApi.EXTRA_KEY_IDS, longArrayOf(TEST_KEY_ID))
         expectedApiIntent.putExtra(OpenPgpApi.EXTRA_REQUEST_ASCII_ARMOR, true)
         expectedApiIntent.putExtra(OpenPgpApi.EXTRA_USER_IDS, cryptoStatus.recipientAddressesAsArray)
-        assertIntentEqualsActionAndExtras(expectedApiIntent, capturedApiIntent.value)
+        assertThat(capturedApiIntent.value).matches(expectedApiIntent)
 
         val captor = ArgumentCaptor.forClass(MimeMessage::class.java)
         verify(mockCallback).onMessageBuildSuccess(captor.capture(), eq(false))
@@ -560,34 +557,24 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
 
         val message = captor.value
 
-        Assert.assertEquals("message must be multipart/encrypted", "multipart/encrypted", message.mimeType)
-
-        val multipart = message.body as MimeMultipart
-        Assert.assertEquals("multipart/encrypted must consist of two parts", 2, multipart.count.toLong())
-
-        val dummyBodyPart = multipart.getBodyPart(0)
-        Assert.assertEquals(
-            "first part must be pgp encrypted dummy part",
-            "application/pgp-encrypted",
-            dummyBodyPart.contentType,
-        )
-        assertContentOfBodyPartEquals(
-            "content must match the supplied detached signature",
-            dummyBodyPart,
-            "Version: 1",
-        )
-
-        val encryptedBodyPart = multipart.getBodyPart(1)
-        Assert.assertEquals(
-            "second part must be octet-stream of encrypted data",
-            "application/octet-stream; name=\"encrypted.asc\"",
-            encryptedBodyPart.contentType,
-        )
-        assertTrue(
-            "message body must be BinaryTempFileBody",
-            encryptedBodyPart.body is BinaryTempFileBody,
-        )
-        Assert.assertEquals(MimeUtil.ENC_7BIT, (encryptedBodyPart.body as BinaryTempFileBody).encoding)
+        assertThat(message).all {
+            mimeType().isEqualTo("multipart/encrypted")
+            body().isInstanceOf<MimeMultipart>().all {
+                bodyParts().hasSize(2)
+                bodyPart(0).all {
+                    contentType().value().isEqualTo("application/pgp-encrypted")
+                    body().asText().isEqualTo("Version: 1")
+                }
+                bodyPart(1).all {
+                    contentType().all {
+                        value().isEqualTo("application/octet-stream")
+                        parameter("name").isEqualTo("encrypted.asc")
+                    }
+                    body().isInstanceOf<BinaryTempFileBody>()
+                        .contentTransferEncoding().isEqualTo(MimeUtil.ENC_7BIT)
+                }
+            }
+        }
 
         assertMessageHasAutocryptHeader(message, SENDER_EMAIL, false, AUTOCRYPT_KEY_MATERIAL)
     }
@@ -623,16 +610,18 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
         expectedApiIntent.putExtra(OpenPgpApi.EXTRA_KEY_IDS, longArrayOf(TEST_KEY_ID))
         expectedApiIntent.putExtra(OpenPgpApi.EXTRA_REQUEST_ASCII_ARMOR, true)
         expectedApiIntent.putExtra(OpenPgpApi.EXTRA_USER_IDS, cryptoStatus.recipientAddressesAsArray)
-        assertIntentEqualsActionAndExtras(expectedApiIntent, capturedApiIntent.value)
+        assertThat(capturedApiIntent.value).matches(expectedApiIntent)
 
         val captor = ArgumentCaptor.forClass(MimeMessage::class.java)
         verify(mockCallback).onMessageBuildSuccess(captor.capture(), eq(false))
         verifyNoMoreInteractions(mockCallback)
 
         val message = captor.value
-        Assert.assertEquals("text/plain", message.mimeType)
-        assertTrue("message body must be BinaryTempFileBody", message.body is BinaryTempFileBody)
-        Assert.assertEquals(MimeUtil.ENC_7BIT, (message.body as BinaryTempFileBody).encoding)
+        assertThat(message).all {
+            mimeType().isEqualTo("text/plain")
+            body().isInstanceOf<BinaryTempFileBody>()
+                .contentTransferEncoding().isEqualTo(MimeUtil.ENC_7BIT)
+        }
 
         assertMessageHasAutocryptHeader(message, SENDER_EMAIL, false, AUTOCRYPT_KEY_MATERIAL)
     }
@@ -667,14 +656,14 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
         val expectedApiIntent = Intent(OpenPgpApi.ACTION_SIGN)
         expectedApiIntent.putExtra(OpenPgpApi.EXTRA_SIGN_KEY_ID, TEST_KEY_ID)
         expectedApiIntent.putExtra(OpenPgpApi.EXTRA_REQUEST_ASCII_ARMOR, true)
-        assertIntentEqualsActionAndExtras(expectedApiIntent, capturedApiIntent.value)
+        assertThat(capturedApiIntent.value).matches(expectedApiIntent)
 
         val captor = ArgumentCaptor.forClass(MimeMessage::class.java)
         verify(mockCallback).onMessageBuildSuccess(captor.capture(), eq(false))
         verifyNoMoreInteractions(mockCallback)
 
         val message = captor.value
-        Assert.assertEquals("message must be text/plain", "text/plain", message.mimeType)
+        assertThat(message.mimeType).isEqualTo("text/plain")
 
         assertMessageHasAutocryptHeader(message, SENDER_EMAIL, false, AUTOCRYPT_KEY_MATERIAL)
     }
@@ -742,7 +731,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
         verifyNoMoreInteractions(mockCallback)
 
         val message = captor.value
-        Assert.assertEquals("text/plain", message.mimeType)
+        assertThat(message.mimeType).isEqualTo("text/plain")
     }
 
     @Test
@@ -820,58 +809,28 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
             return builder
         }
 
-        private fun assertContentOfBodyPartEquals(reason: String, signatureBodyPart: BodyPart, expected: ByteArray) {
-            try {
-                val bos = ByteArrayOutputStream()
-                signatureBodyPart.body.writeTo(bos)
-                Assert.assertArrayEquals(reason, expected, bos.toByteArray())
-            } catch (e: IOException) {
-                Assert.fail()
-            } catch (e: MessagingException) {
-                Assert.fail()
-            }
-        }
-
-        private fun assertContentOfBodyPartEquals(reason: String, signatureBodyPart: BodyPart, expected: String) {
-            try {
-                val bos = ByteArrayOutputStream()
-                val inputStream = MimeUtility.decodeBody(signatureBodyPart.body)
-                IOUtils.copy(inputStream, bos)
-                Assert.assertEquals(reason, expected, String(bos.toByteArray(), Charsets.UTF_8))
-            } catch (e: IOException) {
-                Assert.fail()
-            } catch (e: MessagingException) {
-                Assert.fail()
-            }
-        }
+        private fun Assert<Intent>.matches(expected: Intent) = given { actual ->
+            assertThat(actual.action).isEqualTo(expected.action)
 
-        private fun assertIntentEqualsActionAndExtras(expected: Intent, actual: Intent) {
-            Assert.assertEquals(expected.action, actual.action)
-
-            val expectedExtras = expected.extras
-            val intentExtras = actual.extras
-
-            if (expectedExtras!!.size() != intentExtras!!.size()) {
-                Assert.assertEquals(expectedExtras.size().toLong(), intentExtras.size().toLong())
-            }
+            val expectedExtras = checkNotNull(expected.extras)
+            val intentExtras = checkNotNull(actual.extras)
+            assertThat(intentExtras.size()).isEqualTo(expectedExtras.size())
 
             for (key in expectedExtras.keySet()) {
+                val name = "extra[$key]"
                 val intentExtra = intentExtras.get(key)
                 val expectedExtra = expectedExtras.get(key)
-                if (intentExtra == null) {
-                    if (expectedExtra == null) {
-                        continue
-                    }
-                    Assert.fail("found null for an expected non-null extra: $key")
-                }
-                if (intentExtra is LongArray) {
-                    Assert.assertArrayEquals("error in $key", expectedExtra as LongArray, intentExtra)
-                } else if (intentExtra is Array<*>) {
-                    Assert.assertArrayEquals("error in $key", expectedExtra as Array<*>, intentExtra)
+
+                if (expectedExtra == null) {
+                    assertThat(intentExtra, name).isNull()
                 } else {
-                    if (intentExtra != expectedExtra) {
-                        Assert.assertEquals("error in $key", expectedExtra, intentExtra)
-                    }
+                    assertThat(intentExtra, name).isNotNull()
+                }
+
+                when (intentExtra) {
+                    is LongArray -> assertThat(intentExtra, name).isEqualTo(expectedExtra as LongArray)
+                    is Array<*> -> assertThat(intentExtra as Array<Any?>, name).isEqualTo(expectedExtra as Array<Any?>)
+                    else -> assertThat(intentExtra, name).isEqualTo(expectedExtra)
                 }
             }
         }
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/ui/K9DrawerTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/ui/K9DrawerTest.kt
index 7db67cbf5b769df8f29b244b684ca494400b31e3..f110a577c1a4f1b645697f980320904e352f9d8c 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/ui/K9DrawerTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/ui/K9DrawerTest.kt
@@ -1,8 +1,10 @@
 package com.fsck.k9.ui
 
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.size
 import com.fsck.k9.RobolectricTest
 import com.fsck.k9.core.R
-import org.junit.Assert.assertEquals
 import org.junit.Test
 import org.robolectric.RuntimeEnvironment
 
@@ -14,6 +16,6 @@ class K9DrawerTest : RobolectricTest() {
         val lightColors = resources.getIntArray(R.array.account_colors)
         val darkColors = resources.getIntArray(R.array.drawer_account_accent_color_dark_theme)
 
-        assertEquals(lightColors.size, darkColors.size)
+        assertThat(darkColors).size().isEqualTo(lightColors.size)
     }
 }
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/ui/helper/RelativeDateTimeFormatterTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/ui/helper/RelativeDateTimeFormatterTest.kt
index f281d902e1c185f9bfb3464c19af626af16bdc13..c4e3f24a192f13afd20e05d55b52b016216b05e0 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/ui/helper/RelativeDateTimeFormatterTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/ui/helper/RelativeDateTimeFormatterTest.kt
@@ -3,13 +3,14 @@ package com.fsck.k9.ui.helper
 import android.os.Build
 import android.os.SystemClock
 import app.k9mail.core.testing.TestClock
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import com.fsck.k9.RobolectricTest
 import java.time.LocalDate
 import java.time.LocalDateTime
 import java.time.ZoneId
 import java.util.TimeZone
 import kotlinx.datetime.Instant
-import org.junit.Assert.assertEquals
 import org.junit.Before
 import org.junit.Test
 import org.robolectric.RuntimeEnvironment
@@ -39,7 +40,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("May 18", displayDate)
+        assertThat(displayDate).isEqualTo("May 18")
     }
 
     @Test
@@ -49,7 +50,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("3:41 PM", displayDate)
+        assertThat(displayDate).isEqualTo("3:41 PM")
     }
 
     @Test
@@ -59,7 +60,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("9:42 AM", displayDate)
+        assertThat(displayDate).isEqualTo("9:42 AM")
     }
 
     @Test
@@ -69,7 +70,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("Sat", displayDate)
+        assertThat(displayDate).isEqualTo("Sat")
     }
 
     @Test
@@ -79,7 +80,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("Mon", displayDate)
+        assertThat(displayDate).isEqualTo("Mon")
     }
 
     @Test
@@ -89,7 +90,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("May 10", displayDate)
+        assertThat(displayDate).isEqualTo("May 10")
     }
 
     @Test
@@ -99,7 +100,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("May 10", displayDate)
+        assertThat(displayDate).isEqualTo("May 10")
     }
 
     @Test
@@ -109,7 +110,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("Jan 1", displayDate)
+        assertThat(displayDate).isEqualTo("Jan 1")
     }
 
     @Test
@@ -119,7 +120,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("12/31/2019", displayDate)
+        assertThat(displayDate).isEqualTo("12/31/2019")
     }
 
     private fun setClockTo(time: String) {
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/ui/helper/SizeFormatterTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/ui/helper/SizeFormatterTest.kt
index 9af9595784f15e68d2254bf6a647ea3fd1cf94ac..319b2a071d0383798c65c5da97891a3ddbb6973d 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/ui/helper/SizeFormatterTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/ui/helper/SizeFormatterTest.kt
@@ -1,7 +1,8 @@
 package com.fsck.k9.ui.helper
 
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import com.fsck.k9.RobolectricTest
-import org.junit.Assert.assertEquals
 import org.junit.Test
 import org.robolectric.RuntimeEnvironment
 import org.robolectric.annotation.Config
@@ -12,46 +13,46 @@ class SizeFormatterTest : RobolectricTest() {
 
     @Test
     fun bytes_lower_bound() {
-        assertEquals("0 B", sizeFormatter.formatSize(0))
+        assertThat(sizeFormatter.formatSize(0)).isEqualTo("0 B")
     }
 
     @Test
     fun bytes_upper_bound() {
-        assertEquals("999 B", sizeFormatter.formatSize(999))
+        assertThat(sizeFormatter.formatSize(999)).isEqualTo("999 B")
     }
 
     @Test
     fun kilobytes_lower_bound() {
-        assertEquals("1.0 kB", sizeFormatter.formatSize(1000))
+        assertThat(sizeFormatter.formatSize(1000)).isEqualTo("1.0 kB")
     }
 
     @Test
     fun kilobytes_upper_bound() {
-        assertEquals("999.9 kB", sizeFormatter.formatSize(999_949))
+        assertThat(sizeFormatter.formatSize(999_949)).isEqualTo("999.9 kB")
     }
 
     @Test
     fun megabytes_lower_bound() {
-        assertEquals("1.0 MB", sizeFormatter.formatSize(999_950))
+        assertThat(sizeFormatter.formatSize(999_950)).isEqualTo("1.0 MB")
     }
 
     @Test
     fun megabytes_upper_bound() {
-        assertEquals("999.9 MB", sizeFormatter.formatSize(999_949_999))
+        assertThat(sizeFormatter.formatSize(999_949_999)).isEqualTo("999.9 MB")
     }
 
     @Test
     fun gigabytes_lower_bound() {
-        assertEquals("1.0 GB", sizeFormatter.formatSize(999_950_000))
+        assertThat(sizeFormatter.formatSize(999_950_000)).isEqualTo("1.0 GB")
     }
 
     @Test
     fun gigabytes_2() {
-        assertEquals("2.0 GB", sizeFormatter.formatSize(2_000_000_000L))
+        assertThat(sizeFormatter.formatSize(2_000_000_000L)).isEqualTo("2.0 GB")
     }
 
     @Test
     fun gigabytes_2000() {
-        assertEquals("2000.0 GB", sizeFormatter.formatSize(2_000_000_000_000L))
+        assertThat(sizeFormatter.formatSize(2_000_000_000_000L)).isEqualTo("2000.0 GB")
     }
 }
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagedetails/MessageDetailsParticipantFormatterTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagedetails/MessageDetailsParticipantFormatterTest.kt
index 6bba916c647bc92829ec3630e04a658fec76fedc..b90a318d35c3d5442fe0cc4d5a52d07109f191eb 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagedetails/MessageDetailsParticipantFormatterTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagedetails/MessageDetailsParticipantFormatterTest.kt
@@ -124,7 +124,7 @@ class MessageDetailsParticipantFormatterTest : RobolectricTest() {
         val displayName = participantFormatter.getDisplayName(Address("user1@domain.example"), account)
 
         assertThat(displayName.toString()).isEqualTo("Contact One")
-        assertThat(displayName).isNotNull().isInstanceOf(Spannable::class.java)
+        assertThat(displayName).isNotNull().isInstanceOf<Spannable>()
         val spans = (displayName as Spannable).getSpans<ForegroundColorSpan>(0, displayName.length)
         assertThat(spans.map { it.foregroundColor }).containsExactly(Color.RED)
     }
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagelist/MessageListAdapterTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagelist/MessageListAdapterTest.kt
index e3018c8d2b6a814764ba1d5916e1bd6a8776d16f..79c1cf0b6c5350c517cb0350225e589345f3c62a 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagelist/MessageListAdapterTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagelist/MessageListAdapterTest.kt
@@ -12,6 +12,11 @@ import androidx.appcompat.app.AppCompatActivity
 import androidx.core.view.isGone
 import androidx.core.view.isVisible
 import app.k9mail.core.testing.TestClock
+import assertk.Assert
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNull
+import assertk.assertions.support.expected
 import com.fsck.k9.Account
 import com.fsck.k9.FontSizes
 import com.fsck.k9.FontSizes.FONT_DEFAULT
@@ -23,10 +28,6 @@ import com.fsck.k9.mail.Address
 import com.fsck.k9.textString
 import com.fsck.k9.ui.R
 import com.fsck.k9.ui.helper.RelativeDateTimeFormatter
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
 import org.junit.Test
 import org.mockito.kotlin.mock
 import org.robolectric.Robolectric
@@ -38,7 +39,7 @@ private const val DATE_DEFAULT_FONT_SIZE = 14f
 
 class MessageListAdapterTest : RobolectricTest() {
     val activity = Robolectric.buildActivity(AppCompatActivity::class.java).create().get()
-    val context: Context = ContextThemeWrapper(activity, R.style.Theme_K9_Light)
+    val context: Context = ContextThemeWrapper(activity, R.style.Theme_K9_DayNight)
 
     val contactsPictureLoader: ContactPictureLoader = mock()
     val listItemListener: MessageListItemActionListener = mock()
@@ -49,7 +50,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertTrue(view.accountChipView.isVisible)
+        assertThat(view.accountChipView).isVisible()
     }
 
     @Test
@@ -58,7 +59,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertTrue(view.accountChipView.isGone)
+        assertThat(view.accountChipView).isGone()
     }
 
     @Test
@@ -67,7 +68,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertTrue(view.starView.isGone)
+        assertThat(view.starView).isGone()
     }
 
     @Test
@@ -76,7 +77,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertTrue(view.starView.isVisible)
+        assertThat(view.starView).isVisible()
     }
 
     @Test
@@ -86,7 +87,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertTrue(view.starView.isSelected)
+        assertThat(view.starView).isSelected()
     }
 
     @Test
@@ -96,7 +97,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertFalse(view.starView.isSelected)
+        assertThat(view.starView).isNotSelected()
     }
 
     @Test
@@ -106,7 +107,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertTrue(view.threadCountView.isGone)
+        assertThat(view.threadCountView).isGone()
     }
 
     @Test
@@ -116,8 +117,8 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertTrue(view.threadCountView.isVisible)
-        assertEquals("13", view.threadCountView.textString)
+        assertThat(view.threadCountView).isVisible()
+        assertThat(view.threadCountView.textString).isEqualTo("13")
     }
 
     @Test
@@ -127,7 +128,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertEquals("Subject", view.firstLineView.textString)
+        assertThat(view.firstLineView.textString).isEqualTo("Subject")
     }
 
     @Test
@@ -137,7 +138,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertEquals("Display Name", view.firstLineView.textString)
+        assertThat(view.firstLineView.textString).isEqualTo("Display Name")
     }
 
     @Test
@@ -147,7 +148,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertEquals("Display Name", view.secondLineView.textString)
+        assertThat(view.secondLineView.textString).isEqualTo("Display Name")
     }
 
     @Test
@@ -157,7 +158,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertEquals(secondLine("Display Name", "Preview"), view.secondLineView.textString)
+        assertThat(view.secondLineView.textString).isEqualTo(secondLine("Display Name", "Preview"))
     }
 
     @Test
@@ -167,7 +168,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertEquals("Subject", view.secondLineView.textString)
+        assertThat(view.secondLineView.textString).isEqualTo("Subject")
     }
 
     @Test
@@ -177,7 +178,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertEquals(secondLine("Subject", "Preview"), view.secondLineView.textString)
+        assertThat(view.secondLineView.textString).isEqualTo(secondLine("Subject", "Preview"))
     }
 
     @Test
@@ -187,7 +188,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertTrue(view.firstLineView.containsNoSubjectIndicator())
+        assertThat(view.firstLineView.textString).isMissingSubjectText()
     }
 
     @Test
@@ -197,7 +198,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertTrue(view.firstLineView.containsNoSubjectIndicator())
+        assertThat(view.firstLineView.textString).isMissingSubjectText()
     }
 
     @Test
@@ -207,7 +208,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertTrue(view.attachmentCountView.isGone)
+        assertThat(view.attachmentCountView).isGone()
     }
 
     @Test
@@ -217,7 +218,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertTrue(view.attachmentCountView.isVisible)
+        assertThat(view.attachmentCountView).isVisible()
     }
 
     @Test
@@ -229,7 +230,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(FIRST_LINE_DEFAULT_FONT_SIZE, view.firstLineView.textSize)
+        assertThat(view.firstLineView.textSize).isEqualTo(FIRST_LINE_DEFAULT_FONT_SIZE)
     }
 
     @Test
@@ -241,7 +242,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(22f, view.firstLineView.textSize)
+        assertThat(view.firstLineView.textSize).isEqualTo(22f)
     }
 
     @Test
@@ -253,7 +254,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(FIRST_LINE_DEFAULT_FONT_SIZE, view.firstLineView.textSize)
+        assertThat(view.firstLineView.textSize).isEqualTo(FIRST_LINE_DEFAULT_FONT_SIZE)
     }
 
     @Test
@@ -265,7 +266,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(22f, view.firstLineView.textSize)
+        assertThat(view.firstLineView.textSize).isEqualTo(22f)
     }
 
     @Test
@@ -277,7 +278,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertNull(view.secondLineView.getFirstAbsoluteSizeSpanValueOrNull())
+        assertThat(view.secondLineView.text).firstAbsoluteSizeSpanValue().isNull()
     }
 
     @Test
@@ -289,7 +290,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(22, view.secondLineView.getFirstAbsoluteSizeSpanValueOrNull())
+        assertThat(view.secondLineView.text).firstAbsoluteSizeSpanValue().isEqualTo(22)
     }
 
     @Test
@@ -301,7 +302,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertNull(view.secondLineView.getFirstAbsoluteSizeSpanValueOrNull())
+        assertThat(view.secondLineView.text).firstAbsoluteSizeSpanValue().isNull()
     }
 
     @Test
@@ -313,7 +314,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(22, view.secondLineView.getFirstAbsoluteSizeSpanValueOrNull())
+        assertThat(view.secondLineView.text).firstAbsoluteSizeSpanValue().isEqualTo(22)
     }
 
     @Test
@@ -322,7 +323,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(DATE_DEFAULT_FONT_SIZE, view.dateView.textSize)
+        assertThat(view.dateView.textSize).isEqualTo(DATE_DEFAULT_FONT_SIZE)
     }
 
     @Test
@@ -331,7 +332,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(22f, view.dateView.textSize)
+        assertThat(view.dateView.textSize).isEqualTo(22f)
     }
 
     @Test
@@ -343,7 +344,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(SECOND_LINE_DEFAULT_FONT_SIZE, view.secondLineView.textSize)
+        assertThat(view.secondLineView.textSize).isEqualTo(SECOND_LINE_DEFAULT_FONT_SIZE)
     }
 
     @Test
@@ -355,7 +356,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(22f, view.secondLineView.textSize)
+        assertThat(view.secondLineView.textSize).isEqualTo(22f)
     }
 
     fun createFontSizes(
@@ -467,10 +468,36 @@ class MessageListAdapterTest : RobolectricTest() {
     val View.attachmentCountView: View get() = findViewById(R.id.attachment)
     val View.dateView: TextView get() = findViewById(R.id.date)
 
-    fun TextView.containsNoSubjectIndicator() = textString.contains(context.getString(R.string.general_no_subject))
+    private fun Assert<View>.isVisible() = given { actual ->
+        if (!actual.isVisible) {
+            expected("View to be visible ($actual)")
+        }
+    }
+
+    private fun Assert<View>.isGone() = given { actual ->
+        if (!actual.isGone) {
+            expected("View to be gone ($actual)")
+        }
+    }
+
+    private fun Assert<View>.isSelected() = given { actual ->
+        if (!actual.isSelected) {
+            expected("View to be selected ($actual)")
+        }
+    }
+
+    private fun Assert<View>.isNotSelected() = given { actual ->
+        if (actual.isSelected) {
+            expected("View to not be selected ($actual)")
+        }
+    }
+
+    private fun Assert<CharSequence>.isMissingSubjectText() {
+        isEqualTo(context.getString(R.string.general_no_subject))
+    }
 
-    fun TextView.getFirstAbsoluteSizeSpanValueOrNull(): Int? {
+    private fun Assert<CharSequence>.firstAbsoluteSizeSpanValue() = transform { text ->
         val spans = (text as Spannable).getSpans(0, text.length, AbsoluteSizeSpan::class.java)
-        return spans.firstOrNull()?.size
+        spans.firstOrNull()?.size
     }
 }
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/DisplayRecipientsExtractorTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/DisplayRecipientsExtractorTest.kt
index 1ed5ec706585c1389cb286bea0e52665f2cdd0e7..3ede76992d2d73be9cb5f2980fd83fdaba3996dd 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/DisplayRecipientsExtractorTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/DisplayRecipientsExtractorTest.kt
@@ -19,13 +19,16 @@ class DisplayRecipientsExtractorTest {
 
     private val recipientFormatter = object : MessageViewRecipientFormatter {
         override fun getDisplayName(address: Address, account: Account): CharSequence {
-            return when (address.address) {
-                IDENTITY_ADDRESS -> "me"
-                "user1@domain.example" -> "Contact One"
-                "user2@domain.example" -> "Contact Two"
-                "user3@domain.example" -> "Contact Three"
-                "user4@domain.example" -> "Contact Four"
-                else -> address.personal ?: address.address
+            return if (account.isAnIdentity(address)) {
+                "me"
+            } else {
+                when (address.address) {
+                    "user1@domain.example" -> "Contact One"
+                    "user2@domain.example" -> "Contact Two"
+                    "user3@domain.example" -> "Contact Three"
+                    "user4@domain.example" -> "Contact Four"
+                    else -> address.personal ?: address.address
+                }
             }
         }
     }
@@ -48,6 +51,45 @@ class DisplayRecipientsExtractorTest {
         )
     }
 
+    @Test
+    fun `single recipient is identity address with different local part case`() {
+        val message = buildMessage {
+            header("To", "Test User <ME@domain.example>")
+        }
+
+        val displayRecipients = displayRecipientsExtractor.extractDisplayRecipients(message, account)
+
+        assertThat(displayRecipients).isEqualTo(
+            DisplayRecipients(recipientNames = listOf("me"), numberOfRecipients = 1),
+        )
+    }
+
+    @Test
+    fun `single recipient is identity address with different domain case`() {
+        val message = buildMessage {
+            header("To", "Test User <me@DOMAIN.EXAMPLE>")
+        }
+
+        val displayRecipients = displayRecipientsExtractor.extractDisplayRecipients(message, account)
+
+        assertThat(displayRecipients).isEqualTo(
+            DisplayRecipients(recipientNames = listOf("me"), numberOfRecipients = 1),
+        )
+    }
+
+    @Test
+    fun `single recipient is identity address with different local part and domain case`() {
+        val message = buildMessage {
+            header("To", "Test User <ME@DOMAIN.EXAMPLE>")
+        }
+
+        val displayRecipients = displayRecipientsExtractor.extractDisplayRecipients(message, account)
+
+        assertThat(displayRecipients).isEqualTo(
+            DisplayRecipients(recipientNames = listOf("me"), numberOfRecipients = 1),
+        )
+    }
+
     @Test
     fun `single recipient is a contact`() {
         val message = buildMessage {
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/MessageViewRecipientFormatterTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/MessageViewRecipientFormatterTest.kt
index c75099ded658f840182a67b5b7003c20d8be5ec7..77e3242187a548818da5dcaecd4a56190221b186 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/MessageViewRecipientFormatterTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/MessageViewRecipientFormatterTest.kt
@@ -133,7 +133,7 @@ class MessageViewRecipientFormatterTest : RobolectricTest() {
         val displayName = recipientFormatter.getDisplayName(Address("user1@domain.example"), account)
 
         assertThat(displayName.toString()).isEqualTo("Contact One")
-        assertThat(displayName).isInstanceOf(Spannable::class.java)
+        assertThat(displayName).isInstanceOf<Spannable>()
         val spans = (displayName as Spannable).getSpans<ForegroundColorSpan>(0, displayName.length)
         assertThat(spans.map { it.foregroundColor }).containsExactly(Color.RED)
     }
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/view/UserInputEmailAddressParserTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/view/UserInputEmailAddressParserTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f1ecb2d60530d77d91323eb8f795dc6a36c867dd
--- /dev/null
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/view/UserInputEmailAddressParserTest.kt
@@ -0,0 +1,153 @@
+package com.fsck.k9.view
+
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.isEmpty
+import assertk.assertions.isInstanceOf
+import com.fsck.k9.mail.Address
+import kotlin.test.Ignore
+import kotlin.test.Test
+
+class UserInputEmailAddressParserTest {
+    private val parser = UserInputEmailAddressParser()
+
+    @Test
+    fun `plain email address`() {
+        val addresses = parser.parse("user@domain.example")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example"))
+    }
+
+    @Test
+    fun `email address followed by space`() {
+        val addresses = parser.parse("user@domain.example ")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example"))
+    }
+
+    @Test
+    fun `email address in angle brackets`() {
+        val addresses = parser.parse("<user@domain.example>")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example"))
+    }
+
+    @Test
+    fun `simple name and address`() {
+        val addresses = parser.parse("Name <user@domain.example>")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example", "Name"))
+    }
+
+    @Test
+    fun `name with quoted string and address`() {
+        val addresses = parser.parse("\"Name\" <user@domain.example>")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example", "Name"))
+    }
+
+    @Test
+    fun `name with multiple words and address`() {
+        val addresses = parser.parse("Firstname Lastname <user@domain.example>")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example", "Firstname Lastname"))
+    }
+
+    @Test
+    fun `name with non-ASCII characters and address`() {
+        val addresses = parser.parse("Käthe Gehäusegröße <user@domain.example>")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example", "Käthe Gehäusegröße"))
+    }
+
+    @Test
+    fun `address with non-ASCII character in local part`() {
+        assertFailure {
+            parser.parse("müller@domain.example")
+        }.isInstanceOf<NonAsciiEmailAddressException>()
+    }
+
+    @Test
+    fun `address with non-ASCII character in domain part`() {
+        assertFailure {
+            parser.parse("user@dömain.example")
+        }.isInstanceOf<NonAsciiEmailAddressException>()
+    }
+
+    @Test
+    fun `multiple addresses separated by comma`() {
+        val addresses = parser.parse("one@domain.example,<two@domain.example>")
+
+        assertThat(addresses).containsExactly(
+            Address("one@domain.example"),
+            Address("two@domain.example"),
+        )
+    }
+
+    @Test
+    @Ignore("Currently not supported")
+    fun `multiple addresses separated by space`() {
+        val addresses = parser.parse("one@domain.example two@domain.example")
+
+        assertThat(addresses).containsExactly(
+            Address("one@domain.example"),
+            Address("two@domain.example"),
+        )
+    }
+
+    @Test
+    fun `multiple addresses in angle brackets separated by space`() {
+        val addresses = parser.parse("<one@domain.example>, <two@domain.example>")
+
+        assertThat(addresses).containsExactly(
+            Address("one@domain.example"),
+            Address("two@domain.example"),
+        )
+    }
+
+    @Test
+    fun `incomplete address should not return a result`() {
+        val addresses = parser.parse("user")
+
+        assertThat(addresses).isEmpty()
+    }
+
+    @Test
+    fun `incomplete address ending in @ should not return a result`() {
+        val addresses = parser.parse("user@")
+
+        assertThat(addresses).isEmpty()
+    }
+
+    @Test
+    fun `name and incomplete address should not return a result`() {
+        val addresses = parser.parse("Name <user")
+
+        assertThat(addresses).isEmpty()
+    }
+
+    @Test
+    @Ignore("Currently not supported")
+    fun `name followed by address not in angle brackets`() {
+        val addresses = parser.parse("Firstname Lastname user@domain.example")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example", "Firstname LastName"))
+    }
+
+    @Test
+    @Ignore("Currently not supported")
+    fun `name containing parenthesis`() {
+        val addresses = parser.parse("Firstname (Nickname) Lastname <user@domain.example>")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example", "Firstname (Nickname) LastName"))
+    }
+
+    @Test
+    @Ignore("Currently not supported")
+    fun `name containing double quotes in the middle`() {
+        val addresses = parser.parse("Firstname \"Nickname\" Lastname <user@domain.example>")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example", "Firstname \"Nickname\" LastName"))
+    }
+}
diff --git a/app/ui/message-list-widget/src/main/java/app/k9mail/ui/widget/list/MessageListWidgetManager.kt b/app/ui/message-list-widget/src/main/java/app/k9mail/ui/widget/list/MessageListWidgetManager.kt
index 6eab9f1d38ba46dd28c96cf5ed02cbcc89faa7be..3335c482cdc2de48b675d513b3509eeca6be07b3 100644
--- a/app/ui/message-list-widget/src/main/java/app/k9mail/ui/widget/list/MessageListWidgetManager.kt
+++ b/app/ui/message-list-widget/src/main/java/app/k9mail/ui/widget/list/MessageListWidgetManager.kt
@@ -14,7 +14,7 @@ class MessageListWidgetManager(
     private val messageListRepository: MessageListRepository,
     private val config: MessageListWidgetConfig,
 ) {
-    private lateinit var appWidgetManager: AppWidgetManager
+    private var appWidgetManager: AppWidgetManager? = null
 
     private var listenerAdded = false
     private val listener = MessageListChangedListener {
@@ -23,6 +23,9 @@ class MessageListWidgetManager(
 
     fun init() {
         appWidgetManager = AppWidgetManager.getInstance(context)
+        if (appWidgetManager == null) {
+            Timber.v("Message list widget is not supported on this device.")
+        }
 
         if (isAtLeastOneMessageListWidgetAdded()) {
             resetMessageListWidget()
@@ -83,7 +86,7 @@ class MessageListWidgetManager(
     private fun triggerMessageListWidgetUpdate() {
         val appWidgetIds = getAppWidgetIds()
         if (appWidgetIds.isNotEmpty()) {
-            appWidgetManager.notifyAppWidgetViewDataChanged(appWidgetIds, R.id.listView)
+            appWidgetManager?.notifyAppWidgetViewDataChanged(appWidgetIds, R.id.listView)
         }
     }
 
@@ -101,6 +104,6 @@ class MessageListWidgetManager(
 
     private fun getAppWidgetIds(): IntArray {
         val componentName = ComponentName(context, config.providerClass)
-        return appWidgetManager.getAppWidgetIds(componentName)
+        return appWidgetManager?.getAppWidgetIds(componentName) ?: intArrayOf()
     }
 }
diff --git a/autodiscovery b/autodiscovery
new file mode 100755
index 0000000000000000000000000000000000000000..b64e697bbd5636ff5ebc341edc8e16ecacba9f8d
--- /dev/null
+++ b/autodiscovery
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+./gradlew --quiet ":cli:autodiscovery-cli:installDist" < /dev/null && ./cli/autodiscovery-cli/build/install/autodiscovery-cli/bin/autodiscovery-cli "$@"
diff --git a/backend/demo/src/main/resources/contents.json b/backend/demo/src/main/resources/contents.json
index f0f75a8e00e43776166ea38a221cf327fe1f3f1e..137551a3b909c74b6b1fe9e11ca7571a3534bf3f 100644
--- a/backend/demo/src/main/resources/contents.json
+++ b/backend/demo/src/main/resources/contents.json
@@ -8,7 +8,8 @@
       "thread_1",
       "thread_2",
       "inline_image_data_uri",
-      "inline_image_attachment"
+      "inline_image_attachment",
+      "localpart_exceeds_length_limit"
     ]
   },
   "trash": {
diff --git a/backend/demo/src/main/resources/inbox/localpart_exceeds_length_limit.eml b/backend/demo/src/main/resources/inbox/localpart_exceeds_length_limit.eml
new file mode 100644
index 0000000000000000000000000000000000000000..2aa0ecb1f06925c3d5354c45790e8e1256c53ae6
--- /dev/null
+++ b/backend/demo/src/main/resources/inbox/localpart_exceeds_length_limit.eml
@@ -0,0 +1,9 @@
+MIME-Version: 1.0
+From: Sender <aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeeeffffffffffggggg@k9mail.example> (local part exceeds maximum length)
+Date: Thu, 15 Jun 2023 18:00:00 +0200
+Message-ID: <localpart@k9mail.example>
+Subject: Localpart of email address exceeds 64 characters
+To: User <user@k9mail.example>
+Content-Type: text/plain; charset=UTF-8
+
+You should still be able to read this message.
diff --git a/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandRefreshFolderListTest.kt b/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandRefreshFolderListTest.kt
index d2f5db91b64329b4a6e03e13f86b9c2c6a9c4663..018a020e639fba531e9f459876be0677d13da8ec 100644
--- a/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandRefreshFolderListTest.kt
+++ b/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandRefreshFolderListTest.kt
@@ -1,18 +1,21 @@
 package com.fsck.k9.backend.jmap
 
 import app.k9mail.backend.testing.InMemoryBackendStorage
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.containsExactlyInAnyOrder
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.isTrue
+import assertk.fail
 import com.fsck.k9.backend.api.BackendFolderUpdater
 import com.fsck.k9.backend.api.FolderInfo
 import com.fsck.k9.backend.api.updateFolders
 import com.fsck.k9.mail.AuthenticationFailedException
 import com.fsck.k9.mail.FolderType
 import com.fsck.k9.mail.MessagingException
-import junit.framework.AssertionFailedError
 import okhttp3.HttpUrl
 import okhttp3.mockwebserver.MockResponse
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Assert.fail
 import org.junit.Test
 import rs.ltt.jmap.client.JmapClient
 
@@ -25,11 +28,9 @@ class CommandRefreshFolderListTest {
             MockResponse().setResponseCode(401),
         )
 
-        try {
+        assertFailure {
             command.refreshFolderList()
-            fail("Expected exception")
-        } catch (e: AuthenticationFailedException) {
-        }
+        }.isInstanceOf<AuthenticationFailedException>()
     }
 
     @Test
@@ -38,12 +39,10 @@ class CommandRefreshFolderListTest {
             MockResponse().setBody("invalid"),
         )
 
-        try {
+        assertFailure {
             command.refreshFolderList()
-            fail("Expected exception")
-        } catch (e: MessagingException) {
-            assertTrue(e.isPermanentFailure)
-        }
+        }.isInstanceOf<MessagingException>()
+            .transform { it.isPermanentFailure }.isTrue()
     }
 
     @Test
@@ -162,18 +161,17 @@ class CommandRefreshFolderListTest {
     }
 
     private fun assertFolderList(vararg folderServerIds: String) {
-        assertEquals(folderServerIds.toSet(), backendStorage.getFolderServerIds().toSet())
+        assertThat(backendStorage.getFolderServerIds()).containsExactlyInAnyOrder(*folderServerIds)
     }
 
     private fun assertFolderPresent(serverId: String, name: String, type: FolderType) {
-        val folder = backendStorage.folders[serverId]
-            ?: throw AssertionFailedError("Expected folder '$serverId' in BackendStorage")
+        val folder = backendStorage.folders[serverId] ?: fail("Expected folder '$serverId' in BackendStorage")
 
-        assertEquals(name, folder.name)
-        assertEquals(type, folder.type)
+        assertThat(folder.name).isEqualTo(name)
+        assertThat(folder.type).isEqualTo(type)
     }
 
     private fun assertMailboxState(expected: String) {
-        assertEquals(expected, backendStorage.getExtraString("jmapState"))
+        assertThat(backendStorage.getExtraString("jmapState")).isEqualTo(expected)
     }
 }
diff --git a/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandSyncTest.kt b/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandSyncTest.kt
index 94cf2fe148651f55c2d180a607afdaa11b03e323..d2a0d16cc8aaa0e069cbe9c51edc8dfc66dd1407 100644
--- a/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandSyncTest.kt
+++ b/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandSyncTest.kt
@@ -2,6 +2,12 @@ package com.fsck.k9.backend.jmap
 
 import app.k9mail.backend.testing.InMemoryBackendFolder
 import app.k9mail.backend.testing.InMemoryBackendStorage
+import assertk.assertThat
+import assertk.assertions.containsOnly
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.isNotNull
 import com.fsck.k9.backend.api.FolderInfo
 import com.fsck.k9.backend.api.SyncConfig
 import com.fsck.k9.backend.api.SyncConfig.ExpungePolicy
@@ -16,7 +22,6 @@ import okhttp3.HttpUrl
 import okhttp3.OkHttpClient
 import okhttp3.mockwebserver.MockResponse
 import okhttp3.mockwebserver.MockWebServer
-import org.junit.Assert.assertEquals
 import org.junit.Before
 import org.junit.Test
 import rs.ltt.jmap.client.JmapClient
@@ -49,9 +54,9 @@ class CommandSyncTest {
 
         command.sync(FOLDER_SERVER_ID, syncConfig, syncListener)
 
-        assertEquals(SyncListenerEvent.SyncStarted(FOLDER_SERVER_ID), syncListener.getNextEvent())
+        assertThat(syncListener.getNextEvent()).isEqualTo(SyncListenerEvent.SyncStarted(FOLDER_SERVER_ID))
         val failedEvent = syncListener.getNextEvent() as SyncListenerEvent.SyncFailed
-        assertEquals(AuthenticationFailedException::class.java, failedEvent.exception!!.javaClass)
+        assertThat(failedEvent.exception).isNotNull().isInstanceOf<AuthenticationFailedException>()
     }
 
     @Test
@@ -103,7 +108,13 @@ class CommandSyncTest {
         command.sync(FOLDER_SERVER_ID, syncConfig, syncListener)
 
         val backendFolder = backendStorage.getFolder(FOLDER_SERVER_ID)
-        assertEquals(setOf("M001", "M002", "M003", "M004", "M005"), backendFolder.getMessageServerIds())
+        assertThat(backendFolder.getMessageServerIds()).containsOnly(
+            "M001",
+            "M002",
+            "M003",
+            "M004",
+            "M005",
+        )
         syncListener.assertSyncSuccess()
     }
 
@@ -145,7 +156,7 @@ class CommandSyncTest {
 
         command.sync(FOLDER_SERVER_ID, syncConfig, syncListener)
 
-        assertEquals(emptySet<String>(), backendFolder.getMessageServerIds())
+        assertThat(backendFolder.getMessageServerIds()).isEmpty()
         syncListener.assertSyncEvents(
             SyncListenerEvent.SyncStarted(FOLDER_SERVER_ID),
             SyncListenerEvent.SyncFinished(FOLDER_SERVER_ID),
@@ -168,9 +179,9 @@ class CommandSyncTest {
 
         command.sync(FOLDER_SERVER_ID, syncConfig, syncListener)
 
-        assertEquals(setOf("M001", "M002"), backendFolder.getMessageServerIds())
-        assertEquals(emptySet<Flag>(), backendFolder.getMessageFlags("M001"))
-        assertEquals(setOf(Flag.SEEN), backendFolder.getMessageFlags("M002"))
+        assertThat(backendFolder.getMessageServerIds()).containsOnly("M001", "M002")
+        assertThat(backendFolder.getMessageFlags("M001")).isEmpty()
+        assertThat(backendFolder.getMessageFlags("M002")).containsOnly(Flag.SEEN)
         backendFolder.assertQueryState("50:0")
         syncListener.assertSyncEvents(
             SyncListenerEvent.SyncStarted(FOLDER_SERVER_ID),
@@ -196,7 +207,7 @@ class CommandSyncTest {
 
         command.sync(FOLDER_SERVER_ID, syncConfig, syncListener)
 
-        assertEquals(setOf("M002", "M003"), backendFolder.getMessageServerIds())
+        assertThat(backendFolder.getMessageServerIds()).containsOnly("M002", "M003")
         backendFolder.assertQueryState("51:0")
         syncListener.assertSyncSuccess()
     }
@@ -220,7 +231,7 @@ class CommandSyncTest {
 
         command.sync(FOLDER_SERVER_ID, syncConfig, syncListener)
 
-        assertEquals(setOf("M002", "M003"), backendFolder.getMessageServerIds())
+        assertThat(backendFolder.getMessageServerIds()).containsOnly("M002", "M003")
         backendFolder.assertQueryState("50:0")
         syncListener.assertSyncSuccess()
     }
@@ -246,11 +257,11 @@ class CommandSyncTest {
         val request = takeRequest()
         val requestUrl = request.requestUrl ?: error("No request URL")
         val requestUrlPath = requestUrl.encodedPath + "?" + requestUrl.encodedQuery
-        assertEquals(expected, requestUrlPath)
+        assertThat(requestUrlPath).isEqualTo(expected)
     }
 
     private fun InMemoryBackendFolder.assertQueryState(expected: String) {
-        assertEquals(expected, getFolderExtraString("jmapQueryState"))
+        assertThat(getFolderExtraString("jmapQueryState")).isEqualTo(expected)
     }
 
     private fun InMemoryBackendFolder.setQueryState(queryState: String) {
diff --git a/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/LoggingSyncListener.kt b/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/LoggingSyncListener.kt
index b1aad2a24d57a91119e46c02e602a3218338831e..8d0f2d84af3c7d215d5606e15d6c34925cdfc26c 100644
--- a/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/LoggingSyncListener.kt
+++ b/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/LoggingSyncListener.kt
@@ -1,9 +1,10 @@
 package com.fsck.k9.backend.jmap
 
+import assertk.assertThat
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.fail
 import com.fsck.k9.backend.api.SyncListener
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Assert.fail
 
 class LoggingSyncListener : SyncListener {
     private val events = mutableListOf<SyncListenerEvent>()
@@ -20,9 +21,10 @@ class LoggingSyncListener : SyncListener {
 
     fun assertSyncEvents(vararg events: SyncListenerEvent) {
         for (event in events) {
-            assertEquals(event, getNextEvent())
+            assertThat(getNextEvent()).isEqualTo(event)
         }
-        assertNoMoreEventsLeft()
+
+        assertThat(this.events).isEmpty()
     }
 
     fun getNextEvent(): SyncListenerEvent {
@@ -30,10 +32,6 @@ class LoggingSyncListener : SyncListener {
         return events.removeAt(0)
     }
 
-    private fun assertNoMoreEventsLeft() {
-        assertTrue("Expected no more events; but still have: $events", events.isEmpty())
-    }
-
     override fun syncStarted(folderServerId: String) {
         events.add(SyncListenerEvent.SyncStarted(folderServerId))
     }
diff --git a/backend/testing/build.gradle.kts b/backend/testing/build.gradle.kts
index d3bc66988b8e7d93bfd134d7d011432ebfda99cf..eb2e245f6752de9be363600a8f1602d30e607fa7 100644
--- a/backend/testing/build.gradle.kts
+++ b/backend/testing/build.gradle.kts
@@ -8,4 +8,5 @@ dependencies {
 
     implementation(libs.okio)
     implementation(libs.junit)
+    implementation(libs.assertk)
 }
diff --git a/backend/testing/src/main/java/app/k9mail/backend/testing/InMemoryBackendFolder.kt b/backend/testing/src/main/java/app/k9mail/backend/testing/InMemoryBackendFolder.kt
index d1368d9f33bf93be0eae391593eca580afe9347f..6446784f3b70ebb5ba8ab02c00a6ade058e7f866 100644
--- a/backend/testing/src/main/java/app/k9mail/backend/testing/InMemoryBackendFolder.kt
+++ b/backend/testing/src/main/java/app/k9mail/backend/testing/InMemoryBackendFolder.kt
@@ -1,5 +1,7 @@
 package app.k9mail.backend.testing
 
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import com.fsck.k9.backend.api.BackendFolder
 import com.fsck.k9.backend.api.BackendFolder.MoreMessages
 import com.fsck.k9.mail.Flag
@@ -11,7 +13,6 @@ import java.util.Date
 import okio.Buffer
 import okio.buffer
 import okio.source
-import org.junit.Assert.assertEquals
 
 class InMemoryBackendFolder(override var name: String, var type: FolderType) : BackendFolder {
     val extraStrings: MutableMap<String, String> = mutableMapOf()
@@ -29,12 +30,12 @@ class InMemoryBackendFolder(override var name: String, var type: FolderType) : B
             assertMessageContents(messageServerId, resourceName)
         }
         val messageServerIds = messagePairs.map { it.first }.toSet()
-        assertEquals(messageServerIds, messages.keys)
+        assertThat(messages.keys).isEqualTo(messageServerIds)
     }
 
     private fun assertMessageContents(messageServerId: String, resourceName: String) {
         val message = messages[messageServerId] ?: error("Message $messageServerId not found")
-        assertEquals(loadResource(resourceName), getMessageContents(message))
+        assertThat(getMessageContents(message)).isEqualTo(loadResource(resourceName))
     }
 
     fun createMessages(vararg messagePairs: Pair<String, String>) {
diff --git a/build-plugin/src/main/kotlin/thunderbird.library.jvm.gradle.kts b/build-plugin/src/main/kotlin/thunderbird.library.jvm.gradle.kts
index 82086143ee243ff9ca3285928be0b5471e1417f4..dc849ffea43e2fd49605b2fe91c2cc09569aed13 100644
--- a/build-plugin/src/main/kotlin/thunderbird.library.jvm.gradle.kts
+++ b/build-plugin/src/main/kotlin/thunderbird.library.jvm.gradle.kts
@@ -1,3 +1,5 @@
+import org.gradle.jvm.tasks.Jar
+
 plugins {
     `java-library`
     id("org.jetbrains.kotlin.jvm")
@@ -8,6 +10,13 @@ java {
     targetCompatibility = ThunderbirdProjectConfig.javaCompatibilityVersion
 }
 
+tasks.withType<Jar> {
+    // We want to avoid ending up with multiple JARs having the same name, e.g. "common.jar".
+    // To do this, we use the modified project path as base name, e.g. ":core:common" -> "core.common".
+    val projectDotPath = project.path.split(":").filter { it.isNotEmpty() }.joinToString(separator = ".")
+    archiveBaseName.set(projectDotPath)
+}
+
 configureKotlinJavaCompatibility()
 
 dependencies {
diff --git a/build-plugin/src/main/kotlin/thunderbird.quality.detekt.gradle.kts b/build-plugin/src/main/kotlin/thunderbird.quality.detekt.gradle.kts
index 0d3a06c1526f414a537c93685890d39d3545f479..739d67b308eca626a48af3be6d8306bb44fde282 100644
--- a/build-plugin/src/main/kotlin/thunderbird.quality.detekt.gradle.kts
+++ b/build-plugin/src/main/kotlin/thunderbird.quality.detekt.gradle.kts
@@ -7,11 +7,8 @@ plugins {
 }
 
 configure<DetektExtension> {
-    source = project.files(
-        project.file(project.rootDir),
-    )
-
-    config = project.rootProject.files("config/detekt/detekt.yml")
+    source.setFrom(project.file(project.rootDir))
+    config.setFrom(project.rootProject.files("config/detekt/detekt.yml"))
     baseline = project.rootProject.file("config/detekt/baseline.xml")
 }
 
diff --git a/cli/autodiscovery-cli/build.gradle.kts b/cli/autodiscovery-cli/build.gradle.kts
new file mode 100644
index 0000000000000000000000000000000000000000..274e96222656420d28b3be98cba9065b03c6b6d0
--- /dev/null
+++ b/cli/autodiscovery-cli/build.gradle.kts
@@ -0,0 +1,18 @@
+plugins {
+    id(ThunderbirdPlugins.App.jvm)
+}
+
+version = "unspecified"
+
+application {
+    mainClass.set("app.k9mail.cli.autodiscovery.MainKt")
+}
+
+dependencies {
+    implementation(projects.feature.autodiscovery.api)
+    implementation(projects.feature.autodiscovery.autoconfig)
+
+    implementation(libs.kotlinx.coroutines.core)
+    implementation(libs.clikt)
+    implementation(libs.kxml2)
+}
diff --git a/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/AutoDiscoveryCli.kt b/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/AutoDiscoveryCli.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1cdf47d950d6c97a0641ed3b601f2ff85fe0e2f0
--- /dev/null
+++ b/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/AutoDiscoveryCli.kt
@@ -0,0 +1,70 @@
+package app.k9mail.cli.autodiscovery
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.Settings
+import app.k9mail.autodiscovery.autoconfig.AutoconfigUrlConfig
+import app.k9mail.autodiscovery.autoconfig.createIspDbAutoconfigDiscovery
+import app.k9mail.autodiscovery.autoconfig.createMxLookupAutoconfigDiscovery
+import app.k9mail.autodiscovery.autoconfig.createProviderAutoconfigDiscovery
+import app.k9mail.core.common.mail.toUserEmailAddress
+import com.github.ajalt.clikt.core.CliktCommand
+import com.github.ajalt.clikt.parameters.arguments.argument
+import com.github.ajalt.clikt.parameters.options.flag
+import com.github.ajalt.clikt.parameters.options.option
+import kotlin.time.DurationUnit.MILLISECONDS
+import kotlin.time.toDuration
+import kotlinx.coroutines.runBlocking
+import okhttp3.OkHttpClient.Builder
+import org.koin.core.time.measureDurationForResult
+
+class AutoDiscoveryCli : CliktCommand(
+    help = "Performs the auto-discovery steps used by Thunderbird for Android to find mail server settings",
+) {
+    private val httpsOnly by option(help = "Only perform Autoconfig lookups using HTTPS").flag()
+    private val includeEmailAddress by option(help = "Include email address in Autoconfig lookups").flag()
+
+    private val emailAddress by argument(name = "email", help = "Email address")
+
+    override fun run() {
+        echo("Attempting to find mail server settings for <$emailAddress>…")
+        echo()
+
+        val config = AutoconfigUrlConfig(
+            httpsOnly = httpsOnly,
+            includeEmailAddress = includeEmailAddress,
+        )
+
+        val (discoveryResult, durationInMillis) = measureDurationForResult {
+            runAutoDiscovery(config)
+        }
+
+        if (discoveryResult is Settings) {
+            echo("Found the following mail server settings:")
+            AutoDiscoveryResultFormatter(::echo).output(discoveryResult)
+        } else {
+            echo("Couldn't find any mail server settings.")
+        }
+
+        echo()
+        echo("Duration: ${durationInMillis.toDuration(MILLISECONDS)}")
+    }
+
+    private fun runAutoDiscovery(config: AutoconfigUrlConfig): AutoDiscoveryResult {
+        val okHttpClient = Builder().build()
+        try {
+            val providerDiscovery = createProviderAutoconfigDiscovery(okHttpClient, config)
+            val ispDbDiscovery = createIspDbAutoconfigDiscovery(okHttpClient)
+            val mxDiscovery = createMxLookupAutoconfigDiscovery(okHttpClient)
+
+            val runnables = listOf(providerDiscovery, ispDbDiscovery, mxDiscovery)
+                .flatMap { it.initDiscovery(emailAddress.toUserEmailAddress()) }
+            val serialRunner = SerialRunner(runnables)
+
+            return runBlocking {
+                serialRunner.run()
+            }
+        } finally {
+            okHttpClient.dispatcher.executorService.shutdown()
+        }
+    }
+}
diff --git a/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/AutoDiscoveryResultFormatter.kt b/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/AutoDiscoveryResultFormatter.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b42ba6ad78a999077489134efe435d387c0c43d0
--- /dev/null
+++ b/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/AutoDiscoveryResultFormatter.kt
@@ -0,0 +1,33 @@
+package app.k9mail.cli.autodiscovery
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.Settings
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+
+internal class AutoDiscoveryResultFormatter(private val echo: (String) -> Unit) {
+    fun output(settings: Settings) {
+        val incomingServer = requireNotNull(settings.incomingServerSettings as? ImapServerSettings)
+        val outgoingServer = requireNotNull(settings.outgoingServerSettings as? SmtpServerSettings)
+
+        echo("------------------------------")
+        echo("Incoming server:")
+        echo("  Hostname:            ${incomingServer.hostname.value}")
+        echo("  Port:                ${incomingServer.port.value}")
+        echo("  Connection security: ${incomingServer.connectionSecurity}")
+        echo("  Authentication type: ${incomingServer.authenticationType}")
+        echo("  Username:            ${incomingServer.username}")
+        echo("")
+        echo("Outgoing server:")
+        echo("  Hostname:            ${outgoingServer.hostname.value}")
+        echo("  Port:                ${outgoingServer.port.value}")
+        echo("  Connection security: ${outgoingServer.connectionSecurity}")
+        echo("  Authentication type: ${outgoingServer.authenticationType}")
+        echo("  Username:            ${outgoingServer.username}")
+        echo("------------------------------")
+        if (settings.isTrusted) {
+            echo("These settings have been retrieved through trusted channels.")
+        } else {
+            echo("At least one UNTRUSTED channel was involved in retrieving these settings.")
+        }
+    }
+}
diff --git a/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/Main.kt b/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/Main.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d0cdcf5f0bfbef0ae7edcd4e345efbd3deda194a
--- /dev/null
+++ b/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/Main.kt
@@ -0,0 +1,3 @@
+package app.k9mail.cli.autodiscovery
+
+fun main(args: Array<String>) = AutoDiscoveryCli().main(args)
diff --git a/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/SerialRunner.kt b/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/SerialRunner.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b0fe4eb22fc8a2ded68791062a3820728d82acbf
--- /dev/null
+++ b/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/SerialRunner.kt
@@ -0,0 +1,45 @@
+package app.k9mail.cli.autodiscovery
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.NetworkError
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.NoUsableSettingsFound
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.Settings
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.UnexpectedException
+import app.k9mail.autodiscovery.api.AutoDiscoveryRunnable
+import com.fsck.k9.logging.Timber
+
+/**
+ * Run a list of [AutoDiscoveryRunnable] one after the other until one returns a [Settings] result.
+ */
+class SerialRunner(private val runnables: List<AutoDiscoveryRunnable>) {
+    suspend fun run(): AutoDiscoveryResult {
+        var networkErrorCount = 0
+        var networkError: NetworkError? = null
+
+        for (runnable in runnables) {
+            when (val discoveryResult = runnable.run()) {
+                is Settings -> {
+                    return discoveryResult
+                }
+                is NetworkError -> {
+                    networkErrorCount++
+                    if (networkError == null) {
+                        networkError = discoveryResult
+                    }
+                }
+                NoUsableSettingsFound -> {
+                    Unit
+                }
+                is UnexpectedException -> {
+                    Timber.w(discoveryResult.exception, "Unexpected exception")
+                }
+            }
+        }
+
+        return if (networkError != null && networkErrorCount == runnables.size) {
+            networkError
+        } else {
+            NoUsableSettingsFound
+        }
+    }
+}
diff --git a/config/detekt/baseline.xml b/config/detekt/baseline.xml
index 0b6df3faa162b776e7c7b95eaff076b2ac19ec9a..816fe03aebfde3be93602ae862ecfb05e2231067 100644
--- a/config/detekt/baseline.xml
+++ b/config/detekt/baseline.xml
@@ -2,6 +2,14 @@
 <SmellBaseline>
   <ManuallySuppressedIssues></ManuallySuppressedIssues>
   <CurrentIssues>
+    <ID>CastToNullableType:AccountSetupCheckSettings.kt$AccountSetupCheckSettings$as</ID>
+    <ID>CastToNullableType:MessageList.kt$MessageList$as</ID>
+    <ID>CastToNullableType:MessageViewContainerFragment.kt$MessageViewContainerFragment$as</ID>
+    <ID>CastToNullableType:MessageViewFragment.kt$MessageViewFragment$as</ID>
+    <ID>CastToNullableType:RealImapFolder.kt$RealImapFolder$as</ID>
+    <ID>CastToNullableType:SettingsExporter.kt$SettingsExporter$as</ID>
+    <ID>CastToNullableType:ToolbarBottomSheetDialogFragment.kt$ToolbarBottomSheetDialogFragment$as</ID>
+    <ID>CastToNullableType:VibrationPreference.kt$VibrationPreference$as</ID>
     <ID>ComplexCondition:HttpUriParser.kt$HttpUriParser$!compressionEnabled &amp;&amp; beginSegmentsCount + endSegmentsCount == 8 || compressionEnabled &amp;&amp; beginSegmentsCount + endSegmentsCount &lt; 8</ID>
     <ID>ComplexCondition:MessageListFragment.kt$MessageListFragment$operation == FolderOperation.MOVE &amp;&amp; !messagingController.isMoveCapable(account) || operation == FolderOperation.COPY &amp;&amp; !messagingController.isCopyCapable(account)</ID>
     <ID>ComplexCondition:MessageListFragment.kt$MessageListFragment$operation == FolderOperation.MOVE &amp;&amp; !messagingController.isMoveCapable(message) || operation == FolderOperation.COPY &amp;&amp; !messagingController.isCopyCapable(message)</ID>
@@ -14,7 +22,6 @@
     <ID>ComplexCondition:TextInputLayoutExtensions.kt$text != null &amp;&amp; before &gt; 0 &amp;&amp; (text.isEmpty() || text.length - count == 0)</ID>
     <ID>ComplexCondition:TouchInterceptView.kt$TouchInterceptView$absoluteDeltaY &gt; touchSlop &amp;&amp; absoluteDeltaY &gt; absoluteDeltaX &amp;&amp; (scrollView.canScrollVertically(deltaY.toInt()) || webView.canScrollVertically(deltaY.toInt()))</ID>
     <ID>ComplexCondition:build.gradle.kts$project.hasProperty("k9mail.keyAlias") &amp;&amp; project.hasProperty("k9mail.keyPassword") &amp;&amp; project.hasProperty("k9mail.storeFile") &amp;&amp; project.hasProperty("k9mail.storePassword")</ID>
-    <ID>ConstructorParameterNaming:MessageTopView.kt$MessageTopView.SavedState$`in`: Parcel</ID>
     <ID>CyclomaticComplexMethod:AccountSettingsDataStore.kt$AccountSettingsDataStore$override fun getBoolean(key: String, defValue: Boolean): Boolean</ID>
     <ID>CyclomaticComplexMethod:AccountSettingsDataStore.kt$AccountSettingsDataStore$override fun getString(key: String, defValue: String?): String?</ID>
     <ID>CyclomaticComplexMethod:AccountSettingsDataStore.kt$AccountSettingsDataStore$override fun putBoolean(key: String, value: Boolean)</ID>
@@ -51,8 +58,6 @@
     <ID>CyclomaticComplexMethod:StorageMigrations.kt$StorageMigrations$@JvmStatic fun upgradeDatabase(db: SQLiteDatabase, migrationsHelper: StorageMigrationsHelper)</ID>
     <ID>CyclomaticComplexMethod:TouchInterceptView.kt$TouchInterceptView$private fun handleOnInterceptTouchEvent(event: MotionEvent)</ID>
     <ID>DestructuringDeclarationWithTooManyEntries:RetrieveFolderOperationsTest.kt$RetrieveFolderOperationsTest$val (folderId1, folderId2, folderId3, folderId4) = listOf( sqliteDatabase.createFolder(name = "Folder 1", displayClass = "FIRST_CLASS"), sqliteDatabase.createFolder(name = "Folder 2", displayClass = "SECOND_CLASS"), sqliteDatabase.createFolder(name = "Folder 3", displayClass = "FIRST_CLASS"), sqliteDatabase.createFolder(name = "Folder 4", displayClass = "NO_CLASS"), )</ID>
-    <ID>EmptyCatchBlock:CommandRefreshFolderListTest.kt$CommandRefreshFolderListTest${ }</ID>
-    <ID>EmptyCatchBlock:K9BackendFolderTest.kt$K9BackendFolderTest${ }</ID>
     <ID>ForbiddenComment:AccountSetupCheckSettings.kt$AccountSetupCheckSettings.CheckAccountTask$* FIXME: Don't use an AsyncTask to perform network operations. * See also discussion in https://github.com/thundernest/k-9/pull/560</ID>
     <ID>ForbiddenComment:BackendFolder.kt$BackendFolder$// FIXME: add documentation</ID>
     <ID>ForbiddenComment:CommandSync.kt$CommandSync$// FIXME: Add sort parameter</ID>
@@ -129,27 +134,19 @@
     <ID>LongMethod:TextBodyBuilderTest.kt$TextBodyBuilderTest.Companion$@JvmStatic @Parameterized.Parameters(name = "{index}: {0}") fun data(): Collection&lt;TestData&gt;</ID>
     <ID>LongMethod:ThreadMessageOperationsTest.kt$ThreadMessageOperationsTest$@Test fun `merge two existing threads`()</ID>
     <ID>LongParameterList:CopyMessageOperations.kt$DatabaseMessagePart$( val id: Long, val type: Int, val root: Long, val parent: Long, val seq: Int, val mimeType: String?, val decodedBodySize: Long?, val displayName: String?, val header: ByteArray?, val encoding: String?, val charset: String?, val dataLocation: Int, val data: ByteArray?, val preamble: ByteArray?, val epilogue: ByteArray?, val boundary: String?, val contentId: String?, val serverExtra: String?, )</ID>
-    <ID>LongParameterList:FolderHelpers.kt$( name: String = "irrelevant", type: String = "regular", serverId: String? = null, isLocalOnly: Boolean = true, integrate: Boolean = false, inTopGroup: Boolean = false, displayClass: String = "NO_CLASS", syncClass: String? = "INHERITED", notifyClass: String? = "INHERITED", pushClass: String? = "SECOND_CLASS", lastUpdated: Long = 0L, unreadCount: Int = 0, visibleLimit: Int = 25, status: String? = null, flaggedCount: Int = 0, moreMessages: String = "unknown", )</ID>
     <ID>LongParameterList:ImapSync.kt$ImapSync$( remoteFolder: ImapFolder, backendFolder: BackendFolder, largeMessages: List&lt;ImapMessage&gt;, progress: AtomicInteger, downloadedMessageCount: AtomicInteger, todo: Int, highestKnownUid: Long?, listener: SyncListener, maxDownloadSize: Int, )</ID>
     <ID>LongParameterList:ImapSync.kt$ImapSync$( remoteFolder: ImapFolder, backendFolder: BackendFolder, smallMessages: List&lt;ImapMessage&gt;, progress: AtomicInteger, downloadedMessageCount: AtomicInteger, todo: Int, highestKnownUid: Long?, listener: SyncListener, )</ID>
     <ID>LongParameterList:ImapSync.kt$ImapSync$( syncConfig: SyncConfig, remoteFolder: ImapFolder, unsyncedMessages: List&lt;ImapMessage&gt;, smallMessages: MutableList&lt;ImapMessage&gt;, largeMessages: MutableList&lt;ImapMessage&gt;, progress: AtomicInteger, todo: Int, listener: SyncListener, )</ID>
-    <ID>LongParameterList:MessageDatabaseHelpers.kt$( folderId: Long, deleted: Boolean = false, uid: String? = null, subject: String = "", date: Long = 0L, flags: String = "", senderList: String = "", toList: String = "", ccList: String = "", bccList: String = "", replyToList: String = "", attachmentCount: Int = 0, internalDate: Long = 0L, messageIdHeader: String? = null, previewType: DatabasePreviewType = DatabasePreviewType.NONE, preview: String = "", mimeType: String = "text/plain", normalizedSubjectHash: Long = 0L, empty: Boolean = false, read: Boolean = false, flagged: Boolean = false, answered: Boolean = false, forwarded: Boolean = false, messagePartId: Long = 0L, encryptionType: String? = null, newMessage: Boolean = false, )</ID>
-    <ID>LongParameterList:MessageDatabaseHelpers.kt$( type: Int = 0, root: Int? = null, parent: Int = -1, seq: Int = 0, mimeType: String = "text/plain", decodedBodySize: Int = 0, displayName: String? = null, header: String? = null, encoding: String = "7bit", charset: String? = null, dataLocation: Int = 0, data: ByteArray? = null, preamble: String? = null, epilogue: String? = null, boundary: String? = null, contentId: String? = null, serverExtra: String? = null, directory: File? = null, )</ID>
     <ID>LongParameterList:MessageDetailsViewModel.kt$MessageDetailsViewModel$( private val resources: Resources, private val messageRepository: MessageRepository, private val folderRepository: FolderRepository, private val contactSettingsProvider: ContactSettingsProvider, private val contactRepository: ContactRepository, private val contactPermissionResolver: ContactPermissionResolver, private val clipboardManager: ClipboardManager, private val accountManager: AccountManager, private val participantFormatter: MessageDetailsParticipantFormatter, private val folderNameFormatter: FolderNameFormatter, )</ID>
-    <ID>LongParameterList:MessageListAdapterTest.kt$MessageListAdapterTest$( account: Account = Account(SOME_ACCOUNT_UUID), subject: String? = "irrelevant", threadCount: Int = 0, messageDate: Long = 0L, internalDate: Long = 0L, displayName: CharSequence = "irrelevant", displayAddress: Address? = Address.parse("irrelevant@domain.example").first(), previewText: String = "irrelevant", isMessageEncrypted: Boolean = false, isRead: Boolean = false, isStarred: Boolean = false, isAnswered: Boolean = false, isForwarded: Boolean = false, hasAttachments: Boolean = false, uniqueId: Long = 0L, folderId: Long = 0L, messageUid: String = "irrelevant", databaseId: Long = 0L, threadRoot: Long = 0L, )</ID>
-    <ID>LongParameterList:MessageListAdapterTest.kt$MessageListAdapterTest$( fontSizes: FontSizes = createFontSizes(), previewLines: Int = 0, stars: Boolean = true, senderAboveSubject: Boolean = false, showContactPicture: Boolean = true, showingThreadedList: Boolean = true, backGroundAsReadIndicator: Boolean = false, showAccountChip: Boolean = false, density: UiDensity = UiDensity.Default, )</ID>
-    <ID>LongParameterList:MessagePartDatabaseHelpers.kt$( type: Int = MessagePartType.UNKNOWN, root: Long? = null, parent: Long = -1, seq: Int = 0, mimeType: String? = null, decodedBodySize: Int? = null, displayName: String? = null, header: String? = null, encoding: String? = null, charset: String? = null, dataLocation: Int = DataLocation.MISSING, data: ByteArray? = null, preamble: String? = null, epilogue: String? = null, boundary: String? = null, contentId: String? = null, serverExtra: String? = null, )</ID>
     <ID>LongParameterList:PasswordPromptDialogFragment.kt$PasswordPromptDialogFragment.Companion$( accountUuid: String, accountName: String, inputIncomingServerPassword: Boolean, incomingServerName: String?, inputOutgoingServerPassword: Boolean, outgoingServerName: String?, targetFragment: Fragment, requestCode: Int, )</ID>
     <ID>LongParameterList:PushController.kt$PushController$( private val preferences: Preferences, private val generalSettingsManager: GeneralSettingsManager, private val backendManager: BackendManager, private val pushServiceManager: PushServiceManager, private val bootCompleteManager: BootCompleteManager, private val autoSyncManager: AutoSyncManager, private val pushNotificationManager: PushNotificationManager, private val connectivityManager: ConnectivityManager, private val accountPushControllerFactory: AccountPushControllerFactory, private val coroutineScope: CoroutineScope = GlobalScope, private val coroutineDispatcher: CoroutineDispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher(), )</ID>
     <ID>LongParameterList:RecipientPresenter.kt$RecipientPresenter$( private val context: Context, loaderManager: LoaderManager, private val openPgpApiManager: OpenPgpApiManager, private val recipientMvpView: RecipientMvpView, account: Account, private val composePgpInlineDecider: ComposePgpInlineDecider, private val composePgpEnableByDefaultDecider: ComposePgpEnableByDefaultDecider, private val autocryptStatusInteractor: AutocryptStatusInteractor, private val replyToParser: ReplyToParser, private val draftStateHeaderParser: AutocryptDraftStateHeaderParser, )</ID>
-    <ID>LongParameterList:SaveMessageOperationsTest.kt$SaveMessageOperationsTest$( subject: String? = getSubject(), date: Long = sentDate?.time ?: System.currentTimeMillis(), internalDate: Long = date, downloadState: MessageDownloadState = getDownloadState(), attachmentCount: Int = 0, previewResult: PreviewResult = PreviewResult.none(), textForSearchIndex: String? = null, encryptionType: String? = null, )</ID>
     <ID>LongParameterList:SettingsImportViewModel.kt$SavedAccountState$( val accountIndex: Int, val displayName: String, val accountUuid: String, val selected: Boolean, val importStatus: ImportStatus, val incomingServerName: String?, val outgoingServerName: String?, val incomingServerPasswordNeeded: Boolean, val outgoingServerPasswordNeeded: Boolean, )</ID>
-    <ID>LoopWithTooManyJumpStatements:AccountSetupCheckSettings.kt$AccountSetupCheckSettings$for (subjectAlternativeName in subjectAlternativeNames) { val type = subjectAlternativeName[0] as Int val value: Any? = subjectAlternativeName[1] val name: String = when (type) { 0 -&gt; { Timber.w("SubjectAltName of type OtherName not supported.") continue } 1 -&gt; value as String 2 -&gt; value as String 3 -&gt; { Timber.w("unsupported SubjectAltName of type x400Address") continue } 4 -&gt; { Timber.w("unsupported SubjectAltName of type directoryName") continue } 5 -&gt; { Timber.w("unsupported SubjectAltName of type ediPartyName") continue } 6 -&gt; value as String 7 -&gt; value as String else -&gt; { Timber.w("unsupported SubjectAltName of unknown type") continue } } // if some of the SubjectAltNames match the store or transport -host, display them if (name.equals(incomingServerHost, ignoreCase = true) || name.equals(outgoingServerHost, ignoreCase = true) ) { // TODO: localize this string altNamesText.append("Subject(alt): ").append(name).append(",...\n") } else if (name.startsWith("*.") &amp;&amp; ( incomingServerHost.endsWith(name.substring(2)) || outgoingServerHost.endsWith(name.substring(2)) ) ) { // TODO: localize this string altNamesText.append("Subject(alt): ").append(name).append(",...\n") } }</ID>
-    <ID>LoopWithTooManyJumpStatements:HttpUriParser.kt$HttpUriParser$while (currentPos &lt; text.length) { val c = text[currentPos] if (isHexDigit(c)) { shouldBeHex = (shouldBeHex - 1).coerceAtLeast(0) } else if (shouldBeHex == 0) { if (c in allowedCharacters) { // Everything ok here :) } else if (c == '%') { shouldBeHex = 2 } else { break } } else { break } currentPos++ }</ID>
-    <ID>LoopWithTooManyJumpStatements:RealImapStore.kt$RealImapStore$for (listResponse in listResponses) { val serverId = listResponse.name if (pathDelimiter == null) { pathDelimiter = listResponse.hierarchyDelimiter combinedPrefix = null } if (RealImapFolder.INBOX.equals(serverId, ignoreCase = true)) { continue } else if (listResponse.hasAttribute("\\NoSelect")) { continue } val name = getFolderDisplayName(serverId) val oldServerId = getOldServerId(serverId) val type = when { listResponse.hasAttribute("\\Archive") -&gt; FolderType.ARCHIVE listResponse.hasAttribute("\\All") -&gt; FolderType.ARCHIVE listResponse.hasAttribute("\\Drafts") -&gt; FolderType.DRAFTS listResponse.hasAttribute("\\Sent") -&gt; FolderType.SENT listResponse.hasAttribute("\\Junk") -&gt; FolderType.SPAM listResponse.hasAttribute("\\Trash") -&gt; FolderType.TRASH else -&gt; FolderType.REGULAR } val existingItem = folderMap[serverId] if (existingItem == null || existingItem.type == FolderType.REGULAR) { folderMap[serverId] = FolderListItem(serverId, name, type, oldServerId) } }</ID>
-    <ID>LoopWithTooManyJumpStatements:SettingsExporter.kt$SettingsExporter$for ((key, value) in prefs) { val valueString = value.toString() val comps = key.split(".") if (comps.size &lt; 3) { // Skip non-identity config entries continue } val keyUuid = comps[0] val identityKey = comps[1] val identityIndex = comps[2] if (keyUuid != accountUuid || identityIndex != identity) { // Skip entries that belong to another identity continue } val versionedSetting = IdentitySettingsDescriptions.SETTINGS[identityKey] if (versionedSetting != null) { val highestVersion = versionedSetting.lastKey() val setting = versionedSetting[highestVersion] if (setting != null) { // Only write settings that have an entry in IdentitySettings.SETTINGS try { writeKeyAndPrettyValueFromSetting(serializer, identityKey, setting, valueString) } catch (e: InvalidSettingValueException) { Timber.w( "Identity setting \"%s\" has invalid value \"%s\" in preference storage. " + "This shouldn't happen!", identityKey, valueString, ) } } } }</ID>
-    <ID>LoopWithTooManyJumpStatements:SettingsExporter.kt$SettingsExporter$for ((key, value) in prefs) { val valueString = value.toString() val comps = key.split(".", limit = 2) if (comps.size &lt; 2) { // Skip global settings continue } val keyUuid = comps[0] val keyPart = comps[1] if (keyUuid != accountUuid) { // Setting doesn't belong to the account we're currently writing. continue } val indexOfLastDot = keyPart.lastIndexOf(".") val hasThirdPart = indexOfLastDot != -1 &amp;&amp; indexOfLastDot &lt; keyPart.length - 1 if (hasThirdPart) { val secondPart = keyPart.substring(0, indexOfLastDot) val thirdPart = keyPart.substring(indexOfLastDot + 1) if (secondPart == IDENTITY_DESCRIPTION_KEY) { // This is an identity key. Save identity index for later... thirdPart.toIntOrNull()?.let { identities.add(it) } // ... but don't write it now. continue } if (FolderSettingsDescriptions.SETTINGS.containsKey(thirdPart)) { // This is a folder key. Ignore it. continue } } if (keyPart !in FOLDER_NAME_KEYS) { writeAccountSettingIfValid(serializer, keyPart, valueString, account) } }</ID>
-    <ID>LoopWithTooManyJumpStatements:UnreadWidgetMigrations.kt$UnreadWidgetMigrations$for (widgetId in widgetIds) { val accountUuid = preferences.getString("unread_widget.$widgetId", null) ?: continue val account = accountRepository.getAccount(accountUuid) ?: continue val folderServerId = preferences.getString("unread_widget.$widgetId.folder_name", null) if (folderServerId != null) { val folderId = folderRepository.getFolderId(account, folderServerId) putString("unread_widget.$widgetId.folder_id", folderId?.toString()) } remove("unread_widget.$widgetId.folder_name") }</ID>
+    <ID>LoopWithTooManyJumpStatements:AccountSetupCheckSettings.kt$AccountSetupCheckSettings$for</ID>
+    <ID>LoopWithTooManyJumpStatements:HttpUriParser.kt$HttpUriParser$while</ID>
+    <ID>LoopWithTooManyJumpStatements:RealImapStore.kt$RealImapStore$for</ID>
+    <ID>LoopWithTooManyJumpStatements:SettingsExporter.kt$SettingsExporter$for</ID>
+    <ID>LoopWithTooManyJumpStatements:UnreadWidgetMigrations.kt$UnreadWidgetMigrations$for</ID>
     <ID>MagicNumber:Account.kt$Account$168</ID>
     <ID>MagicNumber:Account.kt$Account$2</ID>
     <ID>MagicNumber:Account.kt$Account$28</ID>
@@ -279,7 +276,6 @@
     <ID>MagicNumber:MimeHeaderParser.kt$MimeHeaderParser$4</ID>
     <ID>MagicNumber:MimeParameterDecoder.kt$MimeParameterDecoder$3</ID>
     <ID>MagicNumber:MimeParameterEncoder.kt$MimeParameterEncoder$126</ID>
-    <ID>MagicNumber:MimeParameterEncoder.kt$MimeParameterEncoder$16</ID>
     <ID>MagicNumber:MimeParameterEncoder.kt$MimeParameterEncoder$3</ID>
     <ID>MagicNumber:MimeParameterEncoder.kt$MimeParameterEncoder$33</ID>
     <ID>MagicNumber:MimeParameterEncoder.kt$MimeParameterEncoder$35</ID>
@@ -443,7 +439,6 @@
     <ID>MatchingDeclarationName:Main.kt$HtmlCleaner : CliktCommand</ID>
     <ID>MaxLineLength:BoundaryGeneratorTest.kt$BoundaryGeneratorTest$0</ID>
     <ID>MaxLineLength:ComposeCryptoStatus.kt$ComposeCryptoStatus$OpenPgpApiManager.OpenPgpProviderState.ERROR, OpenPgpApiManager.OpenPgpProviderState.UI_REQUIRED -&gt; CryptoStatusDisplayType.ERROR</ID>
-    <ID>MaxLineLength:EmailAddressValidatorTest.kt$EmailAddressValidatorTest$Assert.assertTrue(validator.isValidAddressOnly("\"very.(),:;&lt;&gt;[]\\\".VERY.\\\"very@\\\\ \\\"very\\\".unusual\"@strange.example.com"))</ID>
     <ID>MaxLineLength:GenericUriParserTest.kt$GenericUriParserTest$assertUriValid("xmpp:node@example.com/repulsive%20!%23%22\$%25&amp;'()*+,-.%2F:;%3C=%3E%3F%40%5B%5C%5D%5E_%60%7B%7C%7D~resource")</ID>
     <ID>MaxLineLength:HtmlSanitizerTest.kt$HtmlSanitizerTest$assertThat(result.toCompactString()).isEqualTo("&lt;html&gt;&lt;head&gt;&lt;style&gt;keep this&lt;/style&gt;&lt;/head&gt;&lt;body&gt;&lt;/body&gt;&lt;/html&gt;")</ID>
     <ID>MaxLineLength:ImapSync.kt$ImapSync.&lt;no name provided&gt;$// TODO: This might be the source of poll count errors in the UI. Is todo always the same as ofTotal</ID>
@@ -461,7 +456,6 @@
     <ID>MayBeConst:SummaryNotificationDataCreatorTest.kt$private val TIMESTAMP = 0L</ID>
     <ID>MemberNameEqualsClassName:HtmlModification.kt$HtmlModification.Replace$abstract fun replace(textToHtml: TextToHtml)</ID>
     <ID>MemberNameEqualsClassName:ReplyToView.kt$ReplyToView$private val replyToView: RecipientSelectView = activity.findViewById(R.id.reply_to)</ID>
-    <ID>NestedBlockDepth:AutoconfigParser.kt$AutoconfigParser$private fun parseServer(xpp: XmlPullParser, nodeName: String, email: String): DiscoveredServerSettings</ID>
     <ID>NestedBlockDepth:HttpUriParser.kt$HttpUriParser$private fun tryMatchIpv6Address(text: CharSequence, startPos: Int): Int</ID>
     <ID>NestedBlockDepth:ImapSync.kt$ImapSync$private fun synchronizeMailboxSynchronous(folder: String, syncConfig: SyncConfig, listener: SyncListener)</ID>
     <ID>NestedBlockDepth:MessageList.kt$MessageList$override fun onBackPressed()</ID>
@@ -567,14 +561,12 @@
     <ID>SpreadOperator:ReplyToView.kt$ReplyToView$(*recipients)</ID>
     <ID>SwallowedException:AboutFragment.kt$e: ActivityNotFoundException</ID>
     <ID>SwallowedException:AuthViewModel.kt$AuthViewModel$e: ActivityNotFoundException</ID>
-    <ID>SwallowedException:CommandRefreshFolderListTest.kt$CommandRefreshFolderListTest$e: AuthenticationFailedException</ID>
     <ID>SwallowedException:ContactPictureLoader.kt$ContactPictureLoader$e: Exception</ID>
     <ID>SwallowedException:DecoderUtil.kt$DecoderUtil$e: IOException</ID>
     <ID>SwallowedException:DecoderUtil.kt$DecoderUtil$e: MessagingException</ID>
     <ID>SwallowedException:JmapAccountDiscovery.kt$JmapAccountDiscovery$e: EndpointNotFoundException</ID>
     <ID>SwallowedException:JmapAccountDiscovery.kt$JmapAccountDiscovery$e: UnauthorizedException</ID>
     <ID>SwallowedException:JmapAccountDiscovery.kt$JmapAccountDiscovery$e: UnknownHostException</ID>
-    <ID>SwallowedException:K9BackendFolderTest.kt$K9BackendFolderTest$e: IllegalStateException</ID>
     <ID>SwallowedException:LocalKeyStore.kt$LocalKeyStore$e: FileNotFoundException</ID>
     <ID>SwallowedException:LocalKeyStore.kt$LocalKeyStore$e: KeyStoreException</ID>
     <ID>SwallowedException:MessageContainerView.kt$MessageContainerView$e: ActivityNotFoundException</ID>
@@ -588,8 +580,6 @@
     <ID>SwallowedException:MimeParameterDecoder.kt$MimeParameterDecoder$e: IllegalCharsetNameException</ID>
     <ID>SwallowedException:MimeParameterDecoder.kt$MimeParameterDecoder$e: MimeHeaderParserException</ID>
     <ID>SwallowedException:MimeType.kt$MimeType.Companion$e: IllegalArgumentException</ID>
-    <ID>SwallowedException:PgpMessageBuilderTest.kt$PgpMessageBuilderTest.Companion$e: IOException</ID>
-    <ID>SwallowedException:PgpMessageBuilderTest.kt$PgpMessageBuilderTest.Companion$e: MessagingException</ID>
     <ID>SwallowedException:PushInfoFragment.kt$PushInfoFragment$e: ActivityNotFoundException</ID>
     <ID>SwallowedException:QuoteDateFormatter.kt$QuoteDateFormatter$e: Exception</ID>
     <ID>SwallowedException:RealImapConnection.kt$RealImapConnection$e: NegativeImapResponseException</ID>
@@ -750,15 +740,11 @@
     <ID>TooManyFunctions:UnreadWidgetConfigurationFragment.kt$UnreadWidgetConfigurationFragment : PreferenceFragmentCompat</ID>
     <ID>TooManyFunctions:UpdateFolderOperations.kt$UpdateFolderOperations</ID>
     <ID>TooManyFunctions:VibrationDialogFragment.kt$VibrationDialogFragment$VibrationPatternAdapter : BaseAdapter</ID>
-    <ID>UnnecessaryAbstractClass:AppRobolectricTest.kt$AppRobolectricTest$AppRobolectricTest</ID>
-    <ID>UnnecessaryAbstractClass:HtmlModification.kt$HtmlModification$HtmlModification</ID>
-    <ID>UnnecessaryAbstractClass:K9RobolectricTest.kt$K9RobolectricTest$K9RobolectricTest</ID>
-    <ID>UnnecessaryAbstractClass:RobolectricTest.kt$RobolectricTest$RobolectricTest</ID>
-    <ID>UnusedPrivateMember:Contacts.kt$Contacts$addresses: Array&lt;Address?&gt;?</ID>
-    <ID>UnusedPrivateMember:ExtraAccountDiscovery.kt$ExtraAccountDiscovery$email: String</ID>
-    <ID>UnusedPrivateMember:HttpUriParser.kt$HttpUriParser$i</ID>
-    <ID>UnusedPrivateMember:MessageListLoader.kt$MessageListLoader$account: Account</ID>
-    <ID>UnusedPrivateMember:MessageViewFragment.kt$MessageViewFragment$requestKey: String</ID>
+    <ID>UnusedParameter:Contacts.kt$Contacts$addresses: Array&lt;Address?&gt;?</ID>
+    <ID>UnusedParameter:ExtraAccountDiscovery.kt$ExtraAccountDiscovery$email: String</ID>
+    <ID>UnusedParameter:MessageListLoader.kt$MessageListLoader$account: Account</ID>
+    <ID>UnusedParameter:MessageViewFragment.kt$MessageViewFragment$requestKey: String</ID>
+    <ID>UnusedPrivateProperty:HttpUriParser.kt$HttpUriParser$i</ID>
     <ID>UseCheckOrError:OutboxStateRepository.kt$OutboxStateRepository$throw IllegalStateException("No outbox_state entry for message with id $messageId")</ID>
     <ID>UseCheckOrError:ThemeExtensions.kt$throw IllegalStateException("Couldn't resolve attribute ($attrId)")</ID>
     <ID>UseRequire:MimeParameterEncoder.kt$MimeParameterEncoder$throw IllegalArgumentException("Unsupported character: $c")</ID>
diff --git a/config/detekt/detekt.yml b/config/detekt/detekt.yml
index 5ef70fc8cdede6e6cdd0170f7a1af528a072f1f0..aea91bcca3d012bf8c20c99b37886e295faca741 100644
--- a/config/detekt/detekt.yml
+++ b/config/detekt/detekt.yml
@@ -48,6 +48,7 @@ output-reports:
   # - 'XmlOutputReport'
   # - 'HtmlOutputReport'
   # - 'MdOutputReport'
+  # - 'SarifOutputReport'
 
 comments:
   active: true
@@ -66,7 +67,7 @@ comments:
     endOfSentenceFormat: '([.?!][ \t\n\r\f<])|([.?!:]$)'
   KDocReferencesNonPublicProperty:
     active: false
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
   OutdatedDocumentation:
     active: false
     matchTypeParameters: true
@@ -74,7 +75,7 @@ comments:
     allowParamOnConstructorProperties: false
   UndocumentedPublicClass:
     active: false
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     searchInNestedClass: true
     searchInInnerClass: true
     searchInInnerObject: true
@@ -82,11 +83,11 @@ comments:
     searchInProtectedClass: false
   UndocumentedPublicFunction:
     active: false
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     searchProtectedFunction: false
   UndocumentedPublicProperty:
     active: false
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     searchProtectedProperty: false
 
 complexity:
@@ -132,7 +133,7 @@ complexity:
     active: true
     functionThreshold: 8
     constructorThreshold: 8
-    ignoreDefaultParameters: false
+    ignoreDefaultParameters: true
     ignoreDataClasses: true
     ignoreAnnotatedParameter: []
   MethodOverloading:
@@ -158,14 +159,14 @@ complexity:
     active: false
   StringLiteralDuplication:
     active: false
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     threshold: 3
     ignoreAnnotation: true
     excludeStringsWithLessThan5Characters: true
     ignoreStringsRegex: '$^'
   TooManyFunctions:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     thresholdInFiles: 11
     thresholdInClasses: 11
     thresholdInInterfaces: 11
@@ -189,6 +190,8 @@ coroutines:
     active: true
   SleepInsteadOfDelay:
     active: true
+  SuspendFunSwallowedCancellation:
+    active: false
   SuspendFunWithCoroutineScopeReceiver:
     active: false
   SuspendFunWithFlowReturnType:
@@ -240,7 +243,7 @@ exceptions:
       - 'toString'
   InstanceOfCheckForException:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
   NotImplementedDeclaration:
     active: false
   ObjectExtendsThrowable:
@@ -266,7 +269,7 @@ exceptions:
     active: false
   ThrowingExceptionsWithoutMessageOrCause:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     exceptions:
       - 'ArrayIndexOutOfBoundsException'
       - 'Exception'
@@ -281,7 +284,7 @@ exceptions:
     active: true
   TooGenericExceptionCaught:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     exceptionNames:
       - 'ArrayIndexOutOfBoundsException'
       - 'Error'
@@ -305,7 +308,6 @@ naming:
   BooleanPropertyNaming:
     active: false
     allowedPattern: '^(is|has|are)'
-    ignoreOverridden: true
   ClassNaming:
     active: true
     classPattern: '[A-Z][a-zA-Z0-9]*'
@@ -314,7 +316,6 @@ naming:
     parameterPattern: '[a-z][A-Za-z0-9]*'
     privateParameterPattern: '[a-z][A-Za-z0-9]*'
     excludeClassPattern: '$^'
-    ignoreOverridden: true
   EnumNaming:
     active: true
     enumEntryPattern: '[A-Z][_a-zA-Z0-9]*'
@@ -329,17 +330,15 @@ naming:
     minimumFunctionNameLength: 3
   FunctionNaming:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     functionPattern: '[a-z][a-zA-Z0-9]*'
     excludeClassPattern: '$^'
-    ignoreOverridden: true
     ignoreAnnotated:
       - 'Composable'
   FunctionParameterNaming:
     active: true
     parameterPattern: '[a-z][A-Za-z0-9]*'
     excludeClassPattern: '$^'
-    ignoreOverridden: true
   InvalidPackageDeclaration:
     active: true
     rootPackage: ''
@@ -381,7 +380,6 @@ naming:
     variablePattern: '[a-z][A-Za-z0-9]*'
     privateVariablePattern: '(_)?[a-z][A-Za-z0-9]*'
     excludeClassPattern: '$^'
-    ignoreOverridden: true
 
 performance:
   active: true
@@ -392,10 +390,10 @@ performance:
     threshold: 3
   ForEachOnRange:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
   SpreadOperator:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
   UnnecessaryPartOfBinaryExpression:
     active: false
   UnnecessaryTemporaryInstantiation:
@@ -407,8 +405,10 @@ potential-bugs:
     active: true
     forbiddenTypePatterns:
       - 'kotlin.String'
+  CastNullableToNonNullableType:
+    active: true
   CastToNullableType:
-    active: false
+    active: true
   Deprecation:
     active: false
   DontDowncastCollectionTypes:
@@ -426,6 +426,7 @@ potential-bugs:
       - 'java.util.HashMap'
   ElseCaseInsteadOfExhaustiveWhen:
     active: false
+    ignoredSubjectTypes: []
   EqualsAlwaysReturnsTrueOrFalse:
     active: true
   EqualsWithHashCodeExist:
@@ -440,9 +441,12 @@ potential-bugs:
     active: true
     restrictToConfig: true
     returnValueAnnotations:
+      - 'CheckResult'
       - '*.CheckResult'
+      - 'CheckReturnValue'
       - '*.CheckReturnValue'
     ignoreReturnValueAnnotations:
+      - 'CanIgnoreReturnValue'
       - '*.CanIgnoreReturnValue'
     returnValueTypes:
       - 'kotlin.sequences.Sequence'
@@ -462,7 +466,7 @@ potential-bugs:
     active: true
   LateinitUsage:
     active: false
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     ignoreOnClassesPattern: ''
   MapGetWithNotNullAssertionOperator:
     active: true
@@ -473,6 +477,8 @@ potential-bugs:
     active: false
   NullableToStringCall:
     active: false
+  PropertyUsedBeforeDeclaration:
+    active: false
   UnconditionalJumpStatementInLoop:
     active: false
   UnnecessaryNotNullCheck:
@@ -487,7 +493,7 @@ potential-bugs:
     active: true
   UnsafeCallOnNullableType:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
   UnsafeCast:
     active: true
   UnusedUnaryOperator:
@@ -501,6 +507,14 @@ style:
   active: true
   AlsoCouldBeApply:
     active: false
+  BracesOnIfStatements:
+    active: false
+    singleLine: 'never'
+    multiLine: 'always'
+  BracesOnWhenStatements:
+    active: false
+    singleLine: 'necessary'
+    multiLine: 'consistent'
   CanBeNonNullable:
     active: false
   CascadingCallWrapping:
@@ -514,11 +528,22 @@ style:
     active: false
     conversionFunctionPrefix:
       - 'to'
+    allowOperators: false
   DataClassShouldBeImmutable:
     active: false
   DestructuringDeclarationWithTooManyEntries:
     active: true
     maxDestructuringEntries: 3
+  DoubleNegativeLambda:
+    active: false
+    negativeFunctions:
+      - reason: 'Use `takeIf` instead.'
+        value: 'takeUnless'
+      - reason: 'Use `all` instead.'
+        value: 'none'
+    negativeFunctionNameParts:
+      - 'not'
+      - 'non'
   EqualsNullCall:
     active: true
   EqualsOnSignatureLine:
@@ -530,13 +555,31 @@ style:
   ExpressionBodySyntax:
     active: false
     includeLineWrapping: false
+  ForbiddenAnnotation:
+    active: false
+    annotations:
+      - reason: 'it is a java annotation. Use `Suppress` instead.'
+        value: 'java.lang.SuppressWarnings'
+      - reason: 'it is a java annotation. Use `kotlin.Deprecated` instead.'
+        value: 'java.lang.Deprecated'
+      - reason: 'it is a java annotation. Use `kotlin.annotation.MustBeDocumented` instead.'
+        value: 'java.lang.annotation.Documented'
+      - reason: 'it is a java annotation. Use `kotlin.annotation.Target` instead.'
+        value: 'java.lang.annotation.Target'
+      - reason: 'it is a java annotation. Use `kotlin.annotation.Retention` instead.'
+        value: 'java.lang.annotation.Retention'
+      - reason: 'it is a java annotation. Use `kotlin.annotation.Repeatable` instead.'
+        value: 'java.lang.annotation.Repeatable'
+      - reason: 'Kotlin does not support @Inherited annotation, see https://youtrack.jetbrains.com/issue/KT-22265'
+        value: 'java.lang.annotation.Inherited'
   ForbiddenComment:
     active: true
-    values:
-      - 'FIXME:'
-      - 'STOPSHIP:'
+    comments:
+      - reason: 'Forbidden FIXME todo marker in comment, please fix the problem.'
+        value: 'FIXME:'
+      - reason: 'Forbidden STOPSHIP todo marker in comment, please address the problem before shipping the code.'
+        value: 'STOPSHIP:'
     allowedPatterns: ''
-    customMessage: ''
   ForbiddenImport:
     active: false
     imports: []
@@ -565,7 +608,7 @@ style:
     maxJumpCount: 1
   MagicNumber:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**', '**/*.kts']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**', '**/*.kts']
     ignoreNumbers:
       - '-1'
       - '0'
@@ -583,8 +626,6 @@ style:
     ignoreEnums: false
     ignoreRanges: false
     ignoreExtensionFunctions: true
-  MandatoryBracesIfStatements:
-    active: false
   MandatoryBracesLoops:
     active: false
   MaxChainedCallsOnSameLine:
@@ -606,6 +647,9 @@ style:
   MultilineRawStringIndentation:
     active: false
     indentSize: 4
+    trimmingMethods:
+      - 'trimIndent'
+      - 'trimMargin'
   NestedClassesVisibility:
     active: true
   NewLineAtEndOfFile:
@@ -646,6 +690,10 @@ style:
     active: true
   SpacingBetweenPackageAndImports:
     active: false
+  StringShouldBeRawString:
+    active: false
+    maxEscapedCharacterCount: 2
+    ignoredCharacters: []
   ThrowsCount:
     active: true
     max: 2
@@ -654,6 +702,9 @@ style:
     active: false
   TrimMultilineRawString:
     active: false
+    trimmingMethods:
+      - 'trimIndent'
+      - 'trimMargin'
   UnderscoresInNumericLiterals:
     active: false
     acceptableLength: 4
@@ -666,6 +717,8 @@ style:
     active: true
   UnnecessaryBackticks:
     active: false
+  UnnecessaryBracesAroundTrailingLambda:
+    active: false
   UnnecessaryFilter:
     active: true
   UnnecessaryInheritance:
@@ -681,11 +734,17 @@ style:
     active: false
   UnusedImports:
     active: false
+  UnusedParameter:
+    active: true
+    allowedNames: 'ignored|expected'
   UnusedPrivateClass:
     active: true
   UnusedPrivateMember:
     active: true
-    allowedNames: '(_|ignored|expected|serialVersionUID)'
+    allowedNames: ''
+  UnusedPrivateProperty:
+    active: true
+    allowedNames: '_|ignored|expected|serialVersionUID'
     ignoreAnnotated:
       - 'Preview'
   UseAnyOrNoneInsteadOfFind:
@@ -705,8 +764,11 @@ style:
     active: false
   UseIfInsteadOfWhen:
     active: false
+    ignoreWhenContainingVariableDeclaration: false
   UseIsNullOrEmpty:
     active: true
+  UseLet:
+    active: false
   UseOrEmpty:
     active: true
   UseRequire:
@@ -730,11 +792,9 @@ style:
 Compose:
   CompositionLocalAllowlist:
     active: true
-    allowedCompositionLocals: [LocalColors, LocalElevations, LocalImages, LocalSizes, LocalSpacings]
+    allowedCompositionLocals: [LocalColors, LocalElevations, LocalImages, LocalShapes, LocalSizes, LocalSpacings]
   ContentEmitterReturningValues:
     active: true
-    # You can optionally add your own composables here
-    # contentEmitters: MyComposable,MyOtherComposable
   ModifierComposable:
     active: true
   ModifierMissing:
@@ -745,22 +805,16 @@ Compose:
     active: true
   MultipleEmitters:
     active: true
-      # You can optionally add your own composables here
-    # contentEmitters: MyComposable,MyOtherComposable
   MutableParams:
     active: true
   ComposableNaming:
     active: true
-    # You can optionally disable the checks in this rule for regex matches against the composable name (e.g. molecule presenters)
-    # allowedComposableFunctionNames: .*Presenter,.*MoleculePresenter
   ComposableParamOrder:
     active: true
   PreviewNaming:
     active: true
   PreviewPublic:
     active: true
-    # You can optionally disable that only previews with @PreviewParameter are flagged
-    # previewPublicOnlyIfParams: false
   RememberMissing:
     active: true
   UnstableCollections:
@@ -769,4 +823,3 @@ Compose:
     active: true
   ViewModelInjection:
     active: true
-
diff --git a/core/android/common/src/test/kotlin/app/k9mail/core/android/common/contact/ContactFixture.kt b/core/android/common/src/test/kotlin/app/k9mail/core/android/common/contact/ContactFixture.kt
index 600ca3168771c753ebb4686db247a50c448f1511..35567986af2319748aa3af0f1a77f0342dd6a5e7 100644
--- a/core/android/common/src/test/kotlin/app/k9mail/core/android/common/contact/ContactFixture.kt
+++ b/core/android/common/src/test/kotlin/app/k9mail/core/android/common/contact/ContactFixture.kt
@@ -1,12 +1,12 @@
 package app.k9mail.core.android.common.contact
 
 import android.net.Uri
-import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toEmailAddressOrThrow
 
 const val CONTACT_ID = 123L
 const val CONTACT_NAME = "user name"
 const val CONTACT_LOOKUP_KEY = "0r1-4F314D4F2F294F29"
-val CONTACT_EMAIL_ADDRESS = EmailAddress("user@example.com")
+val CONTACT_EMAIL_ADDRESS = "user@example.com".toEmailAddressOrThrow()
 val CONTACT_URI: Uri = Uri.parse("content://com.android.contacts/contacts/lookup/$CONTACT_LOOKUP_KEY/$CONTACT_ID")
 val CONTACT_PHOTO_URI: Uri = Uri.parse("content://com.android.contacts/display_photo/$CONTACT_ID")
 
diff --git a/core/android/common/src/test/kotlin/app/k9mail/core/android/common/database/CursorExtensionsKtAccessTest.kt b/core/android/common/src/test/kotlin/app/k9mail/core/android/common/database/CursorExtensionsKtAccessTest.kt
index d228ae48c976c15fbf88afad0018bd92352f91f7..1eaa52f71c9bfbd83b079fd86ec92ba09a14cb7c 100644
--- a/core/android/common/src/test/kotlin/app/k9mail/core/android/common/database/CursorExtensionsKtAccessTest.kt
+++ b/core/android/common/src/test/kotlin/app/k9mail/core/android/common/database/CursorExtensionsKtAccessTest.kt
@@ -2,10 +2,10 @@ package app.k9mail.core.android.common.database
 
 import android.database.Cursor
 import android.database.MatrixCursor
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isNull
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -55,9 +55,9 @@ class CursorExtensionsKtAccessTest(data: CursorExtensionsAccessTestData<Any>) {
             addRow(arrayOf(null))
         }
 
-        assertThat {
+        assertFailure {
             cursor.map { testThrowingAction(it, "column") }
-        }.isFailure().hasMessage("Column column must not be null")
+        }.hasMessage("Column column must not be null")
     }
 
     @Test
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/domain/usecase/validation/ValidationError.kt b/core/common/src/main/kotlin/app/k9mail/core/common/domain/usecase/validation/ValidationError.kt
new file mode 100644
index 0000000000000000000000000000000000000000..068cd486cd51035141bd5871f3fc52c49d6eecd1
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/domain/usecase/validation/ValidationError.kt
@@ -0,0 +1,3 @@
+package app.k9mail.core.common.domain.usecase.validation
+
+interface ValidationError
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/domain/usecase/validation/ValidationResult.kt b/core/common/src/main/kotlin/app/k9mail/core/common/domain/usecase/validation/ValidationResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..582cbe32165f1e1dd6922bec31a3ac8e9bb6966f
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/domain/usecase/validation/ValidationResult.kt
@@ -0,0 +1,7 @@
+package app.k9mail.core.common.domain.usecase.validation
+
+sealed interface ValidationResult {
+    object Success : ValidationResult
+
+    data class Failure(val error: ValidationError) : ValidationResult
+}
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/AbstractParser.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/AbstractParser.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5d32e34bbb126c59a3afc0a4391dc2ad709ba82f
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/AbstractParser.kt
@@ -0,0 +1,81 @@
+package app.k9mail.core.common.mail
+
+import app.k9mail.core.common.mail.EmailAddressParserError.UnexpectedCharacter
+import app.k9mail.core.common.mail.EmailAddressParserError.UnexpectedEndOfInput
+
+@Suppress("UnnecessaryAbstractClass")
+internal abstract class AbstractParser(val input: String, startIndex: Int = 0, val endIndex: Int = input.length) {
+    protected var currentIndex = startIndex
+
+    val position: Int
+        get() = currentIndex
+
+    fun endReached() = currentIndex >= endIndex
+
+    fun peek(): Char {
+        if (currentIndex >= endIndex) {
+            parserError(UnexpectedEndOfInput)
+        }
+
+        return input[currentIndex]
+    }
+
+    fun read(): Char {
+        if (currentIndex >= endIndex) {
+            parserError(UnexpectedEndOfInput)
+        }
+
+        return input[currentIndex].also { currentIndex++ }
+    }
+
+    fun expect(character: Char) {
+        if (!endReached() && peek() == character) {
+            currentIndex++
+        } else {
+            parserError(UnexpectedCharacter, message = "Expected '$character' (${character.code})")
+        }
+    }
+
+    @Suppress("SameParameterValue")
+    protected inline fun expect(displayInError: String, predicate: (Char) -> Boolean) {
+        if (!endReached() && predicate(peek())) {
+            skip()
+        } else {
+            parserError(UnexpectedCharacter, message = "Expected $displayInError")
+        }
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    protected inline fun skip() {
+        currentIndex++
+    }
+
+    protected inline fun skipWhile(crossinline predicate: (Char) -> Boolean) {
+        while (!endReached() && predicate(input[currentIndex])) {
+            currentIndex++
+        }
+    }
+
+    protected inline fun readString(block: () -> Unit): String {
+        val startIndex = currentIndex
+        block()
+        return input.substring(startIndex, currentIndex)
+    }
+
+    protected inline fun <P : AbstractParser, T> withParser(parser: P, block: P.() -> T): T {
+        try {
+            return block(parser)
+        } finally {
+            currentIndex = parser.position
+        }
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    protected inline fun parserError(
+        error: EmailAddressParserError,
+        position: Int = currentIndex,
+        message: String = error.message,
+    ): Nothing {
+        throw EmailAddressParserException(message, error, input, position)
+    }
+}
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddress.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddress.kt
index b6c3f1760b92d300d22e7aaf470191aa7097d3b4..cdf0dfd603e50497bcdd2da3a1eb4accae7ead65 100644
--- a/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddress.kt
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddress.kt
@@ -1,8 +1,138 @@
 package app.k9mail.core.common.mail
 
-@JvmInline
-value class EmailAddress(val address: String) {
+// See RFC 5321, 4.5.3.1.3.
+// The maximum length of 'Path' indirectly limits the length of 'Mailbox'.
+internal const val MAXIMUM_EMAIL_ADDRESS_LENGTH = 254
+
+// See RFC 5321, 4.5.3.1.1.
+internal const val MAXIMUM_LOCAL_PART_LENGTH = 64
+
+/**
+ * Represents an email address.
+ *
+ * This class currently doesn't support internationalized domain names (RFC 5891) or non-ASCII local parts (RFC 6532).
+ */
+class EmailAddress internal constructor(
+    val localPart: String,
+    val domain: EmailDomain,
+) {
+    val encodedLocalPart: String = if (localPart.isDotString) localPart else quoteString(localPart)
+
+    val warnings: Set<Warning>
+
     init {
-        require(address.isNotBlank()) { "Email address must not be blank" }
+        warnings = buildSet {
+            if (localPart.length > MAXIMUM_LOCAL_PART_LENGTH) {
+                add(Warning.LocalPartExceedsLengthLimit)
+            }
+
+            if (address.length > MAXIMUM_EMAIL_ADDRESS_LENGTH) {
+                add(Warning.EmailAddressExceedsLengthLimit)
+            }
+
+            if (localPart.isEmpty()) {
+                add(Warning.EmptyLocalPart)
+            }
+
+            if (!localPart.isDotString) {
+                add(Warning.QuotedStringInLocalPart)
+            }
+        }
+    }
+
+    val address: String
+        get() = "$encodedLocalPart@$domain"
+
+    val normalizedAddress: String
+        get() = "$encodedLocalPart@${domain.normalized}"
+
+    override fun toString(): String {
+        return address
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as EmailAddress
+
+        if (localPart != other.localPart) return false
+        return domain == other.domain
+    }
+
+    override fun hashCode(): Int {
+        var result = localPart.hashCode()
+        result = 31 * result + domain.hashCode()
+        return result
+    }
+
+    private fun quoteString(input: String): String {
+        return buildString {
+            append(DQUOTE)
+            for (character in input) {
+                if (!character.isQtext) {
+                    append(BACKSLASH)
+                }
+                append(character)
+            }
+            append(DQUOTE)
+        }
+    }
+
+    enum class Warning {
+        /**
+         * The local part exceeds the length limit (see RFC 5321, 4.5.3.1.1.).
+         */
+        LocalPartExceedsLengthLimit,
+
+        /**
+         * The email address exceeds the length limit (see RFC 5321, 4.5.3.1.3.; The maximum length of 'Path'
+         * indirectly limits the length of 'Mailbox').
+         */
+        EmailAddressExceedsLengthLimit,
+
+        /**
+         * The local part requires using a quoted string.
+         *
+         * This is valid, but very uncommon. Using such a local part should be avoided whenever possible.
+         */
+        QuotedStringInLocalPart,
+
+        /**
+         * The local part is the empty string.
+         *
+         * Even if you want to allow quoted strings, you probably don't want to allow this.
+         */
+        EmptyLocalPart,
+    }
+
+    companion object {
+        fun parse(address: String, config: EmailAddressParserConfig = EmailAddressParserConfig.RELAXED): EmailAddress {
+            return EmailAddressParser(address, config).parse()
+        }
     }
 }
+
+/**
+ * Converts this string to an [EmailAddress] instance using [EmailAddressParserConfig.RELAXED].
+ */
+fun String.toEmailAddressOrThrow() = EmailAddress.parse(this, EmailAddressParserConfig.RELAXED)
+
+/**
+ * Converts this string to an [EmailAddress] instance using [EmailAddressParserConfig.RELAXED].
+ */
+@Suppress("SwallowedException")
+fun String.toEmailAddressOrNull(): EmailAddress? {
+    return try {
+        EmailAddress.parse(this, EmailAddressParserConfig.RELAXED)
+    } catch (e: EmailAddressParserException) {
+        null
+    }
+}
+
+/**
+ * Convert this string into an [EmailAddress] instance using [EmailAddressParserConfig.LIMITED].
+ *
+ * Use this when validating the email address a user wants to add to an account/identity.
+ */
+fun String.toUserEmailAddress() = EmailAddress.parse(this, EmailAddressParserConfig.LIMITED)
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParser.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParser.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fd03a6e725a7df6ac5d55677a239c27e749ed1de
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParser.kt
@@ -0,0 +1,164 @@
+package app.k9mail.core.common.mail
+
+import app.k9mail.core.common.mail.EmailAddress.Warning
+import app.k9mail.core.common.mail.EmailAddressParserError.AddressLiteralsNotSupported
+import app.k9mail.core.common.mail.EmailAddressParserError.EmptyLocalPart
+import app.k9mail.core.common.mail.EmailAddressParserError.ExpectedEndOfInput
+import app.k9mail.core.common.mail.EmailAddressParserError.InvalidDomainPart
+import app.k9mail.core.common.mail.EmailAddressParserError.InvalidDotString
+import app.k9mail.core.common.mail.EmailAddressParserError.InvalidLocalPart
+import app.k9mail.core.common.mail.EmailAddressParserError.InvalidQuotedString
+import app.k9mail.core.common.mail.EmailAddressParserError.LocalPartLengthExceeded
+import app.k9mail.core.common.mail.EmailAddressParserError.LocalPartRequiresQuotedString
+import app.k9mail.core.common.mail.EmailAddressParserError.QuotedStringInLocalPart
+import app.k9mail.core.common.mail.EmailAddressParserError.TotalLengthExceeded
+
+/**
+ * Parse an email address.
+ *
+ * This class currently doesn't support internationalized domain names (RFC 5891) or non-ASCII local parts (RFC 6532).
+ *
+ * From RFC 5321:
+ * ```
+ * Mailbox                 = Local-part "@" ( Domain / address-literal )
+ *
+ * Local-part              = Dot-string / Quoted-string
+ * Dot-string              = Atom *("."  Atom)
+ * Quoted-string           = DQUOTE *QcontentSMTP DQUOTE
+ * QcontentSMTP            = qtextSMTP / quoted-pairSMTP
+ * qtextSMTP               = %d32-33 / %d35-91 / %d93-126
+ * quoted-pairSMTP         = %d92 %d32-126
+ *
+ * Domain                  - see DomainParser
+ * address-literal         - We intentionally don't support address literals
+ * ```
+ */
+internal class EmailAddressParser(
+    input: String,
+    private val config: EmailAddressParserConfig,
+) : AbstractParser(input) {
+
+    fun parse(): EmailAddress {
+        val emailAddress = readEmailAddress()
+
+        if (!endReached()) {
+            parserError(ExpectedEndOfInput)
+        }
+
+        if (
+            config.isEmailAddressLengthCheckEnabled && Warning.EmailAddressExceedsLengthLimit in emailAddress.warnings
+        ) {
+            parserError(TotalLengthExceeded)
+        }
+
+        if (config.isLocalPartLengthCheckEnabled && Warning.LocalPartExceedsLengthLimit in emailAddress.warnings) {
+            parserError(LocalPartLengthExceeded, position = input.lastIndexOf('@'))
+        }
+
+        if (
+            !config.isLocalPartRequiringQuotedStringAllowed && Warning.QuotedStringInLocalPart in emailAddress.warnings
+        ) {
+            parserError(LocalPartRequiresQuotedString, position = 0)
+        }
+
+        if (!config.isEmptyLocalPartAllowed && Warning.EmptyLocalPart in emailAddress.warnings) {
+            parserError(EmptyLocalPart, position = 1)
+        }
+
+        return emailAddress
+    }
+
+    private fun readEmailAddress(): EmailAddress {
+        val localPart = readLocalPart()
+
+        expect(AT)
+        val domain = readDomainPart()
+
+        return EmailAddress(localPart, domain)
+    }
+
+    private fun readLocalPart(): String {
+        val character = peek()
+        val localPart = when {
+            character.isAtext -> {
+                readDotString()
+            }
+            character == DQUOTE -> {
+                if (config.isQuotedLocalPartAllowed) {
+                    readQuotedString()
+                } else {
+                    parserError(QuotedStringInLocalPart)
+                }
+            }
+            else -> {
+                parserError(InvalidLocalPart)
+            }
+        }
+
+        return localPart
+    }
+
+    private fun readDotString(): String {
+        return buildString {
+            appendAtom()
+
+            while (!endReached() && peek() == DOT) {
+                expect(DOT)
+                append(DOT)
+                appendAtom()
+            }
+        }
+    }
+
+    private fun StringBuilder.appendAtom() {
+        val startIndex = currentIndex
+        skipWhile { it.isAtext }
+
+        if (startIndex == currentIndex) {
+            parserError(InvalidDotString)
+        }
+
+        append(input, startIndex, currentIndex)
+    }
+
+    private fun readQuotedString(): String {
+        return buildString {
+            expect(DQUOTE)
+
+            while (!endReached()) {
+                val character = peek()
+                when {
+                    character.isQtext -> append(read())
+                    character == BACKSLASH -> {
+                        expect(BACKSLASH)
+                        val escapedCharacter = read()
+                        if (!escapedCharacter.isQuotedChar) {
+                            parserError(InvalidQuotedString)
+                        }
+                        append(escapedCharacter)
+                    }
+
+                    character == DQUOTE -> break
+                    else -> parserError(InvalidQuotedString)
+                }
+            }
+
+            expect(DQUOTE)
+        }
+    }
+
+    private fun readDomainPart(): EmailDomain {
+        val character = peek()
+        return when {
+            character.isLetDig -> readDomain()
+            character == '[' -> parserError(AddressLiteralsNotSupported)
+            else -> parserError(InvalidDomainPart)
+        }
+    }
+
+    private fun readDomain(): EmailDomain {
+        return withParser(EmailDomainParser(input, currentIndex)) {
+            readDomain()
+        }
+    }
+}
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserConfig.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserConfig.kt
new file mode 100644
index 0000000000000000000000000000000000000000..325b97975ce4a524a0f80d783b20788257d473a8
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserConfig.kt
@@ -0,0 +1,65 @@
+package app.k9mail.core.common.mail
+
+/**
+ * Configuration to control the behavior when parsing an email address into [EmailAddress].
+ *
+ * @param isLocalPartLengthCheckEnabled When this is `true` the length of the local part is checked to make sure it
+ * doesn't exceed the specified limit (see RFC 5321, 4.5.3.1.1.).
+ *
+ * @param isEmailAddressLengthCheckEnabled When this is `true` the length of the whole email address is checked to make
+ * sure it doesn't exceed the specified limit (see RFC 5321, 4.5.3.1.3.; The maximum length of 'Path' indirectly limits
+ * the length of 'Mailbox').
+ *
+ * @param isQuotedLocalPartAllowed When this is `true`, the parsing step allows email addresses with a local part
+ * encoded as quoted string, e.g. `"foo bar"@domain.example`. Otherwise, the parser will throw an
+ * [EmailAddressParserException] as soon as a quoted string is encountered.
+ * Quoted strings in local parts are not widely used. It's recommended to disallow them whenever possible.
+ *
+ * @param isLocalPartRequiringQuotedStringAllowed Email addresses whose local part requires the use of a quoted string
+ * are only allowed when this is `true`. This is separate from [isQuotedLocalPartAllowed] because one might want to
+ * allow email addresses that unnecessarily use a quoted string, e.g. `"test"@domain.example`
+ * ([isQuotedLocalPartAllowed] = `true`, [isLocalPartRequiringQuotedStringAllowed] = `false`; [EmailAddress] will not
+ * retain the original form and treat this address exactly like `test@domain.example`). When allowing this, remember to
+ * use the value of [EmailAddress.address] instead of retaining the original user input.
+ *
+ * The value of this property is ignored if [isQuotedLocalPartAllowed] is `false`.
+ *
+ * @param isEmptyLocalPartAllowed Email addresses with an empty local part (e.g. `""@domain.example`) are only allowed
+ * if this value is `true`.
+ *
+ * The value of this property is ignored if at least one of [isQuotedLocalPartAllowed] and
+ * [isLocalPartRequiringQuotedStringAllowed] is `false`.
+ */
+data class EmailAddressParserConfig(
+    val isLocalPartLengthCheckEnabled: Boolean,
+    val isEmailAddressLengthCheckEnabled: Boolean,
+    val isQuotedLocalPartAllowed: Boolean,
+    val isLocalPartRequiringQuotedStringAllowed: Boolean,
+    val isEmptyLocalPartAllowed: Boolean = false,
+) {
+    companion object {
+        /**
+         * This allows local parts requiring quoted strings and disables length checks for the local part and the
+         * whole email address.
+         */
+        val RELAXED = EmailAddressParserConfig(
+            isLocalPartLengthCheckEnabled = false,
+            isEmailAddressLengthCheckEnabled = false,
+            isQuotedLocalPartAllowed = true,
+            isLocalPartRequiringQuotedStringAllowed = true,
+            isEmptyLocalPartAllowed = false,
+        )
+
+        /**
+         * This only allows a subset of valid email addresses. Use this when validating the email address a user wants
+         * to add to an account/identity.
+         */
+        val LIMITED = EmailAddressParserConfig(
+            isLocalPartLengthCheckEnabled = true,
+            isEmailAddressLengthCheckEnabled = true,
+            isQuotedLocalPartAllowed = false,
+            isLocalPartRequiringQuotedStringAllowed = false,
+            isEmptyLocalPartAllowed = false,
+        )
+    }
+}
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserError.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserError.kt
new file mode 100644
index 0000000000000000000000000000000000000000..61933cff0fdae1e8e86bf14c306c4fa88b543333
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserError.kt
@@ -0,0 +1,22 @@
+package app.k9mail.core.common.mail
+
+enum class EmailAddressParserError(internal val message: String) {
+    UnexpectedEndOfInput("End of input reached unexpectedly"),
+    ExpectedEndOfInput("Expected end of input"),
+    InvalidLocalPart("Expected 'Dot-string' or 'Quoted-string'"),
+    InvalidDotString("Expected 'Dot-string'"),
+    InvalidQuotedString("Expected 'Quoted-string'"),
+    InvalidDomainPart("Expected 'Domain' or 'address-literal'"),
+    AddressLiteralsNotSupported("Address literals are not supported"),
+
+    LocalPartLengthExceeded("Local part exceeds maximum length of $MAXIMUM_LOCAL_PART_LENGTH characters"),
+    DnsLabelLengthExceeded("DNS labels exceeds maximum length of $MAXIMUM_DNS_LABEL_LENGTH characters"),
+    DomainLengthExceeded("Domain exceeds maximum length of $MAXIMUM_DOMAIN_LENGTH characters"),
+    TotalLengthExceeded("The email address exceeds the maximum length of $MAXIMUM_EMAIL_ADDRESS_LENGTH characters"),
+
+    QuotedStringInLocalPart("Quoted string in local part is not allowed by config"),
+    LocalPartRequiresQuotedString("Local part requiring the use of a quoted string is not allowed by config"),
+    EmptyLocalPart("Empty local part is not allowed by config"),
+
+    UnexpectedCharacter("Caller needs to provide message"),
+}
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserException.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserException.kt
new file mode 100644
index 0000000000000000000000000000000000000000..074b87c98594649913802033c5793b533f1aeaca
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserException.kt
@@ -0,0 +1,8 @@
+package app.k9mail.core.common.mail
+
+class EmailAddressParserException internal constructor(
+    message: String,
+    val error: EmailAddressParserError,
+    val input: String,
+    val position: Int,
+) : RuntimeException(message)
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailDomain.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailDomain.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9c8800821e25f1ec46604613576461375f642631
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailDomain.kt
@@ -0,0 +1,51 @@
+package app.k9mail.core.common.mail
+
+import app.k9mail.core.common.net.Domain
+
+/**
+ * The domain part of an email address.
+ *
+ * @param value String representation of the email domain with the original capitalization.
+ */
+class EmailDomain internal constructor(val value: String) {
+    /**
+     * The normalized (converted to lower case) string representation of this email domain.
+     */
+    val normalized: String = value.lowercase()
+
+    /**
+     * Returns this email domain with the original capitalization.
+     *
+     * @see value
+     */
+    override fun toString(): String = value
+
+    /**
+     * Compares the normalized string representations of two [EmailDomain] instances.
+     */
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as EmailDomain
+
+        return normalized == other.normalized
+    }
+
+    override fun hashCode(): Int {
+        return normalized.hashCode()
+    }
+
+    companion object {
+        /**
+         * Parses the string representation of an email domain.
+         *
+         * @throws EmailAddressParserException in case of an error.
+         */
+        fun parse(domain: String): EmailDomain {
+            return EmailDomainParser(domain).parseDomain()
+        }
+    }
+}
+
+fun EmailDomain.toDomain() = Domain(value)
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailDomainParser.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailDomainParser.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d7a9badf424bf6b6573a17cf7fadac098bf7ac33
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailDomainParser.kt
@@ -0,0 +1,92 @@
+package app.k9mail.core.common.mail
+
+import app.k9mail.core.common.mail.EmailAddressParserError.DnsLabelLengthExceeded
+import app.k9mail.core.common.mail.EmailAddressParserError.DomainLengthExceeded
+import app.k9mail.core.common.mail.EmailAddressParserError.ExpectedEndOfInput
+
+// See RFC 1035, 2.3.4.
+// For the string representation used in emails (labels separated by dots, no final dot allowed), we end up with a
+// maximum of 253 characters.
+internal const val MAXIMUM_DOMAIN_LENGTH = 253
+
+// See RFC 1035, 2.3.4.
+internal const val MAXIMUM_DNS_LABEL_LENGTH = 63
+
+/**
+ * Parser for domain names in email addresses.
+ *
+ * From RFC 5321:
+ * ```
+ * Domain                  = sub-domain *("." sub-domain)
+ * sub-domain              = Let-dig [Ldh-str]
+ * Let-dig                 = ALPHA / DIGIT
+ * Ldh-str                 = *( ALPHA / DIGIT / "-" ) Let-dig
+ * ```
+ */
+internal class EmailDomainParser(
+    input: String,
+    startIndex: Int = 0,
+    endIndex: Int = input.length,
+) : AbstractParser(input, startIndex, endIndex) {
+
+    fun parseDomain(): EmailDomain {
+        val domain = readDomain()
+
+        if (!endReached()) {
+            parserError(ExpectedEndOfInput)
+        }
+
+        return domain
+    }
+
+    fun readDomain(): EmailDomain {
+        val domain = readString {
+            expectSubDomain()
+
+            while (!endReached() && peek() == DOT) {
+                expect(DOT)
+                expectSubDomain()
+            }
+        }
+
+        if (domain.length > MAXIMUM_DOMAIN_LENGTH) {
+            parserError(DomainLengthExceeded)
+        }
+
+        return EmailDomain(domain)
+    }
+
+    private fun expectSubDomain() {
+        val startIndex = currentIndex
+
+        expectLetDig()
+
+        var requireLetDig = false
+        while (!endReached()) {
+            val character = peek()
+            when {
+                character == HYPHEN -> {
+                    requireLetDig = true
+                    expect(HYPHEN)
+                }
+                character.isLetDig -> {
+                    requireLetDig = false
+                    expectLetDig()
+                }
+                else -> break
+            }
+        }
+
+        if (requireLetDig) {
+            expectLetDig()
+        }
+
+        if (currentIndex - startIndex > MAXIMUM_DNS_LABEL_LENGTH) {
+            parserError(DnsLabelLengthExceeded)
+        }
+    }
+
+    private fun expectLetDig() {
+        expect("'Let-dig'") { it.isLetDig }
+    }
+}
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/Tokens.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/Tokens.kt
new file mode 100644
index 0000000000000000000000000000000000000000..079556642766cbd31a85aa97d477c17ba965e0d3
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/Tokens.kt
@@ -0,0 +1,66 @@
+@file:Suppress("MagicNumber")
+
+package app.k9mail.core.common.mail
+
+internal const val DQUOTE = '"'
+internal const val DOT = '.'
+internal const val AT = '@'
+internal const val BACKSLASH = '\\'
+internal const val HYPHEN = '-'
+
+internal val ATEXT_EXTRA = charArrayOf(
+    '!', '#', '$', '%', '&', '\'', '*', '+', '-', '/', '=', '?', '^', '_', '`', '{', '|', '}', '~',
+)
+
+// RFC 5234: ALPHA = %x41-5A / %x61-7A    ; A-Z / a-z
+internal val Char.isALPHA
+    get() = this in 'A'..'Z' || this in 'a'..'z'
+
+// RFC 5234: DIGIT = %x30-39    ; 0-9
+internal val Char.isDIGIT
+    get() = this in '0'..'9'
+
+// RFC 5322:
+// atext = ALPHA / DIGIT /    ; Printable US-ASCII
+//         "!" / "#" /        ;  characters not including
+//         "$" / "%" /        ;  specials.  Used for atoms.
+//         "&" / "'" /
+//         "*" / "+" /
+//         "-" / "/" /
+//         "=" / "?" /
+//         "^" / "_" /
+//         "`" / "{" /
+//         "|" / "}" /
+//         "~"
+internal val Char.isAtext
+    get() = isALPHA || isDIGIT || this in ATEXT_EXTRA
+
+// RFC 5321: qtextSMTP = %d32-33 / %d35-91 / %d93-126
+internal val Char.isQtext
+    get() = code.let { it in 32..33 || it in 35..91 || it in 93..126 }
+
+// RFC 5321: second character of quoted-pairSMTP = %d92 %d32-126
+internal val Char.isQuotedChar
+    get() = code in 32..126
+
+// RFC 5321:
+// Dot-string = Atom *("."  Atom)
+// Atom       = 1*atext
+internal val String.isDotString: Boolean
+    get() {
+        if (isEmpty() || this[0] == DOT || this[lastIndex] == DOT) return false
+        for (i in 0..lastIndex) {
+            val character = this[i]
+            when {
+                character == DOT -> if (this[i - 1] == DOT) return false
+                character.isAtext -> Unit
+                else -> return false
+            }
+        }
+
+        return true
+    }
+
+// RFC 5321: Let-dig = ALPHA / DIGIT
+internal val Char.isLetDig
+    get() = isALPHA || isDIGIT
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/net/Domain.kt b/core/common/src/main/kotlin/app/k9mail/core/common/net/Domain.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4c5216134c7edabc8bee38d7130a7d143656c0f2
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/net/Domain.kt
@@ -0,0 +1,10 @@
+package app.k9mail.core.common.net
+
+@JvmInline
+value class Domain(val value: String) {
+    init {
+        requireNotNull(HostNameUtils.isLegalHostName(value)) { "Not a valid domain name: '$value'" }
+    }
+}
+
+fun String.toDomain() = Domain(this)
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/net/HostNameUtils.kt b/core/common/src/main/kotlin/app/k9mail/core/common/net/HostNameUtils.kt
new file mode 100644
index 0000000000000000000000000000000000000000..91e1f2ba3ac67a38af6d3fa47777e8d049167cfb
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/net/HostNameUtils.kt
@@ -0,0 +1,225 @@
+package app.k9mail.core.common.net
+
+/**
+ * Code to check the validity of host names and IP addresses.
+ *
+ * Based on
+ * [mailnews/base/src/hostnameUtils.jsm](https://searchfox.org/comm-central/source/mailnews/base/src/hostnameUtils.jsm)
+ *
+ * Note: The naming of these functions is inconsistent with the rest of the Android project to match the original
+ * source. Please use more appropriate names when refactoring this code.
+ */
+@Suppress("MagicNumber", "ReturnCount")
+object HostNameUtils {
+    /**
+     * Check if `hostName` is an IP address or a valid hostname.
+     *
+     * @return Unobscured host name if `hostName` is valid.
+     */
+    fun isLegalHostNameOrIP(hostName: String): String? {
+        /*
+         RFC 1123:
+         Whenever a user inputs the identity of an Internet host, it SHOULD
+         be possible to enter either (1) a host domain name or (2) an IP
+         address in dotted-decimal ("#.#.#.#") form.  The host SHOULD check
+         the string syntactically for a dotted-decimal number before
+         looking it up in the Domain Name System.
+        */
+
+        return isLegalIPAddress(hostName) ?: isLegalHostName(hostName)
+    }
+
+    /**
+     * Check if `hostName` is a valid IP address (IPv4 or IPv6).
+     *
+     * @return Unobscured canonicalized IPv4 or IPv6 address if it is valid, otherwise `null`.
+     */
+    fun isLegalIPAddress(hostName: String): String? {
+        return isLegalIPv4Address(hostName) ?: isLegalIPv6Address(hostName)
+    }
+
+    /**
+     * Check if `hostName` is a valid IPv4 address.
+     *
+     * @return Unobscured canonicalized address if `hostName` is an IPv4 address. Returns `null` if it's not.
+     */
+    fun isLegalIPv4Address(hostName: String): String? {
+        // Break the IP address down into individual components.
+        val ipComponentStrings = hostName.split(".")
+        if (ipComponentStrings.size != 4) {
+            return null
+        }
+
+        val ipComponents = ipComponentStrings.map { toIPv4NumericComponent(it) }
+
+        if (ipComponents.any { it == null }) {
+            return null
+        }
+
+        // First component of zero is not valid.
+        if (ipComponents.first() == 0) {
+            return null
+        }
+
+        return hostName
+    }
+
+    /**
+     * Converts an IPv4 address component to a number if it is valid. Returns `null` otherwise.
+     */
+    private fun toIPv4NumericComponent(value: String): Int? {
+        return if (IPV4_COMPONENT_PATTERN.matches(value)) {
+            value.toInt(radix = 10).takeIf { it in 0..255 }
+        } else {
+            null
+        }
+    }
+
+    /**
+     * Check if `hostName` is a valid IPv6 address.
+     *
+     * @returns Unobscured canonicalized address if `hostName` is an IPv6 address. Returns `null` if it's not.
+     */
+    fun isLegalIPv6Address(hostName: String): String? {
+        // Break the IP address down into individual components.
+        val ipComponentStrings = hostName.lowercase().split(":")
+
+        // Make sure there are at least 3 components.
+        if (ipComponentStrings.size < 3) {
+            return null
+        }
+
+        // Take care if the last part is written in decimal using dots as separators.
+        val lastPart = isLegalIPv4Address(ipComponentStrings.last())
+        val ipComponentHexStrings = if (lastPart != null) {
+            val lastPartComponents = lastPart.split(".").map { it.toInt(radix = 10) }
+            // Convert it into standard IPv6 components.
+            val part1 = ((lastPartComponents[0] shl 8) or lastPartComponents[1]).toString(radix = 16)
+            val part2 = ((lastPartComponents[2] shl 8) or lastPartComponents[3]).toString(radix = 16)
+
+            ipComponentStrings.subList(0, ipComponentStrings.lastIndex) + part1 + part2
+        } else {
+            ipComponentStrings
+        }
+
+        // Make sure that there is only one empty component.
+        var emptyIndex = -1
+        for (index in 1 until ipComponentHexStrings.lastIndex) {
+            if (ipComponentHexStrings[index] == "") {
+                // If we already found an empty component return null.
+                if (emptyIndex != -1) {
+                    return null
+                }
+
+                emptyIndex = index
+            }
+        }
+
+        // If we found an empty component, extend it.
+        val fullIpComponentStrings = if (emptyIndex != -1) {
+            buildList(capacity = 8) {
+                for (i in 0 until emptyIndex) {
+                    add(ipComponentHexStrings[i])
+                }
+
+                repeat(8 - ipComponentHexStrings.size + 1) {
+                    add("0")
+                }
+
+                for (i in (emptyIndex + 1)..ipComponentHexStrings.lastIndex) {
+                    add(ipComponentHexStrings[i])
+                }
+            }
+        } else {
+            ipComponentHexStrings
+        }
+
+        // Make sure there are 8 components.
+        if (fullIpComponentStrings.size != 8) {
+            return null
+        }
+
+        // Format all components to 4 character hex value.
+        val ipComponents = fullIpComponentStrings.map { ipComponentString ->
+            if (ipComponentString == "") {
+                0
+            } else if (IPV6_COMPONENT_PATTERN.matches(ipComponentString)) {
+                ipComponentString.toInt(radix = 16)
+            } else {
+                return null
+            }
+        }
+
+        // Treat 0000:0000:0000:0000:0000:0000:0000:0000 as an invalid IPv6 address.
+        if (ipComponents.all { it == 0 }) {
+            return null
+        }
+
+        // Pad the component with 0:s.
+        val canonicalIpComponents = ipComponents.map { it.toString(radix = 16).padStart(4, '0') }
+
+        // TODO: support Zone indices in Link-local addresses? Currently they are rejected.
+        // http://en.wikipedia.org/wiki/IPv6_address#Link-local_addresses_and_zone_indices
+
+        return canonicalIpComponents.joinToString(":")
+    }
+
+    /**
+     * Check if `hostName` is a valid hostname.
+     *
+     * @returns The host name if it is valid. Returns `null` if it's not.
+     */
+    fun isLegalHostName(hostName: String): String? {
+        /*
+         RFC 952:
+         A "name" (Net, Host, Gateway, or Domain name) is a text string up
+         to 24 characters drawn from the alphabet (A-Z), digits (0-9), minus
+         sign (-), and period (.).  Note that periods are only allowed when
+         they serve to delimit components of "domain style names". (See
+         RFC-921, "Domain Name System Implementation Schedule", for
+         background).  No blank or space characters are permitted as part of a
+         name. No distinction is made between upper and lower case.  The first
+         character must be an alpha character.  The last character must not be
+         a minus sign or period.
+
+         RFC 1123:
+         The syntax of a legal Internet host name was specified in RFC-952
+         [DNS:4].  One aspect of host name syntax is hereby changed: the
+         restriction on the first character is relaxed to allow either a
+         letter or a digit.  Host software MUST support this more liberal
+         syntax.
+
+         Host software MUST handle host names of up to 63 characters and
+         SHOULD handle host names of up to 255 characters.
+
+         RFC 1034:
+         Relative names are either taken relative to a well known origin, or to a
+         list of domains used as a search list.  Relative names appear mostly at
+         the user interface, where their interpretation varies from
+         implementation to implementation, and in master files, where they are
+         relative to a single origin domain name.  The most common interpretation
+         uses the root "." as either the single origin or as one of the members
+         of the search list, so a multi-label relative name is often one where
+         the trailing dot has been omitted to save typing.
+
+         Since a complete domain name ends with the root label, this leads to
+         a printed form which ends in a dot.
+        */
+
+        return hostName.takeIf { hostName.length <= 255 && HOST_PATTERN.matches(hostName) }
+    }
+
+    /**
+     * Clean up the hostname or IP. Usually used to sanitize a value input by the user.
+     * It is usually applied before we know if the hostname is even valid.
+     */
+    fun cleanUpHostName(hostName: String): String {
+        return hostName.trim()
+    }
+
+    private const val LDH_LABEL = "([a-z0-9]|[a-z0-9][a-z0-9\\-]{0,61}[a-z0-9])"
+    private val HOST_PATTERN = """($LDH_LABEL\.)*$LDH_LABEL\.?""".toRegex(RegexOption.IGNORE_CASE)
+
+    private val IPV4_COMPONENT_PATTERN = "(0|([1-9][0-9]{0,2}))".toRegex()
+    private val IPV6_COMPONENT_PATTERN = "[0-9a-f]{1,4}".toRegex()
+}
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/net/Hostname.kt b/core/common/src/main/kotlin/app/k9mail/core/common/net/Hostname.kt
new file mode 100644
index 0000000000000000000000000000000000000000..21286aca38fda90e4c610216e3a62636961d2a39
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/net/Hostname.kt
@@ -0,0 +1,15 @@
+package app.k9mail.core.common.net
+
+/**
+ * Represents a hostname, IPv4, or IPv6 address.
+ */
+@JvmInline
+value class Hostname(val value: String) {
+    init {
+        requireNotNull(HostNameUtils.isLegalHostNameOrIP(value)) { "Not a valid domain or IP: '$value'" }
+    }
+}
+
+fun String.toHostname() = Hostname(this)
+
+fun Hostname.isIpAddress(): Boolean = HostNameUtils.isLegalIPAddress(value) != null
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/net/Port.kt b/core/common/src/main/kotlin/app/k9mail/core/common/net/Port.kt
new file mode 100644
index 0000000000000000000000000000000000000000..73d0232730041b5cc910d954da29ce4c4f35a2df
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/net/Port.kt
@@ -0,0 +1,11 @@
+package app.k9mail.core.common.net
+
+@Suppress("MagicNumber")
+@JvmInline
+value class Port(val value: Int) {
+    init {
+        require(value in 1..65535) { "Not a valid port number: $value" }
+    }
+}
+
+fun Int.toPort() = Port(this)
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressParserTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressParserTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..48431066a4dcc3d30bbda9ab8a7617ec97bbd074
--- /dev/null
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressParserTest.kt
@@ -0,0 +1,321 @@
+package app.k9mail.core.common.mail
+
+import app.k9mail.core.common.mail.EmailAddressParserError.AddressLiteralsNotSupported
+import app.k9mail.core.common.mail.EmailAddressParserError.EmptyLocalPart
+import app.k9mail.core.common.mail.EmailAddressParserError.ExpectedEndOfInput
+import app.k9mail.core.common.mail.EmailAddressParserError.InvalidDomainPart
+import app.k9mail.core.common.mail.EmailAddressParserError.InvalidDotString
+import app.k9mail.core.common.mail.EmailAddressParserError.InvalidLocalPart
+import app.k9mail.core.common.mail.EmailAddressParserError.InvalidQuotedString
+import app.k9mail.core.common.mail.EmailAddressParserError.LocalPartLengthExceeded
+import app.k9mail.core.common.mail.EmailAddressParserError.LocalPartRequiresQuotedString
+import app.k9mail.core.common.mail.EmailAddressParserError.QuotedStringInLocalPart
+import app.k9mail.core.common.mail.EmailAddressParserError.TotalLengthExceeded
+import app.k9mail.core.common.mail.EmailAddressParserError.UnexpectedCharacter
+import assertk.all
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.contains
+import assertk.assertions.hasMessage
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import kotlin.test.Test
+
+class EmailAddressParserTest {
+    @Test
+    fun `simple address`() {
+        val emailAddress = parseEmailAddress("alice@domain.example")
+
+        assertThat(emailAddress.localPart).isEqualTo("alice")
+        assertThat(emailAddress.domain).isEqualTo(EmailDomain("domain.example"))
+    }
+
+    @Test
+    fun `local part containing dot`() {
+        val emailAddress = parseEmailAddress("alice.lastname@domain.example")
+
+        assertThat(emailAddress.localPart).isEqualTo("alice.lastname")
+        assertThat(emailAddress.domain).isEqualTo(EmailDomain("domain.example"))
+    }
+
+    @Test
+    fun `quoted local part`() {
+        val emailAddress = parseEmailAddress(
+            address = "\"one two\"@domain.example",
+            isLocalPartRequiringQuotedStringAllowed = true,
+        )
+
+        assertThat(emailAddress.localPart).isEqualTo("one two")
+        assertThat(emailAddress.domain).isEqualTo(EmailDomain("domain.example"))
+    }
+
+    @Test
+    fun `quoted local part not allowed`() {
+        assertFailure {
+            parseEmailAddress(
+                address = "\"one two\"@domain.example",
+                isQuotedLocalPartAllowed = true,
+                isLocalPartRequiringQuotedStringAllowed = false,
+            )
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(LocalPartRequiresQuotedString)
+            prop(EmailAddressParserException::position).isEqualTo(0)
+            hasMessage("Local part requiring the use of a quoted string is not allowed by config")
+        }
+    }
+
+    @Test
+    fun `unnecessarily quoted local part`() {
+        val emailAddress = parseEmailAddress(
+            address = "\"user\"@domain.example",
+            isQuotedLocalPartAllowed = true,
+            isLocalPartRequiringQuotedStringAllowed = false,
+        )
+
+        assertThat(emailAddress.localPart).isEqualTo("user")
+        assertThat(emailAddress.domain).isEqualTo(EmailDomain("domain.example"))
+        assertThat(emailAddress.address).isEqualTo("user@domain.example")
+    }
+
+    @Test
+    fun `unnecessarily quoted local part not allowed`() {
+        assertFailure {
+            parseEmailAddress("\"user\"@domain.example", isQuotedLocalPartAllowed = false)
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(QuotedStringInLocalPart)
+            prop(EmailAddressParserException::position).isEqualTo(0)
+            hasMessage("Quoted string in local part is not allowed by config")
+        }
+    }
+
+    @Test
+    fun `quoted local part containing double quote character`() {
+        val emailAddress = parseEmailAddress(
+            address = """"a\"b"@domain.example""",
+            isLocalPartRequiringQuotedStringAllowed = true,
+        )
+
+        assertThat(emailAddress.localPart).isEqualTo("a\"b")
+        assertThat(emailAddress.domain).isEqualTo(EmailDomain("domain.example"))
+        assertThat(emailAddress.address).isEqualTo(""""a\"b"@domain.example""")
+    }
+
+    @Test
+    fun `empty local part`() {
+        val emailAddress = parseEmailAddress("\"\"@domain.example", isEmptyLocalPartAllowed = true)
+
+        assertThat(emailAddress.localPart).isEqualTo("")
+        assertThat(emailAddress.domain).isEqualTo(EmailDomain("domain.example"))
+        assertThat(emailAddress.address).isEqualTo("\"\"@domain.example")
+    }
+
+    @Test
+    fun `empty local part not allowed`() {
+        assertFailure {
+            parseEmailAddress(
+                address = "\"\"@domain.example",
+                isLocalPartRequiringQuotedStringAllowed = true,
+                isEmptyLocalPartAllowed = false,
+            )
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(EmptyLocalPart)
+            prop(EmailAddressParserException::position).isEqualTo(1)
+            hasMessage("Empty local part is not allowed by config")
+        }
+    }
+
+    @Test
+    fun `IPv4 address literal`() {
+        assertFailure {
+            parseEmailAddress("user@[255.0.100.23]")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(AddressLiteralsNotSupported)
+            prop(EmailAddressParserException::position).isEqualTo(5)
+            hasMessage("Address literals are not supported")
+        }
+    }
+
+    @Test
+    fun `IPv6 address literal`() {
+        assertFailure {
+            parseEmailAddress("user@[IPv6:2001:0db8:0000:0000:0000:ff00:0042:8329]")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(AddressLiteralsNotSupported)
+            prop(EmailAddressParserException::position).isEqualTo(5)
+            hasMessage("Address literals are not supported")
+        }
+    }
+
+    @Test
+    fun `domain part starts with unsupported value`() {
+        assertFailure {
+            parseEmailAddress("user@ä")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(InvalidDomainPart)
+            prop(EmailAddressParserException::position).isEqualTo(5)
+            hasMessage("Expected 'Domain' or 'address-literal'")
+        }
+    }
+
+    @Test
+    fun `obsolete syntax`() {
+        assertFailure {
+            parseEmailAddress("\"quoted\".atom@domain.example", isLocalPartRequiringQuotedStringAllowed = true)
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(UnexpectedCharacter)
+            prop(EmailAddressParserException::position).isEqualTo(8)
+            hasMessage("Expected '@' (64)")
+        }
+    }
+
+    @Test
+    fun `local part starting with dot`() {
+        assertFailure {
+            parseEmailAddress(".invalid@domain.example")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(InvalidLocalPart)
+            prop(EmailAddressParserException::position).isEqualTo(0)
+            hasMessage("Expected 'Dot-string' or 'Quoted-string'")
+        }
+    }
+
+    @Test
+    fun `local part ending with dot`() {
+        assertFailure {
+            parseEmailAddress("invalid.@domain.example")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(InvalidDotString)
+            prop(EmailAddressParserException::position).isEqualTo(8)
+            hasMessage("Expected 'Dot-string'")
+        }
+    }
+
+    @Test
+    fun `quoted local part missing closing double quote`() {
+        assertFailure {
+            parseEmailAddress("\"invalid@domain.example", isLocalPartRequiringQuotedStringAllowed = true)
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(UnexpectedCharacter)
+            prop(EmailAddressParserException::position).isEqualTo(23)
+            hasMessage("Expected '\"' (34)")
+        }
+    }
+
+    @Test
+    fun `quoted text containing unsupported character`() {
+        assertFailure {
+            parseEmailAddress("\"ä\"@domain.example", isLocalPartRequiringQuotedStringAllowed = true)
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(InvalidQuotedString)
+            prop(EmailAddressParserException::position).isEqualTo(1)
+            hasMessage("Expected 'Quoted-string'")
+        }
+    }
+
+    @Test
+    fun `quoted text containing unsupported escaped character`() {
+        assertFailure {
+            parseEmailAddress(""""\ä"@domain.example""", isLocalPartRequiringQuotedStringAllowed = true)
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(InvalidQuotedString)
+            prop(EmailAddressParserException::position).isEqualTo(3)
+            hasMessage("Expected 'Quoted-string'")
+        }
+    }
+
+    @Test
+    fun `local part exceeds maximum size with length check enabled`() {
+        assertFailure {
+            parseEmailAddress(
+                address = "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx12345@domain.example",
+                isLocalPartLengthCheckEnabled = true,
+            )
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(LocalPartLengthExceeded)
+            prop(EmailAddressParserException::position).isEqualTo(65)
+            hasMessage("Local part exceeds maximum length of 64 characters")
+        }
+    }
+
+    @Test
+    fun `local part exceeds maximum size with length check disabled`() {
+        val input = "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx12345@domain.example"
+
+        val emailAddress = parseEmailAddress(address = input, isLocalPartLengthCheckEnabled = false)
+
+        assertThat(emailAddress.localPart)
+            .isEqualTo("1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx12345")
+        assertThat(emailAddress.domain).isEqualTo(EmailDomain("domain.example"))
+        assertThat(emailAddress.address).isEqualTo(input)
+        assertThat(emailAddress.warnings).contains(EmailAddress.Warning.LocalPartExceedsLengthLimit)
+    }
+
+    @Test
+    fun `email exceeds maximum size with length check enabled`() {
+        assertFailure {
+            parseEmailAddress(
+                address = "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx1234@" +
+                    "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+                    "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+                    "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx12",
+                isEmailAddressLengthCheckEnabled = true,
+            )
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(TotalLengthExceeded)
+            prop(EmailAddressParserException::position).isEqualTo(255)
+            hasMessage("The email address exceeds the maximum length of 254 characters")
+        }
+    }
+
+    @Test
+    fun `email exceeds maximum size with length check disabled`() {
+        val input = "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx1234@" +
+            "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+            "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+            "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx12"
+
+        val emailAddress = parseEmailAddress(address = input, isEmailAddressLengthCheckEnabled = false)
+
+        assertThat(emailAddress.localPart)
+            .isEqualTo("1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx1234")
+        assertThat(emailAddress.domain).isEqualTo(
+            EmailDomain(
+                "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+                    "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+                    "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx12",
+            ),
+        )
+        assertThat(emailAddress.address).isEqualTo(input)
+        assertThat(emailAddress.warnings).contains(EmailAddress.Warning.EmailAddressExceedsLengthLimit)
+    }
+
+    @Test
+    fun `input contains additional character`() {
+        assertFailure {
+            parseEmailAddress("test@domain.example#")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(ExpectedEndOfInput)
+            prop(EmailAddressParserException::position).isEqualTo(19)
+            hasMessage("Expected end of input")
+        }
+    }
+
+    private fun parseEmailAddress(
+        address: String,
+        isLocalPartLengthCheckEnabled: Boolean = false,
+        isEmailAddressLengthCheckEnabled: Boolean = false,
+        isEmptyLocalPartAllowed: Boolean = false,
+        isLocalPartRequiringQuotedStringAllowed: Boolean = isEmptyLocalPartAllowed,
+        isQuotedLocalPartAllowed: Boolean = isLocalPartRequiringQuotedStringAllowed,
+    ): EmailAddress {
+        val config = EmailAddressParserConfig(
+            isLocalPartLengthCheckEnabled,
+            isEmailAddressLengthCheckEnabled,
+            isQuotedLocalPartAllowed,
+            isLocalPartRequiringQuotedStringAllowed,
+            isEmptyLocalPartAllowed,
+        )
+        return EmailAddressParser(address, config).parse()
+    }
+}
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressTest.kt
index f37a3b4ef2c6a32c0d9f4b6c4e1c7895bb88848c..4567aba0e6bb1eb172ab9d7d972746738242a764 100644
--- a/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressTest.kt
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressTest.kt
@@ -1,29 +1,60 @@
 package app.k9mail.core.common.mail
 
+import app.k9mail.core.common.mail.EmailAddress.Warning
 import assertk.assertThat
+import assertk.assertions.containsExactlyInAnyOrder
+import assertk.assertions.isEmpty
 import assertk.assertions.isEqualTo
+import assertk.assertions.isSameAs
 import kotlin.test.Test
-import kotlin.test.assertFails
-
-internal class EmailAddressTest {
 
+class EmailAddressTest {
     @Test
-    fun `should reject blank email address`() {
-        assertFails("Email address must not be blank") {
-            EmailAddress("")
-        }
+    fun `simple email address`() {
+        val domain = EmailDomain("DOMAIN.example")
+        val emailAddress = EmailAddress(localPart = "user", domain = domain)
+
+        assertThat(emailAddress.localPart).isEqualTo("user")
+        assertThat(emailAddress.encodedLocalPart).isEqualTo("user")
+        assertThat(emailAddress.domain).isSameAs(domain)
+        assertThat(emailAddress.address).isEqualTo("user@DOMAIN.example")
+        assertThat(emailAddress.normalizedAddress).isEqualTo("user@domain.example")
+        assertThat(emailAddress.toString()).isEqualTo("user@DOMAIN.example")
+        assertThat(emailAddress.warnings).isEmpty()
     }
 
     @Test
-    fun `should return email address`() {
-        val emailAddress = EmailAddress(EMAIL_ADDRESS)
+    fun `local part that requires use of quoted string`() {
+        val emailAddress = EmailAddress(localPart = "foo bar", domain = EmailDomain("domain.example"))
 
-        val address = emailAddress.address
+        assertThat(emailAddress.localPart).isEqualTo("foo bar")
+        assertThat(emailAddress.encodedLocalPart).isEqualTo("\"foo bar\"")
+        assertThat(emailAddress.address).isEqualTo("\"foo bar\"@domain.example")
+        assertThat(emailAddress.normalizedAddress).isEqualTo("\"foo bar\"@domain.example")
+        assertThat(emailAddress.toString()).isEqualTo("\"foo bar\"@domain.example")
+        assertThat(emailAddress.warnings).containsExactlyInAnyOrder(Warning.QuotedStringInLocalPart)
+    }
 
-        assertThat(address).isEqualTo(EMAIL_ADDRESS)
+    @Test
+    fun `empty local part`() {
+        val emailAddress = EmailAddress(localPart = "", domain = EmailDomain("domain.example"))
+
+        assertThat(emailAddress.localPart).isEqualTo("")
+        assertThat(emailAddress.encodedLocalPart).isEqualTo("\"\"")
+        assertThat(emailAddress.address).isEqualTo("\"\"@domain.example")
+        assertThat(emailAddress.normalizedAddress).isEqualTo("\"\"@domain.example")
+        assertThat(emailAddress.toString()).isEqualTo("\"\"@domain.example")
+        assertThat(emailAddress.warnings).containsExactlyInAnyOrder(
+            Warning.QuotedStringInLocalPart,
+            Warning.EmptyLocalPart,
+        )
     }
 
-    private companion object {
-        private const val EMAIL_ADDRESS = "email@example.com"
+    @Test
+    fun `equals() does case-insensitive domain comparison`() {
+        val emailAddress1 = EmailAddress(localPart = "user", domain = EmailDomain("domain.example"))
+        val emailAddress2 = EmailAddress(localPart = "user", domain = EmailDomain("DOMAIN.example"))
+
+        assertThat(emailAddress2).isEqualTo(emailAddress1)
     }
 }
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailDomainParserTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailDomainParserTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c157dc4b2fd6846489c34a6e2b21b696bd904fd9
--- /dev/null
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailDomainParserTest.kt
@@ -0,0 +1,88 @@
+package app.k9mail.core.common.mail
+
+import app.k9mail.core.common.mail.EmailAddressParserError.DnsLabelLengthExceeded
+import app.k9mail.core.common.mail.EmailAddressParserError.DomainLengthExceeded
+import app.k9mail.core.common.mail.EmailAddressParserError.ExpectedEndOfInput
+import app.k9mail.core.common.mail.EmailAddressParserError.UnexpectedCharacter
+import assertk.all
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.hasMessage
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import kotlin.test.Test
+
+class EmailDomainParserTest {
+    @Test
+    fun `simple domain`() {
+        val emailDomain = parseEmailDomain("DOMAIN.example")
+
+        assertThat(emailDomain.value).isEqualTo("DOMAIN.example")
+        assertThat(emailDomain.normalized).isEqualTo("domain.example")
+    }
+
+    @Test
+    fun `label starting with hyphen`() {
+        assertFailure {
+            parseEmailDomain("-domain.example")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(UnexpectedCharacter)
+            prop(EmailAddressParserException::position).isEqualTo(0)
+            hasMessage("Expected 'Let-dig'")
+        }
+    }
+
+    @Test
+    fun `label ending with hyphen`() {
+        assertFailure {
+            parseEmailDomain("domain-.example")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(UnexpectedCharacter)
+            prop(EmailAddressParserException::position).isEqualTo(7)
+            hasMessage("Expected 'Let-dig'")
+        }
+    }
+
+    @Test
+    fun `label exceeds maximum size`() {
+        assertFailure {
+            parseEmailDomain("1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx1234.example")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(DnsLabelLengthExceeded)
+            prop(EmailAddressParserException::position).isEqualTo(64)
+            hasMessage("DNS labels exceeds maximum length of 63 characters")
+        }
+    }
+
+    @Test
+    fun `domain exceeds maximum size`() {
+        assertFailure {
+            parseEmailDomain(
+                "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+                    "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+                    "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+                    "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx12",
+            )
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(DomainLengthExceeded)
+            prop(EmailAddressParserException::position).isEqualTo(254)
+            hasMessage("Domain exceeds maximum length of 253 characters")
+        }
+    }
+
+    @Test
+    fun `input contains additional character`() {
+        assertFailure {
+            parseEmailDomain("domain.example#")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(ExpectedEndOfInput)
+            prop(EmailAddressParserException::position).isEqualTo(14)
+            hasMessage("Expected end of input")
+        }
+    }
+
+    private fun parseEmailDomain(domain: String): EmailDomain {
+        return EmailDomainParser(domain).parseDomain()
+    }
+}
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailDomainTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailDomainTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f3abd1f596b7f10bd37a78153aa67a1afa795b98
--- /dev/null
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailDomainTest.kt
@@ -0,0 +1,24 @@
+package app.k9mail.core.common.mail
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlin.test.Test
+
+class EmailDomainTest {
+    @Test
+    fun `simple domain`() {
+        val domain = EmailDomain("DOMAIN.example")
+
+        assertThat(domain.value).isEqualTo("DOMAIN.example")
+        assertThat(domain.normalized).isEqualTo("domain.example")
+        assertThat(domain.toString()).isEqualTo("DOMAIN.example")
+    }
+
+    @Test
+    fun `equals() does case-insensitive comparison`() {
+        val domain1 = EmailDomain("domain.example")
+        val domain2 = EmailDomain("DOMAIN.example")
+
+        assertThat(domain2).isEqualTo(domain1)
+    }
+}
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/net/DomainTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/net/DomainTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7dbdd73979760e2be7b2c62b95a1d2b443c9675b
--- /dev/null
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/net/DomainTest.kt
@@ -0,0 +1,25 @@
+package app.k9mail.core.common.net
+
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.hasMessage
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import kotlin.test.Test
+
+class DomainTest {
+    @Test
+    fun `valid domain`() {
+        val domain = Domain("domain.example")
+
+        assertThat(domain.value).isEqualTo("domain.example")
+    }
+
+    @Test
+    fun `invalid domain should throw`() {
+        assertFailure {
+            Domain("invalid domain")
+        }.isInstanceOf<IllegalArgumentException>()
+            .hasMessage("Not a valid domain name: 'invalid domain'")
+    }
+}
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/net/HostNameUtilsTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/net/HostNameUtilsTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e38ef7b8741ff51a74c137bb783b2a7f4b0a542e
--- /dev/null
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/net/HostNameUtilsTest.kt
@@ -0,0 +1,165 @@
+package app.k9mail.core.common.net
+
+import assertk.Assert
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
+import kotlin.test.Test
+
+/**
+ * Test data copied from `mailnews/base/test/unit/test_hostnameUtils.js`
+ */
+class HostNameUtilsTest {
+    @Test
+    fun `valid host names`() {
+        assertThat("localhost").isLegalHostName()
+        assertThat("some-server").isLegalHostName()
+        assertThat("server.company.invalid").isLegalHostName()
+        assertThat("server.comp-any.invalid").isLegalHostName()
+        assertThat("server.123.invalid").isLegalHostName()
+        assertThat("1server.123.invalid").isLegalHostName()
+        assertThat("1.2.3.4.5").isLegalHostName()
+        assertThat("very.log.sub.domain.name.invalid").isLegalHostName()
+        assertThat("1234567890").isLegalHostName()
+        assertThat("1234567890.").isLegalHostName()
+        assertThat("server.company.invalid.").isLegalHostName()
+    }
+
+    @Test
+    fun `invalid host names`() {
+        assertThat("").isNotLegalHostName()
+        assertThat("server.badcompany!.invalid").isNotLegalHostName()
+        assertThat("server._badcompany.invalid").isNotLegalHostName()
+        assertThat("server.bad_company.invalid").isNotLegalHostName()
+        assertThat("server.badcompany-.invalid").isNotLegalHostName()
+        assertThat("server.bad company.invalid").isNotLegalHostName()
+        assertThat("server.b…dcompany.invalid").isNotLegalHostName()
+        assertThat(".server.badcompany.invalid").isNotLegalHostName()
+        assertThat("make-this-a-long-host-name-component-that-is-over-63-characters-long.invalid").isNotLegalHostName()
+        assertThat(
+            "append-strings-to-make-this-a-too-long-host-name.that-is-really-over-255-characters-long.invalid." +
+                "append-strings-to-make-this-a-too-long-host-name.that-is-really-over-255-characters-long.invalid." +
+                "append-strings-to-make-this-a-too-long-host-name.that-is-really-over-255-characters-long.invalid." +
+                "append-strings-to-make-this-a-too-long-host-name.that-is-really-over-255-characters-long.invalid",
+        ).isNotLegalHostName()
+    }
+
+    @Test
+    fun `valid IPv4 addresses`() {
+        assertThat("1.2.3.4").isLegalIPv4Address()
+        assertThat("123.245.111.222").isLegalIPv4Address()
+        assertThat("255.255.255.255").isLegalIPv4Address()
+        assertThat("1.2.0.4").isLegalIPv4Address()
+        assertThat("1.2.3.4").isLegalIPv4Address()
+        assertThat("127.1.2.3").isLegalIPv4Address()
+        assertThat("10.1.2.3").isLegalIPv4Address()
+        assertThat("192.168.2.3").isLegalIPv4Address()
+    }
+
+    @Test
+    fun `invalid IPv4 addresses`() {
+        assertThat("1.2.3.4.5").isNotLegalIPv4Address()
+        assertThat("1.2.3").isNotLegalIPv4Address()
+        assertThat("1.2.3.").isNotLegalIPv4Address()
+        assertThat(".1.2.3").isNotLegalIPv4Address()
+        assertThat("1.2.3.256").isNotLegalIPv4Address()
+        assertThat("1.2.3.12345").isNotLegalIPv4Address()
+        assertThat("1.2..123").isNotLegalIPv4Address()
+        assertThat("1").isNotLegalIPv4Address()
+        assertThat("").isNotLegalIPv4Address()
+        assertThat("0.1.2.3").isNotLegalIPv4Address()
+        assertThat("0.0.2.3").isNotLegalIPv4Address()
+        assertThat("0.0.0.0").isNotLegalIPv4Address()
+        assertThat("1.2.3.d").isNotLegalIPv4Address()
+        assertThat("a.b.c.d").isNotLegalIPv4Address()
+        assertThat("a.b.c.d").isNotLegalIPv4Address()
+
+        // Extended formats of IPv4, hex, octal, decimal up to DWORD
+        // We intentionally don't support any of these.
+        assertThat("0xff.0x12.0x45.0x78").isNotLegalIPv4Address()
+        assertThat("01.0123.056.077").isNotLegalIPv4Address()
+        assertThat("0xff.2.3.4").isNotLegalIPv4Address()
+        assertThat("0xff.2.3.077").isNotLegalIPv4Address()
+        assertThat("0x7f.2.3.077").isNotLegalIPv4Address()
+        assertThat("0xZZ.1.2.3").isNotLegalIPv4Address()
+        assertThat("0x00.0123.056.077").isNotLegalIPv4Address()
+        assertThat("0x11.0123.056.078").isNotLegalIPv4Address()
+        assertThat("0x11.0123.056.0789").isNotLegalIPv4Address()
+        assertThat("1234566945").isNotLegalIPv4Address()
+        assertThat("12345").isNotLegalIPv4Address()
+        assertThat("123456789123456").isNotLegalIPv4Address()
+        assertThat("127.1").isNotLegalIPv4Address()
+        assertThat("0x7f.100").isNotLegalIPv4Address()
+        assertThat("0x7f.100.1000").isNotLegalIPv4Address()
+        assertThat("0xff.100.1024").isNotLegalIPv4Address()
+        assertThat("0xC0.0xA8.0x2A48").isNotLegalIPv4Address()
+        assertThat("0xC0.0xA82A48").isNotLegalIPv4Address()
+        assertThat("0xC0A82A48").isNotLegalIPv4Address()
+        assertThat("0324.062477106").isNotLegalIPv4Address()
+        assertThat("0.0.1000").isNotLegalIPv4Address()
+        assertThat("0324.06247710677").isNotLegalIPv4Address()
+    }
+
+    @Test
+    fun `valid IPv6 addresses`() {
+        assertThat("2001:0db8:85a3:0000:0000:8a2e:0370:7334").isNormalizedTo("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
+        assertThat("2001:db8:85a3:0:0:8a2e:370:7334").isNormalizedTo("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
+        assertThat("2001:db8:85a3::8a2e:370:7334").isNormalizedTo("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
+        assertThat("2001:0db8:85a3:0000:0000:8a2e:0370:").isNormalizedTo("2001:0db8:85a3:0000:0000:8a2e:0370:0000")
+        assertThat("::ffff:c000:0280").isNormalizedTo("0000:0000:0000:0000:0000:ffff:c000:0280")
+        assertThat("::ffff:192.0.2.128").isNormalizedTo("0000:0000:0000:0000:0000:ffff:c000:0280")
+        assertThat("2001:db8::1").isNormalizedTo("2001:0db8:0000:0000:0000:0000:0000:0001")
+        assertThat("2001:DB8::1").isNormalizedTo("2001:0db8:0000:0000:0000:0000:0000:0001")
+        assertThat("1:2:3:4:5:6:7:8").isNormalizedTo("0001:0002:0003:0004:0005:0006:0007:0008")
+        assertThat("::1").isNormalizedTo("0000:0000:0000:0000:0000:0000:0000:0001")
+        assertThat("::0000:0000:1").isNormalizedTo("0000:0000:0000:0000:0000:0000:0000:0001")
+    }
+
+    @Test
+    fun `invalid IPv6 addresses`() {
+        assertThat("::").isNotLegalIPv6Address()
+        assertThat("2001:0db8:85a3:0000:0000:8a2e:0370:73346").isNotLegalIPv6Address()
+        assertThat("2001:0db8:85a3:0000:0000:8a2e:0370:7334:1").isNotLegalIPv6Address()
+        assertThat("2001:0db8:85a3:0000:0000:8a2e:0370:7334x").isNotLegalIPv6Address()
+        assertThat("2001:0db8:85a3:0000:0000:8a2e:03707334").isNotLegalIPv6Address()
+        assertThat("2001:0db8:85a3:0000:0000x8a2e:0370:7334").isNotLegalIPv6Address()
+        assertThat("2001:0db8:85a3:0000:0000:::1").isNotLegalIPv6Address()
+        assertThat("2001:0db8:85a3:0000:0000:0000:some:junk").isNotLegalIPv6Address()
+        assertThat("2001:0db8:85a3:0000:0000:0000::192.0.2.359").isNotLegalIPv6Address()
+        assertThat("some::junk").isNotLegalIPv6Address()
+        assertThat("some_junk").isNotLegalIPv6Address()
+    }
+
+    @Test
+    fun cleanUpHostName() {
+        assertThat(HostNameUtils.cleanUpHostName("imap.domain.example ")).isEqualTo("imap.domain.example")
+    }
+}
+
+private fun Assert<String>.isLegalHostName() = given { actual ->
+    assertThat(HostNameUtils.isLegalHostName(actual)).isNotNull()
+    assertThat(HostNameUtils.isLegalHostNameOrIP(actual)).isNotNull()
+}
+
+private fun Assert<String>.isNotLegalHostName() = given { actual ->
+    assertThat(HostNameUtils.isLegalHostName(actual)).isNull()
+}
+
+private fun Assert<String>.isLegalIPv4Address() = given { actual ->
+    assertThat(HostNameUtils.isLegalIPv4Address(actual)).isNotNull()
+    assertThat(HostNameUtils.isLegalIPAddress(actual)).isNotNull()
+}
+
+private fun Assert<String>.isNotLegalIPv4Address() = given { actual ->
+    assertThat(HostNameUtils.isLegalIPv4Address(actual)).isNull()
+}
+
+private fun Assert<String>.isNormalizedTo(normalized: String) = given { actual ->
+    assertThat(HostNameUtils.isLegalIPv6Address(actual)).isEqualTo(normalized)
+    assertThat(HostNameUtils.isLegalHostNameOrIP(actual)).isEqualTo(normalized)
+}
+
+private fun Assert<String>.isNotLegalIPv6Address() = given { actual ->
+    assertThat(HostNameUtils.isLegalIPv6Address(actual)).isNull()
+}
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/net/HostnameTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/net/HostnameTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..970c25bae5bc1978d26cc5b3d96dec61c0e250bf
--- /dev/null
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/net/HostnameTest.kt
@@ -0,0 +1,47 @@
+package app.k9mail.core.common.net
+
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.hasMessage
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import kotlin.test.Test
+
+class HostnameTest {
+    @Test
+    fun `valid domain`() {
+        val hostname = Hostname("domain.example")
+
+        assertThat(hostname.value).isEqualTo("domain.example")
+    }
+
+    @Test
+    fun `valid IPv4`() {
+        val hostname = Hostname("127.0.0.1")
+
+        assertThat(hostname.value).isEqualTo("127.0.0.1")
+    }
+
+    @Test
+    fun `valid IPv6`() {
+        val hostname = Hostname("fc00::1")
+
+        assertThat(hostname.value).isEqualTo("fc00::1")
+    }
+
+    @Test
+    fun `invalid domain should throw`() {
+        assertFailure {
+            Hostname("invalid domain")
+        }.isInstanceOf<IllegalArgumentException>()
+            .hasMessage("Not a valid domain or IP: 'invalid domain'")
+    }
+
+    @Test
+    fun `invalid IPv6 should throw`() {
+        assertFailure {
+            Hostname("fc00:1")
+        }.isInstanceOf<IllegalArgumentException>()
+            .hasMessage("Not a valid domain or IP: 'fc00:1'")
+    }
+}
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/net/PortTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/net/PortTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..54a01c177cb7246c5d05ce8754e8f02c8c35ba7e
--- /dev/null
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/net/PortTest.kt
@@ -0,0 +1,33 @@
+package app.k9mail.core.common.net
+
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.hasMessage
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import kotlin.test.Test
+
+class PortTest {
+    @Test
+    fun `valid port number`() {
+        val port = Port(993)
+
+        assertThat(port.value).isEqualTo(993)
+    }
+
+    @Test
+    fun `negative port number should throw`() {
+        assertFailure {
+            Port(-1)
+        }.isInstanceOf<IllegalArgumentException>()
+            .hasMessage("Not a valid port number: -1")
+    }
+
+    @Test
+    fun `port number exceeding valid range should throw`() {
+        assertFailure {
+            Port(65536)
+        }.isInstanceOf<IllegalArgumentException>()
+            .hasMessage("Not a valid port number: 65536")
+    }
+}
diff --git a/core/testing/build.gradle.kts b/core/testing/build.gradle.kts
index 93f45909c0a50546b9442c83fad8b98047dc7b61..2b963d7c8b28cc9194b0f3c21e0a810d592f8c6d 100644
--- a/core/testing/build.gradle.kts
+++ b/core/testing/build.gradle.kts
@@ -4,4 +4,5 @@ plugins {
 
 dependencies {
     implementation(libs.assertk)
+    implementation(libs.turbine)
 }
diff --git a/core/testing/src/main/kotlin/assertk/assertions/TurbineExtensions.kt b/core/testing/src/main/kotlin/assertk/assertions/TurbineExtensions.kt
new file mode 100644
index 0000000000000000000000000000000000000000..56ebc109dc28ee5874d96e58fdc9580d6bbc07f4
--- /dev/null
+++ b/core/testing/src/main/kotlin/assertk/assertions/TurbineExtensions.kt
@@ -0,0 +1,34 @@
+package assertk.assertions
+
+import app.cash.turbine.ReceiveTurbine
+import assertk.Assert
+import assertk.all
+import assertk.assertThat
+
+/**
+ * The `assertThatAndTurbinesConsumed` function ensures that the assertion passed and
+ * all events in the given turbines have been consumed.
+ *
+ * Usage:
+ *  val actualValue: T = getActualValue()
+ *  val turbines: List<ReceiveTurbine<*>> = getTurbines()
+ *  assertThatAndEnsureAllEventsConsumed(actualValue, turbines) {
+ *      // your assertion here
+ *  }
+ *
+ * @param T The type of the actual value.
+ * @param actual The actual value being asserted.
+ * @param turbines The list of ReceiveTurbine instances to check if all events are consumed.
+ * @param assertion An extension function on `Assert<T>`, which is used to define assertions on the actual value.
+ */
+fun <T> assertThatAndTurbinesConsumed(
+    actual: T,
+    turbines: List<ReceiveTurbine<*>>,
+    assertion: Assert<T>.() -> Unit,
+) {
+    assertThat(actual).all {
+        assertion()
+    }
+
+    turbines.forEach { it.ensureAllEventsConsumed() }
+}
diff --git a/core/testing/src/test/kotlin/assertk/assertions/ListExtensionsKtTest.kt b/core/testing/src/test/kotlin/assertk/assertions/ListExtensionsKtTest.kt
index 6978dae9111a5b852f943c1b9d8235e16ad38956..e3626132406212206578d617bb3096631e31119a 100644
--- a/core/testing/src/test/kotlin/assertk/assertions/ListExtensionsKtTest.kt
+++ b/core/testing/src/test/kotlin/assertk/assertions/ListExtensionsKtTest.kt
@@ -1,5 +1,6 @@
 package assertk.assertions
 
+import assertk.assertFailure
 import assertk.assertThat
 import kotlin.test.Test
 
@@ -16,13 +17,8 @@ class ListExtensionsKtTest {
     fun `containsNoDuplicates() should fail with duplicates`() {
         val list = listOf("a", "b", "c", "a", "a")
 
-        assertThat {
+        assertFailure {
             assertThat(list).containsNoDuplicates()
-        }.isFailure()
-            .hasMessage(
-                """
-                expected to contain no duplicates but found: <["a", "a"]>
-                """.trimIndent(),
-            )
+        }.hasMessage("""expected to contain no duplicates but found: <["a", "a"]>""")
     }
 }
diff --git a/core/ui/compose/common/build.gradle.kts b/core/ui/compose/common/build.gradle.kts
index 20f1ad10d1eb0acbffd8cdbf275306c5ee899ee2..d1b76a4dd5ee9c36c768583c00f41e3ad3052c59 100644
--- a/core/ui/compose/common/build.gradle.kts
+++ b/core/ui/compose/common/build.gradle.kts
@@ -6,3 +6,7 @@ android {
     namespace = "app.k9mail.core.ui.compose.common"
     resourcePrefix = "core_ui_common_"
 }
+
+dependencies {
+    testImplementation(projects.core.ui.compose.testing)
+}
diff --git a/core/ui/compose/common/src/main/kotlin/app/k9mail/core/ui/compose/common/mvi/BaseViewModel.kt b/core/ui/compose/common/src/main/kotlin/app/k9mail/core/ui/compose/common/mvi/BaseViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..28f554ba39ea7a662b8e4f510c748032f6143522
--- /dev/null
+++ b/core/ui/compose/common/src/main/kotlin/app/k9mail/core/ui/compose/common/mvi/BaseViewModel.kt
@@ -0,0 +1,57 @@
+package app.k9mail.core.ui.compose.common.mvi
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+
+/**
+ * An abstract base ViewModel that implements [UnidirectionalViewModel] and provides basic
+ * functionality for managing state and effects.
+ *
+ * @param STATE The type that represents the state of the ViewModel. For example, the UI state of a screen can be
+ * represented as a state.
+ * @param EVENT The type that represents user actions that can occur and should be handled by the ViewModel. For
+ * example, a button click can be represented as an event.
+ * @param EFFECT The  type that represents side-effects that can occur in response to the state changes. For example,
+ * a navigation event can be represented as an effect.
+ *
+ * @property initialState The initial [STATE] of the ViewModel.
+ */
+abstract class BaseViewModel<STATE, EVENT, EFFECT>(
+    initialState: STATE,
+) : ViewModel(),
+    UnidirectionalViewModel<STATE, EVENT, EFFECT> {
+
+    private val _state = MutableStateFlow(initialState)
+    override val state: StateFlow<STATE> = _state.asStateFlow()
+
+    private val _effect = MutableSharedFlow<EFFECT>()
+    override val effect: SharedFlow<EFFECT> = _effect.asSharedFlow()
+
+    /**
+     * Updates the [STATE] of the ViewModel.
+     *
+     * @param update A function that takes the current [STATE] and produces a new [STATE].
+     */
+    protected fun updateState(update: (STATE) -> STATE) {
+        _state.update(update)
+    }
+
+    /**
+     * Emits a side effect.
+     *
+     * @param effect The [EFFECT] to emit.
+     */
+    protected fun emitEffect(effect: EFFECT) {
+        viewModelScope.launch {
+            _effect.emit(effect)
+        }
+    }
+}
diff --git a/core/ui/compose/common/src/main/kotlin/app/k9mail/core/ui/compose/common/mvi/UnidirectionalViewModel.kt b/core/ui/compose/common/src/main/kotlin/app/k9mail/core/ui/compose/common/mvi/UnidirectionalViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f79840deff59f775f23b736bd3e21cf4804cdbb7
--- /dev/null
+++ b/core/ui/compose/common/src/main/kotlin/app/k9mail/core/ui/compose/common/mvi/UnidirectionalViewModel.kt
@@ -0,0 +1,104 @@
+package app.k9mail.core.ui.compose.common.mvi
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.State
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.collectLatest
+
+/**
+ * Interface for a unidirectional view model with side-effects ([EFFECT]). It has a [STATE] and can handle [EVENT]'s.
+ *
+ * @param STATE The type that represents the state of the ViewModel. For example, the UI state of a screen can be
+ * represented as a state.
+ * @param EVENT The type that represents user actions that can occur and should be handled by the ViewModel. For
+ * example, a button click can be represented as an event.
+ * @param EFFECT The  type that represents side-effects that can occur in response to the state changes. For example,
+ * a navigation event can be represented as an effect.
+ */
+interface UnidirectionalViewModel<STATE, EVENT, EFFECT> {
+    /**
+     * The current [STATE] of the view model.
+     */
+    val state: StateFlow<STATE>
+
+    /**
+     * The side-effects ([EFFECT]) produced by the view model.
+     */
+    val effect: SharedFlow<EFFECT>
+
+    /**
+     * Handles an [EVENT] and updates the [STATE] of the view model.
+     *
+     * @param event The [EVENT] to handle.
+     */
+    fun event(event: EVENT)
+}
+
+/**
+ * Data class representing a state and a dispatch function, used for destructuring in [observe].
+ */
+data class StateDispatch<STATE, EVENT>(
+    val state: State<STATE>,
+    val dispatch: (EVENT) -> Unit,
+)
+
+/**
+ * Composable function that observes a UnidirectionalViewModel and handles its side effects.
+ *
+ * Example usage:
+ * ```
+ * @Composable
+ * fun MyScreen(
+ *    onNavigateNext: () -> Unit,
+ *    onNavigateBack: () -> Unit,
+ *    viewModel: MyUnidirectionalViewModel<MyState, MyEvent, MyEffect>,
+ * ) {
+ *    val (state, dispatch) = viewModel.observe { effect ->
+ *      when (effect) {
+ *          MyEffect.OnBackPressed -> onNavigateBack()
+ *          MyEffect.OnNextPressed -> onNavigateNext()
+ *      }
+ *    }
+ *
+ *    MyContent(
+ *      onNextClick = {
+ *          dispatch(MyEvent.OnNext)
+ *      },
+ *      onBackClick = {
+ *          dispatch(MyEvent.OnBack)
+ *      },
+ *      state = state.value,
+ *    )
+ * }
+ * ```
+ *
+ * @param STATE The type that represents the state of the ViewModel.
+ * @param EVENT The type that represents user actions that can occur and should be handled by the ViewModel.
+ * @param EFFECT The  type that represents side-effects that can occur in response to the state changes.
+ *
+ * @param handleEffect A function to handle side effects ([EFFECT]).
+ *
+ * @return A [StateDispatch] containing the state and a dispatch function.
+ */
+@Composable
+inline fun <reified STATE, EVENT, EFFECT> UnidirectionalViewModel<STATE, EVENT, EFFECT>.observe(
+    crossinline handleEffect: (EFFECT) -> Unit,
+): StateDispatch<STATE, EVENT> {
+    val collectedState = state.collectAsStateWithLifecycle()
+
+    val dispatch: (EVENT) -> Unit = { event(it) }
+
+    LaunchedEffect(key1 = effect) {
+        effect.collectLatest {
+            handleEffect(it)
+        }
+    }
+
+    return StateDispatch(
+        state = collectedState,
+        dispatch = dispatch,
+    )
+}
diff --git a/core/ui/compose/common/src/test/kotlin/app/k9mail/core/ui/compose/common/mvi/BaseViewModelTest.kt b/core/ui/compose/common/src/test/kotlin/app/k9mail/core/ui/compose/common/mvi/BaseViewModelTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..6f9ba22630f266b0e767183a588467b58b0d6e24
--- /dev/null
+++ b/core/ui/compose/common/src/test/kotlin/app/k9mail/core/ui/compose/common/mvi/BaseViewModelTest.kt
@@ -0,0 +1,56 @@
+package app.k9mail.core.ui.compose.common.mvi
+
+import app.cash.turbine.test
+import app.k9mail.core.ui.compose.testing.MainDispatcherRule
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class BaseViewModelTest {
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    @Test
+    fun `should emit initial state`() = runTest {
+        val viewModel = TestBaseViewModel()
+        assertThat(viewModel.state.value).isEqualTo("Initial state")
+    }
+
+    @Test
+    fun `should update state`() = runTest {
+        val viewModel = TestBaseViewModel()
+
+        viewModel.event("Test event")
+
+        assertThat(viewModel.state.value).isEqualTo("Test event")
+
+        viewModel.event("Another test event")
+
+        assertThat(viewModel.state.value).isEqualTo("Another test event")
+    }
+
+    @Test
+    fun `should emit effects`() = runTest {
+        val viewModel = TestBaseViewModel()
+
+        viewModel.effect.test {
+            viewModel.event("Test effect")
+
+            assertThat(awaitItem()).isEqualTo("Test effect")
+
+            viewModel.event("Another test effect")
+
+            assertThat(awaitItem()).isEqualTo("Another test effect")
+        }
+    }
+
+    private class TestBaseViewModel : BaseViewModel<String, String, String>("Initial state") {
+        override fun event(event: String) {
+            updateState { event }
+            emitEffect(event)
+        }
+    }
+}
diff --git a/core/ui/compose/common/src/test/kotlin/app/k9mail/core/ui/compose/common/mvi/UnidirectionalViewModelKtTest.kt b/core/ui/compose/common/src/test/kotlin/app/k9mail/core/ui/compose/common/mvi/UnidirectionalViewModelKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7d039b5a32c732d95a80f95853c9378bf8fabc37
--- /dev/null
+++ b/core/ui/compose/common/src/test/kotlin/app/k9mail/core/ui/compose/common/mvi/UnidirectionalViewModelKtTest.kt
@@ -0,0 +1,78 @@
+package app.k9mail.core.ui.compose.common.mvi
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import app.k9mail.core.ui.compose.testing.MainDispatcherRule
+import app.k9mail.core.ui.compose.testing.setContent
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class UnidirectionalViewModelKtTest : ComposeTest() {
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    @Test
+    fun `observe should emit state changes, allow event dispatch and expose effects`() = runTest {
+        val viewModel = TestViewModel()
+        val effects = mutableListOf<TestEffect>()
+        lateinit var stateDispatch: StateDispatch<TestState, TestEvent>
+
+        setContent {
+            stateDispatch = viewModel.observe { effect ->
+                effects.add(effect)
+            }
+        }
+
+        val (state, dispatch) = stateDispatch
+
+        // Initial state
+        assertThat(state.value.data).isEqualTo("TestState: Initial")
+
+        // Dispatch an event
+        dispatch(TestEvent("Event 1"))
+
+        assertThat(state.value.data).isEqualTo("TestState: Event 1")
+        assertThat(effects.last().result).isEqualTo("TestEffect: Event 1")
+
+        // Dispatch another event
+        dispatch(TestEvent("Event 2"))
+
+        assertThat(state.value.data).isEqualTo("TestState: Event 2")
+        assertThat(effects.last().result).isEqualTo("TestEffect: Event 2")
+    }
+
+    private data class TestState(val data: String)
+    private data class TestEvent(val action: String)
+    private data class TestEffect(val result: String)
+
+    private class TestViewModel(
+        initialState: TestState = TestState("TestState: Initial"),
+    ) : ViewModel(), UnidirectionalViewModel<TestState, TestEvent, TestEffect> {
+
+        private val _state = MutableStateFlow(initialState)
+        override val state: StateFlow<TestState> = _state.asStateFlow()
+
+        private val _effect = MutableSharedFlow<TestEffect>()
+        override val effect: SharedFlow<TestEffect> = _effect.asSharedFlow()
+
+        override fun event(event: TestEvent) {
+            _state.update { it.copy(data = "TestState: ${event.action}") }
+            viewModelScope.launch {
+                _effect.emit(TestEffect(result = "TestEffect: ${event.action}"))
+            }
+        }
+    }
+}
diff --git a/core/ui/compose/designsystem/build.gradle.kts b/core/ui/compose/designsystem/build.gradle.kts
index 2abfd60ebb9dfe5382b735c63efefcf1f18b3dc0..10362d9198bc10d07f58a398b3ff8b42cd95d737 100644
--- a/core/ui/compose/designsystem/build.gradle.kts
+++ b/core/ui/compose/designsystem/build.gradle.kts
@@ -10,7 +10,6 @@ android {
 dependencies {
     api(projects.core.ui.compose.theme)
     implementation(libs.androidx.compose.material)
-    implementation(libs.androidx.compose.material.icons.extended)
 
     testImplementation(projects.core.ui.compose.testing)
 }
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Divider.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Divider.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ef63cf3fcdfc01137cecbc883733d53f545d7476
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Divider.kt
@@ -0,0 +1,48 @@
+package app.k9mail.core.ui.compose.designsystem.atom
+
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import androidx.compose.material.Divider as MaterialDivider
+
+@Composable
+fun Divider(
+    modifier: Modifier = Modifier,
+    color: Color = MaterialTheme.colors.onSurface.copy(alpha = DIVIDER_ALPHA),
+    thickness: Dp = 1.dp,
+    startIndent: Dp = 0.dp,
+) {
+    MaterialDivider(
+        modifier = modifier,
+        color = color,
+        thickness = thickness,
+        startIndent = startIndent,
+    )
+}
+
+private const val DIVIDER_ALPHA = 0.12f
+
+@Preview(showBackground = true)
+@Composable
+internal fun DividerPreview() {
+    PreviewWithThemes {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(MainTheme.spacings.double),
+        ) {
+            Divider(
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Icon.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Icon.kt
new file mode 100644
index 0000000000000000000000000000000000000000..df0bb7febaeabfafdcc1c9101e4f10bed89892c3
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Icon.kt
@@ -0,0 +1,47 @@
+package app.k9mail.core.ui.compose.designsystem.atom
+
+import androidx.compose.material.LocalContentAlpha
+import androidx.compose.material.LocalContentColor
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import androidx.compose.material.Icon as MaterialIcon
+
+@Composable
+fun Icon(
+    imageVector: ImageVector,
+    modifier: Modifier = Modifier,
+    tint: Color = LocalContentColor.current.copy(alpha = LocalContentAlpha.current),
+) {
+    MaterialIcon(
+        imageVector = imageVector,
+        contentDescription = null,
+        modifier = modifier,
+        tint = tint,
+    )
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun IconPreview() {
+    PreviewWithThemes {
+        Icon(
+            imageVector = Icons.Filled.error,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun IconTintedPreview() {
+    PreviewWithThemes {
+        Icon(
+            imageVector = Icons.Filled.error,
+            tint = Color.Magenta,
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Surface.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Surface.kt
index 663a2453bcc670738acffed089fde098a00cffd5..ead36785b86aad167df48420765a423edc0e2964 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Surface.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Surface.kt
@@ -1,11 +1,15 @@
 package app.k9mail.core.ui.compose.designsystem.atom
 
-import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.requiredHeight
+import androidx.compose.foundation.layout.requiredWidth
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.RectangleShape
+import androidx.compose.ui.graphics.Shape
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
 import androidx.compose.material.Surface as MaterialSurface
@@ -13,12 +17,14 @@ import androidx.compose.material.Surface as MaterialSurface
 @Composable
 fun Surface(
     modifier: Modifier = Modifier,
+    shape: Shape = RectangleShape,
     color: Color = MainTheme.colors.surface,
     elevation: Dp = MainTheme.elevations.default,
     content: @Composable () -> Unit,
 ) {
     MaterialSurface(
         modifier = modifier,
+        shape = shape,
         content = content,
         elevation = elevation,
         color = color,
@@ -30,8 +36,27 @@ fun Surface(
 internal fun SurfacePreview() {
     PreviewWithThemes {
         Surface(
-            modifier = Modifier.fillMaxSize(),
+            modifier = Modifier
+                .requiredHeight(100.dp)
+                .requiredWidth(100.dp),
             content = {},
         )
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun SurfaceWithShapePreview() {
+    PreviewWithThemes {
+        Background {
+            Surface(
+                modifier = Modifier
+                    .requiredHeight(MainTheme.sizes.larger)
+                    .requiredWidth(MainTheme.sizes.larger),
+                shape = MainTheme.shapes.small,
+                color = MainTheme.colors.primary,
+                content = {},
+            )
+        }
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Switch.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Switch.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1c449c3bb03f61a7a1198edac0cd8b02e9683055
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Switch.kt
@@ -0,0 +1,45 @@
+package app.k9mail.core.ui.compose.designsystem.atom
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import androidx.compose.material.Switch as MaterialSwitch
+
+@Composable
+fun Switch(
+    checked: Boolean,
+    onCheckedChange: (Boolean) -> Unit,
+    modifier: Modifier = Modifier,
+    enabled: Boolean = true,
+) {
+    MaterialSwitch(
+        checked = checked,
+        onCheckedChange = onCheckedChange,
+        modifier = modifier,
+        enabled = enabled,
+    )
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun SwitchPreview() {
+    PreviewWithThemes {
+        Switch(
+            checked = true,
+            onCheckedChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun SwitchDisabledPreview() {
+    PreviewWithThemes {
+        Switch(
+            checked = true,
+            onCheckedChange = {},
+            enabled = false,
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/Button.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/Button.kt
index 4b9754d1de0f237145d31cfed05862e8ac7107fa..5165145b8b60f03751cc1ff0834d9d4c2a0a9df9 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/Button.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/Button.kt
@@ -4,8 +4,10 @@ import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.material.ButtonDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.designsystem.atom.text.TextButton
+import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
 import androidx.compose.material.Button as MaterialButton
 
@@ -15,13 +17,16 @@ fun Button(
     onClick: () -> Unit,
     modifier: Modifier = Modifier,
     enabled: Boolean = true,
+    color: Color? = null,
     contentPadding: PaddingValues = buttonContentPadding(),
 ) {
     MaterialButton(
         onClick = onClick,
         modifier = modifier,
         enabled = enabled,
-        colors = ButtonDefaults.buttonColors(),
+        colors = ButtonDefaults.buttonColors(
+            backgroundColor = color ?: MainTheme.colors.primary,
+        ),
         contentPadding = contentPadding,
     ) {
         TextButton(text = text)
@@ -39,6 +44,18 @@ internal fun ButtonPreview() {
     }
 }
 
+@Preview(showBackground = true)
+@Composable
+internal fun ButtonColoredPreview() {
+    PreviewWithThemes {
+        Button(
+            text = "ButtonColored",
+            onClick = {},
+            color = Color.Magenta,
+        )
+    }
+}
+
 @Preview(showBackground = true)
 @Composable
 internal fun ButtonDisabledPreview() {
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonDefaults.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonDefaults.kt
index 346441e9fc2a03a39eb4ed29af77892d58dce891..f613fbda11e70153065c1f9803c8ac28af302a3a 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonDefaults.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonDefaults.kt
@@ -2,12 +2,18 @@ package app.k9mail.core.ui.compose.designsystem.atom.button
 
 import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.unit.Dp
 import app.k9mail.core.ui.compose.theme.MainTheme
 
 @Composable
-fun buttonContentPadding(): PaddingValues = PaddingValues(
-    start = MainTheme.spacings.quadruple,
-    top = MainTheme.spacings.default,
-    end = MainTheme.spacings.quadruple,
-    bottom = MainTheme.spacings.default,
+fun buttonContentPadding(
+    start: Dp = MainTheme.spacings.quadruple,
+    top: Dp = MainTheme.spacings.default,
+    end: Dp = MainTheme.spacings.quadruple,
+    bottom: Dp = MainTheme.spacings.default,
+): PaddingValues = PaddingValues(
+    start = start,
+    top = top,
+    end = end,
+    bottom = bottom,
 )
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonIcon.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonIcon.kt
new file mode 100644
index 0000000000000000000000000000000000000000..128d4e9d89998abe01cc58027a06b88456d63cbe
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonIcon.kt
@@ -0,0 +1,41 @@
+package app.k9mail.core.ui.compose.designsystem.atom.button
+
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.Icon
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.MainTheme
+import androidx.compose.material.IconButton as MaterialIconButton
+
+@Composable
+fun ButtonIcon(
+    onClick: () -> Unit,
+    imageVector: ImageVector,
+    modifier: Modifier = Modifier,
+    enabled: Boolean = true,
+    contentDescription: String? = null,
+) {
+    MaterialIconButton(
+        onClick = onClick,
+        modifier = modifier,
+        enabled = enabled,
+    ) {
+        Icon(
+            modifier = Modifier.size(MainTheme.sizes.icon),
+            imageVector = imageVector,
+            contentDescription = contentDescription,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun ButtonIconPreview() {
+    ButtonIcon(
+        onClick = { },
+        imageVector = Icons.Filled.user,
+    )
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonOutlined.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonOutlined.kt
index 3f0944bd61f18eac5c1ce05204f875822a9ca186..fcde407636e41a69541711915b77c723861f1978 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonOutlined.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonOutlined.kt
@@ -19,6 +19,7 @@ fun ButtonOutlined(
     onClick: () -> Unit,
     modifier: Modifier = Modifier,
     enabled: Boolean = true,
+    color: Color? = null,
     contentPadding: PaddingValues = buttonContentPadding(),
 ) {
     MaterialOutlinedButton(
@@ -26,12 +27,13 @@ fun ButtonOutlined(
         modifier = modifier,
         enabled = enabled,
         colors = ButtonDefaults.outlinedButtonColors(
+            contentColor = color ?: MainTheme.colors.primary,
             backgroundColor = Color.Transparent,
         ),
         border = BorderStroke(
             width = 1.dp,
             color = if (enabled) {
-                MainTheme.colors.primary
+                color ?: MainTheme.colors.primary
             } else {
                 MainTheme.colors.onSurface.copy(
                     alpha = 0.12f,
@@ -55,6 +57,18 @@ internal fun ButtonOutlinedPreview() {
     }
 }
 
+@Preview(showBackground = true)
+@Composable
+internal fun ButtonOutlinedColoredPreview() {
+    PreviewWithThemes {
+        ButtonOutlined(
+            text = "ButtonOutlinedColored",
+            onClick = {},
+            color = Color.Magenta,
+        )
+    }
+}
+
 @Preview(showBackground = true)
 @Composable
 internal fun ButtonOutlinedDisabledPreview() {
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonText.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonText.kt
index 2ab02ca07adac3e91a1f6674ffcd4fe1c2c12645..be9a029fceeb556403614f008d439c9e1fc78ce1 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonText.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonText.kt
@@ -4,8 +4,10 @@ import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.material.ButtonDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.designsystem.atom.text.TextButton
+import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
 import androidx.compose.material.TextButton as MaterialTextButton
 
@@ -15,13 +17,16 @@ fun ButtonText(
     onClick: () -> Unit,
     modifier: Modifier = Modifier,
     enabled: Boolean = true,
+    color: Color? = null,
     contentPadding: PaddingValues = buttonContentPadding(),
 ) {
     MaterialTextButton(
         onClick = onClick,
         modifier = modifier,
         enabled = enabled,
-        colors = ButtonDefaults.textButtonColors(),
+        colors = ButtonDefaults.textButtonColors(
+            contentColor = color ?: MainTheme.colors.primary,
+        ),
         contentPadding = contentPadding,
     ) {
         TextButton(text = text)
@@ -39,6 +44,18 @@ internal fun ButtonTextPreview() {
     }
 }
 
+@Preview(showBackground = true)
+@Composable
+internal fun ButtonTextColoredPreview() {
+    PreviewWithThemes {
+        ButtonText(
+            text = "ButtonTextColored",
+            onClick = {},
+            color = Color.Magenta,
+        )
+    }
+}
+
 @Preview(showBackground = true)
 @Composable
 internal fun ButtonTextDisabledPreview() {
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextBody1.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextBody1.kt
index 4c604aaa72e0cd25779e25c4b44a873de2f012a0..09cacd61ee08098ef45a4ee80f929c6458010e95 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextBody1.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextBody1.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextBody1(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.body1,
+    )
+}
+
+@Composable
+fun TextBody1(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.body1,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextBody1Preview() {
         TextBody1(text = "TextBody1")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextBody1WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextBody1(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextBody2.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextBody2.kt
index dc125a153c480793e7683b42dc63846927e76eca..6b2397da4ef047c5363ffc8035ed7c10f79adbef 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextBody2.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextBody2.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextBody2(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.body2,
+    )
+}
+
+@Composable
+fun TextBody2(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.body2,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextBody2Preview() {
         TextBody2(text = "TextBody2")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextBody2WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextBody2(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextButton.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextButton.kt
index 31ac9ad99b7c385768c19bc5a4e18903e59bf54c..a0f5619f5adb594825f3fab54320623162e9f835 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextButton.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextButton.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,35 @@ import androidx.compose.material.Text as MaterialText
 fun TextButton(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text.uppercase(),
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.button,
+    )
+}
+
+@Composable
+fun TextButton(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = AnnotatedString(
+            text = text.text.uppercase(),
+            spanStyles = text.spanStyles,
+            paragraphStyles = text.paragraphStyles,
+        ),
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.button,
     )
 }
 
@@ -26,3 +57,18 @@ internal fun TextButtonPreview() {
         TextButton(text = "TextButton")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextButtonWithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextButton(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextCaption.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextCaption.kt
index 6d81cd36fc0d7f83dd1d863c0dae8eb44a773281..fecb945b416af8e0fb3b0adb0a98a302a3d45c85 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextCaption.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextCaption.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextCaption(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.caption,
+    )
+}
+
+@Composable
+fun TextCaption(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.caption,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextCaptionPreview() {
         TextCaption(text = "TextCaption")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextCaptionWithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextCaption(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline1.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline1.kt
index bc2f845fd919dfed73a16c2a51ff41a8753bb535..a26fba617d5f693b97b95fe2d4402cd387ebb53b 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline1.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline1.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextHeadline1(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.h1,
+    )
+}
+
+@Composable
+fun TextHeadline1(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.h1,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextHeadline1Preview() {
         TextHeadline1(text = "TextHeadline1")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextHeadline1WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextHeadline1(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline2.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline2.kt
index 7227cf21771a1e79e832c0b0051ccdaa8fc9fbc0..eabd641148fbee2e27d1b38568c5af8f3790ecd9 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline2.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline2.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextHeadline2(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.h2,
+    )
+}
+
+@Composable
+fun TextHeadline2(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.h2,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextHeadline2Preview() {
         TextHeadline2(text = "TextHeadline2")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextHeadline2WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextHeadline2(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline3.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline3.kt
index 7b4a44d86c86ce5d46ea38581402e25dcf5c0cbd..2ce4893cc39dd4ce183d2bc2c1fa2c4f18ae8923 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline3.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline3.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextHeadline3(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.h3,
+    )
+}
+
+@Composable
+fun TextHeadline3(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.h3,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextHeadline3Preview() {
         TextHeadline3(text = "TextHeadline3")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextHeadline3WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextHeadline3(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline4.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline4.kt
index 805eb5fc55695143af51d60c53bb95fc8951be67..3a2b333b64308e3fe0592e6b3302dc896754a3ec 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline4.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline4.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextHeadline4(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.h4,
+    )
+}
+
+@Composable
+fun TextHeadline4(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.h4,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextHeadline4Preview() {
         TextHeadline4(text = "TextHeadline4")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextHeadline4WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextHeadline4(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline5.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline5.kt
index 1d0cd722d7ff8afb371dd3372fd1da3d4788bda5..f0cd62de1d76ccb6c76a5e23bdbee6af188b01fb 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline5.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline5.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextHeadline5(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.h5,
+    )
+}
+
+@Composable
+fun TextHeadline5(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.h5,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextHeadline5Preview() {
         TextHeadline5(text = "TextHeadline5")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextHeadline5WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextHeadline5(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline6.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline6.kt
index 3b9a9b7f053b155b1b14c5961c0946f6f2313d66..d022369bdf45e749e1c6ca0fa19ef3c2cde40b4d 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline6.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline6.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextHeadline6(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.h6,
+    )
+}
+
+@Composable
+fun TextHeadline6(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.h6,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextHeadline6Preview() {
         TextHeadline6(text = "TextHeadline6")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextHeadline6WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextHeadline6(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextOverline.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextOverline.kt
index 9ec8ae8391c1a3d15da9046d00ae5d21a0af2fac..b1da3d629fc1076210a0de7cca7bdec5a6893972 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextOverline.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextOverline.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,35 @@ import androidx.compose.material.Text as MaterialText
 fun TextOverline(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text.uppercase(),
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.overline,
+    )
+}
+
+@Composable
+fun TextOverline(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = AnnotatedString(
+            text = text.text.uppercase(),
+            spanStyles = text.spanStyles,
+            paragraphStyles = text.paragraphStyles,
+        ),
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.overline,
     )
 }
 
@@ -26,3 +57,18 @@ internal fun TextOverlinePreview() {
         TextOverline(text = "TextOverline")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextOverlineWithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextOverline(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextSubtitle1.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextSubtitle1.kt
index a9d69abbc21df56b8039296456bfb00d77545694..014debaa258117ccd2aabac272d2fa52295306bc 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextSubtitle1.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextSubtitle1.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextSubtitle1(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.subtitle1,
+    )
+}
+
+@Composable
+fun TextSubtitle1(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.subtitle1,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextSubtitle1Preview() {
         TextSubtitle1(text = "TextSubtitle1")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextSubtitle1WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextSubtitle1(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextSubtitle2.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextSubtitle2.kt
index fab6c45b147873a576d02d2a5842d3d8dbe32009..5cadbf44bac0aa5992752e9547cac24511dc586b 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextSubtitle2.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextSubtitle2.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextSubtitle2(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.subtitle2,
+    )
+}
+
+@Composable
+fun TextSubtitle2(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.subtitle2,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextSubtitle2Preview() {
         TextSubtitle2(text = "TextSubtitle2")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextSubtitle2WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextSubtitle2(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldCommon.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldCommon.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fcf3cb0121ae417ad93dc5c80ca238e350194a0d
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldCommon.kt
@@ -0,0 +1,68 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+internal fun selectLabel(
+    label: String?,
+    isRequired: Boolean,
+): @Composable (() -> Unit)? {
+    return if (label != null || isRequired) {
+        {
+            TextFieldLabel(label.orEmpty(), isRequired)
+        }
+    } else {
+        null
+    }
+}
+
+@Composable
+internal fun TextFieldLabel(
+    label: String,
+    isRequired: Boolean,
+) {
+    Text(
+        text = if (isRequired) {
+            "$label$ASTERISK"
+        } else {
+            label
+        },
+    )
+}
+
+private const val ASTERISK = "*"
+
+@Preview(showBackground = true)
+@Composable
+fun TextFieldLabelPreview() {
+    PreviewWithThemes {
+        TextFieldLabel(
+            label = "Label",
+            isRequired = false,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+fun TextFieldLabelRequiredPreview() {
+    PreviewWithThemes {
+        TextFieldLabel(
+            label = "Label",
+            isRequired = true,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+fun TextFieldLabelRequiredEmptyLabelPreview() {
+    PreviewWithThemes {
+        TextFieldLabel(
+            label = "",
+            isRequired = true,
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlined.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlined.kt
index 251f8a01ef3bb0628f8ddcf93d3b3de93051f151..79ebb45ab1f479ea6b70dea4a827b44e26ef747f 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlined.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlined.kt
@@ -1,41 +1,40 @@
 package app.k9mail.core.ui.compose.designsystem.atom.textfield
 
-import androidx.compose.material.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.Icon
+import app.k9mail.core.ui.compose.theme.Icons
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
 import androidx.compose.material.OutlinedTextField as MaterialOutlinedTextField
 
+@Suppress("LongParameterList")
 @Composable
 fun TextFieldOutlined(
     value: String,
     onValueChange: (String) -> Unit,
     modifier: Modifier = Modifier,
-    enabled: Boolean = true,
     label: String? = null,
-    isError: Boolean = false,
+    trailingIcon: @Composable (() -> Unit)? = null,
+    isEnabled: Boolean = true,
+    isReadOnly: Boolean = false,
+    isRequired: Boolean = false,
+    hasError: Boolean = false,
+    isSingleLine: Boolean = true,
 ) {
     MaterialOutlinedTextField(
         value = value,
         onValueChange = onValueChange,
         modifier = modifier,
-        enabled = enabled,
-        label = selectLabel(label),
-        isError = isError,
+        enabled = isEnabled,
+        label = selectLabel(label, isRequired),
+        trailingIcon = trailingIcon,
+        readOnly = isReadOnly,
+        isError = hasError,
+        singleLine = isSingleLine,
     )
 }
 
-private fun selectLabel(label: String?): @Composable (() -> Unit)? {
-    return if (label != null) {
-        {
-            Text(text = label)
-        }
-    } else {
-        null
-    }
-}
-
 @Preview(showBackground = true)
 @Composable
 internal fun TextFieldOutlinedPreview() {
@@ -66,7 +65,7 @@ internal fun TextFieldOutlinedDisabledPreview() {
         TextFieldOutlined(
             value = "Input text",
             onValueChange = {},
-            enabled = false,
+            isEnabled = false,
         )
     }
 }
@@ -78,7 +77,33 @@ internal fun TextFieldOutlinedErrorPreview() {
         TextFieldOutlined(
             value = "Input text",
             onValueChange = {},
-            isError = true,
+            hasError = true,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedRequiredPreview() {
+    PreviewWithThemes {
+        TextFieldOutlined(
+            value = "",
+            onValueChange = {},
+            label = "Label",
+            isRequired = true,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedWithTrailingIconPreview() {
+    PreviewWithThemes {
+        TextFieldOutlined(
+            value = "",
+            onValueChange = {},
+            trailingIcon = { Icon(imageVector = Icons.Filled.user) },
+            isRequired = true,
         )
     }
 }
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedEmailAddress.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedEmailAddress.kt
new file mode 100644
index 0000000000000000000000000000000000000000..abf2d929ba271f496bda28b06d0c3bbce8da8cb3
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedEmailAddress.kt
@@ -0,0 +1,83 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import androidx.compose.material.OutlinedTextField as MaterialOutlinedTextField
+
+@Suppress("LongParameterList")
+@Composable
+fun TextFieldOutlinedEmailAddress(
+    value: String,
+    onValueChange: (String) -> Unit,
+    modifier: Modifier = Modifier,
+    label: String? = null,
+    isEnabled: Boolean = true,
+    isReadOnly: Boolean = false,
+    isRequired: Boolean = false,
+    hasError: Boolean = false,
+) {
+    MaterialOutlinedTextField(
+        value = value,
+        onValueChange = onValueChange,
+        modifier = modifier,
+        enabled = isEnabled,
+        label = selectLabel(label, isRequired),
+        readOnly = isReadOnly,
+        isError = hasError,
+        keyboardOptions = KeyboardOptions(
+            keyboardType = KeyboardType.Email,
+        ),
+        singleLine = true,
+    )
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedEmailAddressPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedEmailAddress(
+            value = "Input text",
+            onValueChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedEmailAddressWithLabelPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedEmailAddress(
+            value = "Input text",
+            label = "Label",
+            onValueChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedEmailDisabledPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedEmailAddress(
+            value = "Input text",
+            onValueChange = {},
+            isEnabled = false,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedEmailErrorPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedEmailAddress(
+            value = "Input text",
+            onValueChange = {},
+            hasError = true,
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedNumber.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedNumber.kt
new file mode 100644
index 0000000000000000000000000000000000000000..25ee4e7a8cece2d264fe6d40831dd5d89b1f9630
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedNumber.kt
@@ -0,0 +1,87 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import androidx.compose.material.OutlinedTextField as MaterialOutlinedTextField
+
+@Suppress("LongParameterList")
+@Composable
+fun TextFieldOutlinedNumber(
+    value: Long?,
+    onValueChange: (Long?) -> Unit,
+    modifier: Modifier = Modifier,
+    label: String? = null,
+    isEnabled: Boolean = true,
+    isReadOnly: Boolean = false,
+    isRequired: Boolean = false,
+    hasError: Boolean = false,
+) {
+    MaterialOutlinedTextField(
+        value = value?.toString() ?: "",
+        onValueChange = {
+            onValueChange(
+                it.takeIf { it.isNotBlank() }?.toLongOrNull(),
+            )
+        },
+        modifier = modifier,
+        enabled = isEnabled,
+        label = selectLabel(label, isRequired),
+        readOnly = isReadOnly,
+        isError = hasError,
+        keyboardOptions = KeyboardOptions(
+            keyboardType = KeyboardType.NumberPassword,
+        ),
+        singleLine = true,
+    )
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedNumberPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedNumber(
+            value = 123L,
+            onValueChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedNumberWithLabelPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedNumber(
+            value = 123L,
+            label = "Label",
+            onValueChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedNumberDisabledPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedNumber(
+            value = 123L,
+            onValueChange = {},
+            isEnabled = false,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedNumberErrorPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedNumber(
+            value = 123L,
+            onValueChange = {},
+            hasError = true,
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/PasswordTextFieldOutlined.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedPassword.kt
similarity index 77%
rename from core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/PasswordTextFieldOutlined.kt
rename to core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedPassword.kt
index 2086682d3553efdac644cca7e90860c2f67bd791..55cb2516082b047bf3ebb670c75353c9dbe299ce 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/PasswordTextFieldOutlined.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedPassword.kt
@@ -3,10 +3,6 @@ package app.k9mail.core.ui.compose.designsystem.atom.textfield
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material.Icon
 import androidx.compose.material.IconButton
-import androidx.compose.material.Text
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Visibility
-import androidx.compose.material.icons.filled.VisibilityOff
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -19,17 +15,21 @@ import androidx.compose.ui.text.input.PasswordVisualTransformation
 import androidx.compose.ui.text.input.VisualTransformation
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.designsystem.R
+import app.k9mail.core.ui.compose.theme.Icons
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
 import androidx.compose.material.OutlinedTextField as MaterialOutlinedTextField
 
+@Suppress("LongParameterList")
 @Composable
-fun PasswordTextFieldOutlined(
+fun TextFieldOutlinedPassword(
     value: String,
     onValueChange: (String) -> Unit,
     modifier: Modifier = Modifier,
-    enabled: Boolean = true,
     label: String? = null,
-    isError: Boolean = false,
+    isEnabled: Boolean = true,
+    isReadOnly: Boolean = false,
+    isRequired: Boolean = false,
+    hasError: Boolean = false,
 ) {
     var passwordVisibilityState by rememberSaveable { mutableStateOf(false) }
 
@@ -37,16 +37,17 @@ fun PasswordTextFieldOutlined(
         value = value,
         onValueChange = onValueChange,
         modifier = modifier,
-        enabled = enabled,
-        label = selectLabel(label),
+        enabled = isEnabled,
+        label = selectLabel(label, isRequired),
         trailingIcon = selectTrailingIcon(
-            isEnabled = enabled,
+            isEnabled = isEnabled,
             isPasswordVisible = passwordVisibilityState,
             onClick = { passwordVisibilityState = !passwordVisibilityState },
         ),
-        isError = isError,
+        readOnly = isReadOnly,
+        isError = hasError,
         visualTransformation = selectVisualTransformation(
-            isEnabled = enabled,
+            isEnabled = isEnabled,
             isPasswordVisible = passwordVisibilityState,
         ),
         keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Password),
@@ -54,16 +55,6 @@ fun PasswordTextFieldOutlined(
     )
 }
 
-private fun selectLabel(label: String?): @Composable (() -> Unit)? {
-    return if (label != null) {
-        {
-            Text(text = label)
-        }
-    } else {
-        null
-    }
-}
-
 private fun selectTrailingIcon(
     isEnabled: Boolean,
     isPasswordVisible: Boolean,
@@ -73,9 +64,9 @@ private fun selectTrailingIcon(
     return if (hasTrailingIcon) {
         {
             val image = if (isShowPasswordAllowed(isEnabled, isPasswordVisible)) {
-                Icons.Filled.Visibility
+                Icons.Filled.passwordVisibility
             } else {
-                Icons.Filled.VisibilityOff
+                Icons.Filled.passwordVisibilityOff
             }
 
             val description = if (isShowPasswordAllowed(isEnabled, isPasswordVisible)) {
@@ -110,7 +101,7 @@ private fun isShowPasswordAllowed(isEnabled: Boolean, isPasswordVisible: Boolean
 @Composable
 internal fun PasswordTextFieldOutlinedPreview() {
     PreviewWithThemes {
-        PasswordTextFieldOutlined(
+        TextFieldOutlinedPassword(
             value = "Input text",
             onValueChange = {},
         )
@@ -119,9 +110,9 @@ internal fun PasswordTextFieldOutlinedPreview() {
 
 @Preview(showBackground = true)
 @Composable
-internal fun PasswordTextFieldOutlinedWithLabelPreview() {
+internal fun TextFieldOutlinedPasswordWithLabelPreview() {
     PreviewWithThemes {
-        PasswordTextFieldOutlined(
+        TextFieldOutlinedPassword(
             value = "Input text",
             label = "Label",
             onValueChange = {},
@@ -131,24 +122,24 @@ internal fun PasswordTextFieldOutlinedWithLabelPreview() {
 
 @Preview(showBackground = true)
 @Composable
-internal fun PasswordTextFieldOutlinedDisabledPreview() {
+internal fun TextFieldOutlinedPasswordDisabledPreview() {
     PreviewWithThemes {
-        PasswordTextFieldOutlined(
+        TextFieldOutlinedPassword(
             value = "Input text",
             onValueChange = {},
-            enabled = false,
+            isEnabled = false,
         )
     }
 }
 
 @Preview(showBackground = true)
 @Composable
-internal fun PasswordTextFieldOutlinedErrorPreview() {
+internal fun TextFieldOutlinedPasswordErrorPreview() {
     PreviewWithThemes {
-        PasswordTextFieldOutlined(
+        TextFieldOutlinedPassword(
             value = "Input text",
             onValueChange = {},
-            isError = true,
+            hasError = true,
         )
     }
 }
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedSelect.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedSelect.kt
new file mode 100644
index 0000000000000000000000000000000000000000..867030175311b0484d60874239fee316fbf0db98
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedSelect.kt
@@ -0,0 +1,151 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.material.DropdownMenuItem
+import androidx.compose.material.ExperimentalMaterialApi
+import androidx.compose.material.ExposedDropdownMenuBox
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.Icon
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+import androidx.compose.material.OutlinedTextField as MaterialOutlinedTextField
+
+@Suppress("LongParameterList")
+@Composable
+fun <T> TextFieldOutlinedSelect(
+    options: ImmutableList<T>,
+    selectedOption: T,
+    onValueChange: (T) -> Unit,
+    modifier: Modifier = Modifier,
+    optionToStringTransformation: (T) -> String = { it.toString() },
+    label: String? = null,
+    isEnabled: Boolean = true,
+    isReadOnly: Boolean = false,
+    isRequired: Boolean = false,
+    hasError: Boolean = false,
+) {
+    TextFieldDropDownWrapper(
+        isReadOnlyOrDisabled = isReadOnly || !isEnabled,
+        options = options,
+        optionToStringTransformation = optionToStringTransformation,
+        onValueChange = onValueChange,
+    ) { expanded ->
+        MaterialOutlinedTextField(
+            value = optionToStringTransformation(selectedOption),
+            onValueChange = { },
+            modifier = Modifier
+                .fillMaxWidth()
+                .then(modifier),
+            enabled = isEnabled,
+            readOnly = true,
+            label = selectLabel(label, isRequired),
+            trailingIcon = selectTrailingIcon(expanded),
+            isError = hasError,
+            singleLine = true,
+            interactionSource = remember {
+                MutableInteractionSource()
+            },
+        )
+    }
+}
+
+private fun selectTrailingIcon(
+    isExpanded: Boolean,
+): @Composable () -> Unit {
+    return if (isExpanded) {
+        { Icon(Icons.Outlined.arrowDropUp) }
+    } else {
+        { Icon(Icons.Outlined.arrowDropDown) }
+    }
+}
+
+@Composable
+private fun <T> TextFieldDropDownWrapper(
+    isReadOnlyOrDisabled: Boolean,
+    options: ImmutableList<T>,
+    optionToStringTransformation: (T) -> String,
+    onValueChange: (T) -> Unit,
+    content: @Composable (expanded: Boolean) -> Unit,
+) {
+    if (isReadOnlyOrDisabled) {
+        content(false)
+    } else {
+        DropDownMenu(
+            options = options,
+            optionToStringTransformation = optionToStringTransformation,
+            onValueChange = onValueChange,
+            content = content,
+        )
+    }
+}
+
+@OptIn(ExperimentalMaterialApi::class)
+@Composable
+private fun <T> DropDownMenu(
+    options: ImmutableList<T>,
+    onValueChange: (T) -> Unit,
+    optionToStringTransformation: (T) -> String,
+    content: @Composable (expanded: Boolean) -> Unit,
+) {
+    var expanded = remember { mutableStateOf(false) }
+
+    ExposedDropdownMenuBox(
+        expanded = expanded.value,
+        onExpandedChange = {
+            expanded.value = expanded.value.not()
+        },
+    ) {
+        content(expanded.value)
+
+        ExposedDropdownMenu(
+            expanded = expanded.value,
+            onDismissRequest = {
+                expanded.value = false
+            },
+        ) {
+            options.forEach { option ->
+                DropdownMenuItem(
+                    onClick = {
+                        onValueChange(option)
+                        expanded.value = false
+                    },
+                ) {
+                    Text(text = optionToStringTransformation(option))
+                }
+            }
+        }
+    }
+}
+
+@Preview
+@Composable
+internal fun TextFieldOutlinedSelectPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedSelect(
+            options = persistentListOf("Option 1", "Option 2", "Option 3"),
+            selectedOption = "Option 1",
+            onValueChange = {},
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun TextFieldOutlinedSelectPreviewWithLabel() {
+    PreviewWithThemes {
+        TextFieldOutlinedSelect(
+            options = persistentListOf("Option 1", "Option 2", "Option 3"),
+            selectedOption = "Option 1",
+            onValueChange = {},
+            label = "Label",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/ErrorView.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/ErrorView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..54f7d38c31be6f9c1aad5bfa204d1afc9945b043
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/ErrorView.kt
@@ -0,0 +1,95 @@
+package app.k9mail.core.ui.compose.designsystem.molecule
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.Icon
+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 app.k9mail.core.ui.compose.designsystem.R
+import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonText
+import app.k9mail.core.ui.compose.designsystem.atom.button.buttonContentPadding
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody2
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun ErrorView(
+    title: String,
+    modifier: Modifier = Modifier,
+    message: String? = null,
+    onRetry: () -> Unit = { },
+) {
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(
+                vertical = MainTheme.spacings.default,
+                horizontal = MainTheme.spacings.double,
+            )
+            .then(modifier),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+    ) {
+        Icon(
+            imageVector = Icons.Filled.error,
+            contentDescription = null,
+            tint = MainTheme.colors.error,
+            modifier = Modifier.padding(top = MainTheme.spacings.default),
+        )
+        TextSubtitle1(
+            text = title,
+            modifier = Modifier.padding(bottom = MainTheme.spacings.default),
+        )
+        if (message != null) {
+            TextBody2(
+                text = message,
+                modifier = Modifier
+                    .fillMaxWidth(),
+            )
+        }
+        Row(
+            modifier = Modifier
+                .fillMaxWidth(),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.End,
+        ) {
+            ButtonText(
+                text = stringResource(id = R.string.designsystem_molecule_error_view_button_retry),
+                onClick = onRetry,
+                contentPadding = buttonContentPadding(
+                    start = MainTheme.spacings.double,
+                    end = MainTheme.spacings.double,
+                ),
+            )
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun ErrorViewPreview() {
+    PreviewWithThemes {
+        ErrorView(
+            title = "Error",
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun ErrorViewWithMessagePreview() {
+    PreviewWithThemes {
+        ErrorView(
+            title = "Error",
+            message = "Something went wrong.",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/LoadingView.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/LoadingView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..cb799625b5410837917662f940ff4391b0771ddf
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/LoadingView.kt
@@ -0,0 +1,57 @@
+package app.k9mail.core.ui.compose.designsystem.molecule
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.CircularProgressIndicator
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun LoadingView(
+    modifier: Modifier = Modifier,
+    message: String? = null,
+) {
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(MainTheme.spacings.default)
+            .then(modifier),
+        horizontalAlignment = Alignment.CenterHorizontally,
+    ) {
+        if (message != null) {
+            TextSubtitle1(text = message)
+        }
+        Row(
+            modifier = Modifier.height(MainTheme.sizes.larger),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            CircularProgressIndicator()
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun LoadingViewPreview() {
+    PreviewWithThemes {
+        LoadingView()
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun LoadingViewWithMessagePreview() {
+    PreviewWithThemes {
+        LoadingView(
+            message = "Loading ...",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/CheckboxInput.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/CheckboxInput.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c8f6c1ecb909e6e25e7b48554c980e1edfa450c8
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/CheckboxInput.kt
@@ -0,0 +1,82 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.Checkbox
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun CheckboxInput(
+    text: String,
+    checked: Boolean,
+    onCheckedChange: (Boolean) -> Unit,
+    modifier: Modifier = Modifier,
+    errorMessage: String? = null,
+    contentPadding: PaddingValues = inputContentPadding(),
+) {
+    InputLayout(
+        modifier = modifier,
+        contentPadding = contentPadding,
+        errorMessage = errorMessage,
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .clickable { onCheckedChange(!checked) },
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(MainTheme.spacings.half),
+        ) {
+            Checkbox(
+                checked = checked,
+                onCheckedChange = onCheckedChange,
+            )
+            TextBody1(text = text)
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun CheckboxInputPreview() {
+    PreviewWithThemes {
+        CheckboxInput(
+            text = "CheckboxInput",
+            checked = false,
+            onCheckedChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun CheckboxInputWithErrorPreview() {
+    PreviewWithThemes {
+        CheckboxInput(
+            text = "CheckboxInput",
+            checked = false,
+            onCheckedChange = {},
+            errorMessage = "Error message",
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun CheckboxInputCheckedPreview() {
+    PreviewWithThemes {
+        CheckboxInput(
+            text = "CheckboxInput",
+            checked = true,
+            onCheckedChange = {},
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/EmailAddressInput.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/EmailAddressInput.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ace279701e2349c088d1ae87ceebcb8489414dcd
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/EmailAddressInput.kt
@@ -0,0 +1,57 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.R
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedEmailAddress
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun EmailAddressInput(
+    onEmailAddressChange: (String) -> Unit,
+    modifier: Modifier = Modifier,
+    emailAddress: String = "",
+    errorMessage: String? = null,
+    isEnabled: Boolean = true,
+    contentPadding: PaddingValues = inputContentPadding(),
+) {
+    InputLayout(
+        modifier = modifier,
+        contentPadding = contentPadding,
+        errorMessage = errorMessage,
+    ) {
+        TextFieldOutlinedEmailAddress(
+            value = emailAddress,
+            onValueChange = onEmailAddressChange,
+            label = stringResource(id = R.string.designsystem_molecule_email_address_input_label),
+            isEnabled = isEnabled,
+            hasError = errorMessage != null,
+            modifier = Modifier.fillMaxWidth(),
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun EmailAddressInputPreview() {
+    PreviewWithThemes {
+        EmailAddressInput(
+            onEmailAddressChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun EmailAddressInputWithErrorPreview() {
+    PreviewWithThemes {
+        EmailAddressInput(
+            onEmailAddressChange = {},
+            errorMessage = "Email address error",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/InputDefaults.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/InputDefaults.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c69586b4d707cb0343fc7766b3986ce47bb67005
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/InputDefaults.kt
@@ -0,0 +1,28 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.unit.Dp
+import app.k9mail.core.ui.compose.theme.MainTheme
+
+@Composable
+fun inputContentPadding(
+    start: Dp = MainTheme.spacings.double,
+    top: Dp = MainTheme.spacings.default,
+    end: Dp = MainTheme.spacings.double,
+    bottom: Dp = MainTheme.spacings.default,
+): PaddingValues = PaddingValues(
+    start = start,
+    top = top,
+    end = end,
+    bottom = bottom,
+)
+
+@Composable
+fun inputContentPadding(
+    horizontal: Dp = MainTheme.spacings.double,
+    vertical: Dp = MainTheme.spacings.default,
+): PaddingValues = PaddingValues(
+    horizontal = horizontal,
+    vertical = vertical,
+)
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/InputLayout.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/InputLayout.kt
new file mode 100644
index 0000000000000000000000000000000000000000..466183c9deb976f619535d17bd2dfef702010cc0
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/InputLayout.kt
@@ -0,0 +1,36 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextCaption
+import app.k9mail.core.ui.compose.theme.MainTheme
+
+@Composable
+internal fun InputLayout(
+    modifier: Modifier = Modifier,
+    contentPadding: PaddingValues = inputContentPadding(),
+    errorMessage: String? = null,
+    content: @Composable () -> Unit,
+) {
+    Column(
+        modifier = Modifier
+            .padding(contentPadding)
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        content()
+
+        AnimatedVisibility(visible = errorMessage != null) {
+            TextCaption(
+                text = errorMessage ?: "",
+                modifier = Modifier.padding(start = MainTheme.spacings.double, top = MainTheme.spacings.half),
+                color = MainTheme.colors.error,
+            )
+        }
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/NumberInput.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/NumberInput.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7d08af433a3f9783198bc25c8c8efdad8d38f587
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/NumberInput.kt
@@ -0,0 +1,69 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedNumber
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Suppress("LongParameterList")
+@Composable
+fun NumberInput(
+    onValueChange: (Long?) -> Unit,
+    modifier: Modifier = Modifier,
+    value: Long? = null,
+    label: String? = null,
+    isRequired: Boolean = false,
+    errorMessage: String? = null,
+    contentPadding: PaddingValues = inputContentPadding(),
+) {
+    InputLayout(
+        modifier = modifier,
+        contentPadding = contentPadding,
+        errorMessage = errorMessage,
+    ) {
+        TextFieldOutlinedNumber(
+            value = value,
+            onValueChange = onValueChange,
+            label = label,
+            isRequired = isRequired,
+            hasError = errorMessage != null,
+            modifier = Modifier.fillMaxWidth(),
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun IntegerInputPreview() {
+    PreviewWithThemes {
+        NumberInput(
+            onValueChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun IntegerInputIsRequiredPreview() {
+    PreviewWithThemes {
+        NumberInput(
+            onValueChange = {},
+            label = "Text input is required",
+            isRequired = true,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun IntegerInputWithErrorPreview() {
+    PreviewWithThemes {
+        NumberInput(
+            onValueChange = {},
+            errorMessage = "Text input error",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/PasswordInput.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/PasswordInput.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5b02a347d2bab567188aa9fdf1d1dd4197921150
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/PasswordInput.kt
@@ -0,0 +1,57 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.R
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedPassword
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun PasswordInput(
+    onPasswordChange: (String) -> Unit,
+    modifier: Modifier = Modifier,
+    password: String = "",
+    isRequired: Boolean = false,
+    errorMessage: String? = null,
+    contentPadding: PaddingValues = inputContentPadding(),
+) {
+    InputLayout(
+        modifier = modifier,
+        contentPadding = contentPadding,
+        errorMessage = errorMessage,
+    ) {
+        TextFieldOutlinedPassword(
+            value = password,
+            onValueChange = onPasswordChange,
+            label = stringResource(id = R.string.designsystem_molecule_password_input_label),
+            isRequired = isRequired,
+            hasError = errorMessage != null,
+            modifier = Modifier.fillMaxWidth(),
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun PasswordInputPreview() {
+    PreviewWithThemes {
+        PasswordInput(
+            onPasswordChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun PasswordInputWithErrorPreview() {
+    PreviewWithThemes {
+        PasswordInput(
+            onPasswordChange = {},
+            errorMessage = "Password error",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/SelectInput.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/SelectInput.kt
new file mode 100644
index 0000000000000000000000000000000000000000..10525ae7c750f368bde1e27dee74bc3277d816b6
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/SelectInput.kt
@@ -0,0 +1,52 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedSelect
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+
+@Composable
+fun <T> SelectInput(
+    options: ImmutableList<T>,
+    selectedOption: T,
+    onOptionChange: (T) -> Unit,
+    modifier: Modifier = Modifier,
+    optionToStringTransformation: (T) -> String = { it.toString() },
+    label: String? = null,
+    contentPadding: PaddingValues = inputContentPadding(),
+) {
+    Column(
+        modifier = Modifier
+            .padding(contentPadding)
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        TextFieldOutlinedSelect(
+            options = options,
+            selectedOption = selectedOption,
+            onValueChange = onOptionChange,
+            modifier = Modifier.fillMaxWidth(),
+            optionToStringTransformation = optionToStringTransformation,
+            label = label,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun SelectInputPreview() {
+    PreviewWithThemes {
+        SelectInput(
+            options = persistentListOf("Option 1", "Option 2", "Option 3"),
+            selectedOption = "Option 1",
+            onOptionChange = {},
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/SwitchInput.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/SwitchInput.kt
new file mode 100644
index 0000000000000000000000000000000000000000..967c2611ce7ef14236f091b600b918e7870ed304
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/SwitchInput.kt
@@ -0,0 +1,82 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.Switch
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun SwitchInput(
+    text: String,
+    checked: Boolean,
+    onCheckedChange: (Boolean) -> Unit,
+    modifier: Modifier = Modifier,
+    errorMessage: String? = null,
+    contentPadding: PaddingValues = inputContentPadding(),
+) {
+    InputLayout(
+        modifier = modifier,
+        contentPadding = contentPadding,
+        errorMessage = errorMessage,
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .clickable { onCheckedChange(!checked) },
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(MainTheme.spacings.half),
+        ) {
+            Switch(
+                checked = checked,
+                onCheckedChange = onCheckedChange,
+            )
+            TextBody1(text = text)
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun SwitchInputPreview() {
+    PreviewWithThemes {
+        SwitchInput(
+            text = "SwitchInput",
+            checked = false,
+            onCheckedChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun SwitchInputWithErrorPreview() {
+    PreviewWithThemes {
+        SwitchInput(
+            text = "SwitchInput",
+            checked = false,
+            onCheckedChange = {},
+            errorMessage = "Error message",
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun SwitchInputCheckedPreview() {
+    PreviewWithThemes {
+        SwitchInput(
+            text = "SwitchInput",
+            checked = true,
+            onCheckedChange = {},
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/TextInput.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/TextInput.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a78f1a65f89f4308d865edca24d67b1821961f62
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/TextInput.kt
@@ -0,0 +1,71 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlined
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Suppress("LongParameterList")
+@Composable
+fun TextInput(
+    onTextChange: (String) -> Unit,
+    modifier: Modifier = Modifier,
+    text: String = "",
+    label: String? = null,
+    isRequired: Boolean = false,
+    errorMessage: String? = null,
+    contentPadding: PaddingValues = inputContentPadding(),
+    isSingleLine: Boolean = true,
+) {
+    InputLayout(
+        modifier = modifier,
+        contentPadding = contentPadding,
+        errorMessage = errorMessage,
+    ) {
+        TextFieldOutlined(
+            value = text,
+            onValueChange = onTextChange,
+            label = label,
+            isRequired = isRequired,
+            hasError = errorMessage != null,
+            isSingleLine = isSingleLine,
+            modifier = Modifier.fillMaxWidth(),
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextInputPreview() {
+    PreviewWithThemes {
+        TextInput(
+            onTextChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextInputIsRequiredPreview() {
+    PreviewWithThemes {
+        TextInput(
+            onTextChange = {},
+            label = "Text input is required",
+            isRequired = true,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextInputWithErrorPreview() {
+    PreviewWithThemes {
+        TextInput(
+            onTextChange = {},
+            errorMessage = "Text input error",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/organism/TopAppBar.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/organism/TopAppBar.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ab54b805e8a72ffdfba8bf12d8d3dd98093bd63b
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/organism/TopAppBar.kt
@@ -0,0 +1,92 @@
+package app.k9mail.core.ui.compose.designsystem.organism
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.Icon
+import androidx.compose.material.IconButton
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody2
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import androidx.compose.material.TopAppBar as MaterialTopAppBar
+
+@Composable
+fun TopAppBar(
+    title: String,
+    modifier: Modifier = Modifier,
+    subtitle: String? = null,
+    navigationIcon: @Composable (() -> Unit)? = null,
+    actions: @Composable RowScope.() -> Unit = {},
+    titleContentPadding: PaddingValues? = null,
+) {
+    MaterialTopAppBar(
+        title = { TopAppBarTitle(title, subtitle, titleContentPadding) },
+        modifier = modifier,
+        navigationIcon = navigationIcon,
+        actions = actions,
+        backgroundColor = MainTheme.colors.toolbar,
+    )
+}
+
+@Composable
+private fun TopAppBarTitle(
+    title: String,
+    subtitle: String?,
+    titleContentPadding: PaddingValues?,
+) {
+    Column(
+        if (titleContentPadding != null) {
+            Modifier.padding(titleContentPadding)
+        } else {
+            Modifier
+        },
+    ) {
+        Text(text = title)
+        if (subtitle != null) {
+            TextBody2(text = subtitle)
+        }
+    }
+}
+
+@Preview
+@Composable
+internal fun TopAppBarPreview() {
+    PreviewWithThemes {
+        TopAppBar(
+            title = "Title",
+            navigationIcon = {
+                IconButton(onClick = {}) {
+                    Icon(
+                        imageVector = Icons.Outlined.menu,
+                        contentDescription = null,
+                    )
+                }
+            },
+            actions = {
+                IconButton(onClick = {}) {
+                    Icon(
+                        imageVector = Icons.Outlined.menu,
+                        contentDescription = null,
+                    )
+                }
+            },
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun TopAppBarWithSubtitlePreview() {
+    PreviewWithThemes {
+        TopAppBar(
+            title = "Title",
+            subtitle = "Subtitle",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/template/ResponsiveWidthContainer.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/template/ResponsiveWidthContainer.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2d9dcb64c4df710ecb31d1536b25257a007ad226
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/template/ResponsiveWidthContainer.kt
@@ -0,0 +1,103 @@
+package app.k9mail.core.ui.compose.designsystem.template
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.requiredWidth
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.common.window.WindowSizeClass
+import app.k9mail.core.ui.compose.common.window.WindowSizeClass.Compact
+import app.k9mail.core.ui.compose.common.window.WindowSizeClass.Expanded
+import app.k9mail.core.ui.compose.common.window.WindowSizeClass.Medium
+import app.k9mail.core.ui.compose.common.window.getWindowSizeInfo
+import app.k9mail.core.ui.compose.designsystem.atom.Background
+import app.k9mail.core.ui.compose.designsystem.atom.Surface
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.MainTheme
+
+/**
+ * A container that adjusts its width depending on the screen size.
+ *
+ * This composable function acts as a wrapper for its content, applying a modifier that changes
+ * the width of the content based on the current screen size. It uses the `getWindowSizeInfo`
+ * function to determine the screen size, and then applies the appropriate modifier.
+ *
+ * @param modifier Any modifier that should be applied to the outer container. This can be used
+ * to add padding, background colors, click events, etc.
+ * @param content The content to be placed inside this container. The content is expected to be
+ * a composable function.
+ *
+ * Example usage:
+ * ```
+ * ResponsiveWidthContainer {
+ *     Text("Hello, World!")
+ * }
+ * ```
+ */
+@Composable
+fun ResponsiveWidthContainer(
+    modifier: Modifier = Modifier,
+    content: @Composable () -> Unit,
+) {
+    val windowSizeInfo = getWindowSizeInfo()
+
+    val responsiveModifier = when (windowSizeInfo.screenWidthSizeClass) {
+        Compact -> Modifier.fillMaxWidth()
+
+        Medium -> Modifier.requiredWidth(WindowSizeClass.COMPACT_MAX_WIDTH.dp)
+
+        Expanded -> Modifier.requiredWidth(WindowSizeClass.MEDIUM_MAX_WIDTH.dp)
+    }
+
+    Box(
+        modifier = Modifier
+            .fillMaxWidth()
+            .then(modifier),
+        contentAlignment = Alignment.TopCenter,
+    ) {
+        Box(
+            modifier = responsiveModifier,
+        ) {
+            content()
+        }
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun ResponsiveWidthContainerK9Preview() {
+    K9Theme {
+        Background {
+            ResponsiveWidthContainer {
+                Surface(
+                    color = MainTheme.colors.error,
+                    modifier = Modifier.fillMaxSize(),
+                ) {
+                    Text("Hello, World!")
+                }
+            }
+        }
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun ResponsiveWidthContainerThunderbirdPreview() {
+    K9Theme {
+        Background {
+            ResponsiveWidthContainer {
+                Surface(
+                    color = MainTheme.colors.error,
+                    modifier = Modifier.fillMaxSize(),
+                ) {
+                    Text("Hello, World!")
+                }
+            }
+        }
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/template/Scaffold.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/template/Scaffold.kt
new file mode 100644
index 0000000000000000000000000000000000000000..414ebdd05ddb5c29ebd78b4bcb13a13b24d7bb9b
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/template/Scaffold.kt
@@ -0,0 +1,120 @@
+package app.k9mail.core.ui.compose.designsystem.template
+
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.DrawerState
+import androidx.compose.material.Scaffold
+import androidx.compose.material.rememberScaffoldState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.designsystem.atom.Surface
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.MainTheme
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import androidx.compose.material.FabPosition as MaterialFabPosition
+import androidx.compose.material.Scaffold as MaterialScaffold
+
+@Suppress("LongParameterList")
+@Composable
+fun Scaffold(
+    modifier: Modifier = Modifier,
+    topBar: @Composable (toggleDrawer: () -> Unit) -> Unit = {},
+    bottomBar: @Composable () -> Unit = {},
+    floatingActionButton: @Composable () -> Unit = {},
+    floatingActionButtonPosition: ScaffoldFabPosition = ScaffoldFabPosition.End,
+    drawerContent: @Composable (ColumnScope.(toggleDrawer: () -> Unit) -> Unit)? = null,
+    content: @Composable (PaddingValues) -> Unit,
+) {
+    val scaffoldState = rememberScaffoldState()
+    val coroutineScope = rememberCoroutineScope()
+
+    MaterialScaffold(
+        modifier = modifier,
+        scaffoldState = scaffoldState,
+        topBar = {
+            topBar { toggleDrawer(scaffoldState.drawerState, coroutineScope) }
+        },
+        bottomBar = bottomBar,
+        floatingActionButton = floatingActionButton,
+        floatingActionButtonPosition = floatingActionButtonPosition.toMaterialFabPosition(),
+        drawerContent = drawerContent?.let { providedDrawerContent ->
+            {
+                providedDrawerContent { toggleDrawer(scaffoldState.drawerState, coroutineScope) }
+            }
+        },
+        drawerGesturesEnabled = scaffoldState.drawerState.isOpen,
+        content = content,
+    )
+}
+
+private fun toggleDrawer(
+    drawerState: DrawerState,
+    coroutineScope: CoroutineScope,
+) {
+    coroutineScope.launch {
+        delay(timeMillis = DRAWER_TOGGLE_DELAY)
+        if (drawerState.isClosed) {
+            drawerState.open()
+        } else {
+            drawerState.close()
+        }
+    }
+}
+
+enum class ScaffoldFabPosition {
+    End,
+    Center,
+}
+
+private fun ScaffoldFabPosition.toMaterialFabPosition(): MaterialFabPosition {
+    return when (this) {
+        ScaffoldFabPosition.End -> MaterialFabPosition.End
+        ScaffoldFabPosition.Center -> MaterialFabPosition.Center
+    }
+}
+
+/**
+ * Delay before opening/closing the drawer to avoid the drawer being opened/closed
+ * immediately and give time for the ripple effect to finish.
+ */
+private const val DRAWER_TOGGLE_DELAY = 250L
+
+@Composable
+@DevicePreviews
+internal fun ScaffoldPreview() {
+    K9Theme {
+        Scaffold(
+            topBar = {
+                Surface(
+                    color = MainTheme.colors.error,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .height(MainTheme.sizes.topBarHeight),
+                ) {}
+            },
+            bottomBar = {
+                Surface(
+                    color = MainTheme.colors.error,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .height(MainTheme.sizes.bottomBarHeight),
+                ) {}
+            },
+        ) { contentPadding ->
+            Surface(
+                color = MainTheme.colors.info,
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(contentPadding),
+            ) {}
+        }
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/res/values/strings.xml b/core/ui/compose/designsystem/src/main/res/values/strings.xml
index 6d8ca68e1bf2340aae0fd271ad5f8e90c39cb518..d23ac906c833317a496a04b1437c3eb748e35e92 100644
--- a/core/ui/compose/designsystem/src/main/res/values/strings.xml
+++ b/core/ui/compose/designsystem/src/main/res/values/strings.xml
@@ -2,4 +2,7 @@
 <resources>
     <string name="designsystem_atom_password_textfield_hide_password">Hide password</string>
     <string name="designsystem_atom_password_textfield_show_password">Show password</string>
+    <string name="designsystem_molecule_email_address_input_label">Email address</string>
+    <string name="designsystem_molecule_password_input_label">Password</string>
+    <string name="designsystem_molecule_error_view_button_retry">Retry</string>
 </resources>
diff --git a/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/CommonTextFieldTest.kt b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/CommonTextFieldTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b8338ee5949a4f5a4d1a2598251a4ef258f89280
--- /dev/null
+++ b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/CommonTextFieldTest.kt
@@ -0,0 +1,284 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.assertIsEnabled
+import androidx.compose.ui.test.assertIsNotEnabled
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performTextInput
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import assertk.assertFailure
+import kotlinx.collections.immutable.persistentListOf
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.ParameterizedRobolectricTestRunner
+
+private const val LABEL = "Label"
+
+data class TextFieldConfig(
+    val label: String?,
+    val isEnabled: Boolean?,
+    val isReadOnly: Boolean,
+    val isRequired: Boolean,
+)
+
+data class CommonTextFieldTestData(
+    val name: String,
+    val content: @Composable (
+        modifier: Modifier,
+        textFieldConfig: TextFieldConfig,
+    ) -> Unit,
+)
+
+@RunWith(ParameterizedRobolectricTestRunner::class)
+class CommonTextFieldTest(
+    data: CommonTextFieldTestData,
+) : ComposeTest() {
+
+    private val testSubjectName = data.name
+    private val testSubject = data.content
+
+    @Test
+    fun `should be enabled by default`() = runComposeTest {
+        setContent {
+            testSubject(
+                modifier = Modifier.testTag(testSubjectName),
+                textFieldConfig = TextFieldConfig(
+                    label = null,
+                    isEnabled = null,
+                    isReadOnly = false,
+                    isRequired = false,
+                ),
+            )
+        }
+
+        onNodeWithTag(testSubjectName).assertIsEnabled()
+    }
+
+    @Test
+    fun `should be disabled when enabled is false`() = runComposeTest {
+        setContent {
+            testSubject(
+                modifier = Modifier.testTag(testSubjectName),
+                textFieldConfig = TextFieldConfig(
+                    label = null,
+                    isEnabled = false,
+                    isReadOnly = false,
+                    isRequired = false,
+                ),
+            )
+        }
+
+        onNodeWithTag(testSubjectName).assertIsNotEnabled()
+    }
+
+    @Test
+    fun `should show label when label is not null`() = runComposeTest {
+        setContent {
+            testSubject(
+                modifier = Modifier.testTag(testSubjectName),
+                textFieldConfig = TextFieldConfig(
+                    label = LABEL,
+                    isEnabled = null,
+                    isReadOnly = false,
+                    isRequired = false,
+                ),
+            )
+        }
+
+        onNodeWithText(LABEL).assertIsDisplayed()
+    }
+
+    @Test
+    fun `should show asterisk when isRequired is true`() = runComposeTest {
+        setContent {
+            testSubject(
+                modifier = Modifier.testTag(testSubjectName),
+                textFieldConfig = TextFieldConfig(
+                    label = LABEL,
+                    isEnabled = null,
+                    isReadOnly = false,
+                    isRequired = true,
+                ),
+            )
+        }
+
+        onNodeWithText("$LABEL*").assertIsDisplayed()
+    }
+
+    @Test
+    fun `should not show asterisk when isRequired is false`() = runComposeTest {
+        setContent {
+            testSubject(
+                modifier = Modifier.testTag(testSubjectName),
+                textFieldConfig = TextFieldConfig(
+                    label = LABEL,
+                    isEnabled = null,
+                    isReadOnly = false,
+                    isRequired = false,
+                ),
+            )
+        }
+
+        onNodeWithText("$LABEL*").assertDoesNotExist()
+    }
+
+    @Test
+    fun `should not allow editing when isReadOnly is true`() = runComposeTest {
+        setContent {
+            testSubject(
+                modifier = Modifier.testTag(testSubjectName),
+                textFieldConfig = TextFieldConfig(
+                    label = LABEL,
+                    isEnabled = null,
+                    isReadOnly = true,
+                    isRequired = false,
+                ),
+            )
+        }
+
+        onNodeWithTag(testSubjectName).performClick()
+        assertFailure {
+            onNodeWithText(testSubjectName).performTextInput(" + added text")
+        }
+    }
+
+    companion object {
+        @JvmStatic
+        @ParameterizedRobolectricTestRunner.Parameters(name = "{0}")
+        @Suppress("LongMethod")
+        fun data(): List<CommonTextFieldTestData> = listOf(
+            CommonTextFieldTestData(
+                name = "TextFieldOutlined",
+                content = { modifier, config ->
+                    if (config.isEnabled != null) {
+                        TextFieldOutlined(
+                            value = "",
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isEnabled = config.isEnabled,
+                            isReadOnly = config.isReadOnly,
+                            isRequired = config.isRequired,
+                        )
+                    } else {
+                        TextFieldOutlined(
+                            value = "",
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isRequired = config.isRequired,
+                            isReadOnly = config.isReadOnly,
+                        )
+                    }
+                },
+            ),
+            CommonTextFieldTestData(
+                name = "TextFieldOutlinedPassword",
+                content = { modifier, config ->
+                    if (config.isEnabled != null) {
+                        TextFieldOutlinedPassword(
+                            value = "",
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isEnabled = config.isEnabled,
+                            isReadOnly = config.isReadOnly,
+                            isRequired = config.isRequired,
+                        )
+                    } else {
+                        TextFieldOutlinedPassword(
+                            value = "",
+                            onValueChange = {},
+                            label = config.label,
+                            modifier = modifier,
+                            isRequired = config.isRequired,
+                            isReadOnly = config.isReadOnly,
+                        )
+                    }
+                },
+            ),
+            CommonTextFieldTestData(
+                name = "TextFieldOutlinedEmail",
+                content = { modifier, config ->
+                    if (config.isEnabled != null) {
+                        TextFieldOutlinedEmailAddress(
+                            value = "",
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isEnabled = config.isEnabled,
+                            isReadOnly = config.isReadOnly,
+                            isRequired = config.isRequired,
+                        )
+                    } else {
+                        TextFieldOutlinedEmailAddress(
+                            value = "",
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isRequired = config.isRequired,
+                            isReadOnly = config.isReadOnly,
+                        )
+                    }
+                },
+            ),
+            CommonTextFieldTestData(
+                name = "TextFieldOutlinedNumber",
+                content = { modifier, config ->
+                    if (config.isEnabled != null) {
+                        TextFieldOutlinedNumber(
+                            value = 123L,
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isEnabled = config.isEnabled,
+                            isReadOnly = config.isReadOnly,
+                            isRequired = config.isRequired,
+                        )
+                    } else {
+                        TextFieldOutlinedNumber(
+                            value = 123L,
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isRequired = config.isRequired,
+                            isReadOnly = config.isReadOnly,
+                        )
+                    }
+                },
+            ),
+            CommonTextFieldTestData(
+                name = "TextFieldOutlinedSelect",
+                content = { modifier, config ->
+                    if (config.isEnabled != null) {
+                        TextFieldOutlinedSelect(
+                            options = persistentListOf("option1", "option2"),
+                            selectedOption = "option1",
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isEnabled = config.isEnabled,
+                            isReadOnly = config.isReadOnly,
+                            isRequired = config.isRequired,
+                        )
+                    } else {
+                        TextFieldOutlinedSelect(
+                            options = persistentListOf("option1", "option2"),
+                            selectedOption = "option1",
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isRequired = config.isRequired,
+                            isReadOnly = config.isReadOnly,
+                        )
+                    }
+                },
+            ),
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldKtTest.kt b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldKtTest.kt
deleted file mode 100644
index 086c2bbce9f8ae7e733448885bda648b2d45c75e..0000000000000000000000000000000000000000
--- a/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldKtTest.kt
+++ /dev/null
@@ -1,154 +0,0 @@
-package app.k9mail.core.ui.compose.designsystem.atom.textfield
-
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.testTag
-import androidx.compose.ui.test.assertIsDisplayed
-import androidx.compose.ui.test.assertIsEnabled
-import androidx.compose.ui.test.assertIsNotEnabled
-import androidx.compose.ui.test.onNodeWithTag
-import androidx.compose.ui.test.onNodeWithText
-import androidx.compose.ui.test.performClick
-import androidx.compose.ui.test.performTextInput
-import app.k9mail.core.ui.compose.testing.ComposeTest
-import assertk.assertThat
-import assertk.assertions.isEqualTo
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.robolectric.ParameterizedRobolectricTestRunner
-
-private const val VALUE = "Input text"
-private const val LABEL = "Label"
-
-data class TextFieldTestData(
-    val name: String,
-    val content: @Composable (
-        value: String,
-        onValueChange: (String) -> Unit,
-        modifier: Modifier,
-        enabled: Boolean?,
-        label: String?,
-    ) -> Unit,
-)
-
-@RunWith(ParameterizedRobolectricTestRunner::class)
-class TextFieldKtTest(
-    data: TextFieldTestData,
-) : ComposeTest() {
-
-    private val testSubjectName = data.name
-    private val testSubject = data.content
-
-    @Test
-    fun `should call onValueChange when value changes`() = runComposeTest {
-        var value = VALUE
-        setContent {
-            testSubject(
-                value = value,
-                onValueChange = { value = it },
-                modifier = Modifier.testTag(testSubjectName),
-                enabled = null,
-                label = null,
-            )
-        }
-
-        onNodeWithTag(testSubjectName).performClick()
-        onNodeWithTag(testSubjectName).performTextInput(" + added text")
-
-        assertThat(value).isEqualTo("$VALUE + added text")
-    }
-
-    @Test
-    fun `should be enabled by default`() = runComposeTest {
-        setContent {
-            testSubject(
-                value = VALUE,
-                onValueChange = {},
-                modifier = Modifier.testTag(testSubjectName),
-                enabled = null,
-                label = null,
-            )
-        }
-
-        onNodeWithTag(testSubjectName).assertIsEnabled()
-    }
-
-    @Test
-    fun `should be disabled when enabled is false`() = runComposeTest {
-        setContent {
-            testSubject(
-                value = VALUE,
-                onValueChange = {},
-                modifier = Modifier.testTag(testSubjectName),
-                enabled = false,
-                label = null,
-            )
-        }
-
-        onNodeWithTag(testSubjectName).assertIsNotEnabled()
-    }
-
-    @Test
-    fun `should show label when label is not null`() = runComposeTest {
-        setContent {
-            testSubject(
-                value = VALUE,
-                onValueChange = {},
-                modifier = Modifier.testTag(testSubjectName),
-                enabled = null,
-                label = LABEL,
-            )
-        }
-
-        onNodeWithText(LABEL).assertIsDisplayed()
-    }
-
-    companion object {
-        @JvmStatic
-        @ParameterizedRobolectricTestRunner.Parameters(name = "{0}")
-        fun data(): List<TextFieldTestData> = listOf(
-            TextFieldTestData(
-                name = "TextFieldOutlined",
-                content = { value, onValueChange, modifier, enabled, label ->
-                    if (enabled != null) {
-                        TextFieldOutlined(
-                            value = value,
-                            onValueChange = onValueChange,
-                            modifier = modifier,
-                            enabled = enabled,
-                            label = label,
-                        )
-                    } else {
-                        TextFieldOutlined(
-                            value = value,
-                            onValueChange = onValueChange,
-                            modifier = modifier,
-                            label = label,
-                        )
-                    }
-                },
-            ),
-            TextFieldTestData(
-                name = "PasswordTextFieldOutlined",
-                content = { value, onValueChange, modifier, enabled, label ->
-                    if (enabled != null) {
-                        PasswordTextFieldOutlined(
-                            value = value,
-                            onValueChange = onValueChange,
-                            modifier = modifier,
-                            enabled = enabled,
-                            label = label,
-                        )
-                    } else {
-                        PasswordTextFieldOutlined(
-                            value = value,
-                            onValueChange = onValueChange,
-                            modifier = modifier,
-                            label = label,
-                        )
-                    }
-                },
-            ),
-        )
-    }
-}
diff --git a/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedNumberKtTest.kt b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedNumberKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..342db161f5a131ca7412f009f8c395913907dc22
--- /dev/null
+++ b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedNumberKtTest.kt
@@ -0,0 +1,85 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performTextClearance
+import androidx.compose.ui.test.performTextInput
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+private const val TEST_TAG = "TextFieldOutlinedNumber"
+
+class TextFieldOutlinedNumberKtTest : ComposeTest() {
+
+    @Test
+    fun `should call onValueChange with null when input is empty`() = runComposeTest {
+        var value: Long? = 1L
+        setContent {
+            TextFieldOutlinedNumber(
+                value = value,
+                onValueChange = { value = it },
+                modifier = Modifier.testTag(TEST_TAG),
+            )
+        }
+
+        onNodeWithTag(TEST_TAG).performClick()
+        onNodeWithTag(TEST_TAG).performTextClearance()
+
+        assertThat(value).isEqualTo(null)
+    }
+
+    @Test
+    fun `should call onValueChange when value changes`() = runComposeTest {
+        var value: Long? = 123L
+        setContent {
+            TextFieldOutlinedNumber(
+                value = value,
+                onValueChange = { value = it },
+                modifier = Modifier.testTag(TEST_TAG),
+            )
+        }
+
+        onNodeWithTag(TEST_TAG).performClick()
+        onNodeWithTag(TEST_TAG).performTextInput("456")
+
+        assertThat(value).isEqualTo(123456L)
+    }
+
+    @Test
+    fun `should return null when no number`() = runComposeTest {
+        var value: Long? = 123L
+        setContent {
+            TextFieldOutlinedNumber(
+                value = value,
+                onValueChange = { value = it },
+                modifier = Modifier.testTag(TEST_TAG),
+            )
+        }
+
+        onNodeWithTag(TEST_TAG).performClick()
+        onNodeWithTag(TEST_TAG).performTextInput(",")
+
+        assertThat(value).isEqualTo(null)
+    }
+
+    @Test
+    fun `should return null when input exceeds max long`() = runComposeTest {
+        var value: Long? = null
+        setContent {
+            TextFieldOutlinedNumber(
+                value = value,
+                onValueChange = { value = it },
+                modifier = Modifier.testTag(TEST_TAG),
+            )
+        }
+
+        onNodeWithTag(TEST_TAG).performClick()
+        onNodeWithTag(TEST_TAG).performTextInput("9223372036854775808")
+
+        assertThat(value).isEqualTo(null)
+    }
+}
diff --git a/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/PasswordTextFieldOutlinedKtTest.kt b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedPasswordKtTest.kt
similarity index 91%
rename from core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/PasswordTextFieldOutlinedKtTest.kt
rename to core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedPasswordKtTest.kt
index d80d36a877aaca5ae51d4b5d10cd151e14256d78..a4bbfa6cfab2950c6c79c7da6bff4fd887cc004d 100644
--- a/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/PasswordTextFieldOutlinedKtTest.kt
+++ b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedPasswordKtTest.kt
@@ -12,12 +12,12 @@ import org.junit.Test
 
 private const val PASSWORD = "Password input"
 
-class PasswordTextFieldOutlinedKtTest : ComposeTest() {
+class TextFieldOutlinedPasswordKtTest : ComposeTest() {
 
     @Test
     fun `should not display password by default`() = runComposeTest {
         setContent {
-            PasswordTextFieldOutlined(
+            TextFieldOutlinedPassword(
                 value = PASSWORD,
                 onValueChange = {},
             )
@@ -29,7 +29,7 @@ class PasswordTextFieldOutlinedKtTest : ComposeTest() {
     @Test
     fun `should display password when show password is clicked`() = runComposeTest {
         setContent {
-            PasswordTextFieldOutlined(
+            TextFieldOutlinedPassword(
                 value = PASSWORD,
                 onValueChange = {},
             )
@@ -43,7 +43,7 @@ class PasswordTextFieldOutlinedKtTest : ComposeTest() {
     @Test
     fun `should not display password when hide password is clicked`() = runComposeTest {
         setContent {
-            PasswordTextFieldOutlined(
+            TextFieldOutlinedPassword(
                 value = PASSWORD,
                 onValueChange = {},
             )
@@ -58,7 +58,7 @@ class PasswordTextFieldOutlinedKtTest : ComposeTest() {
     @Test
     fun `should display hide password icon when show password is clicked`() = runComposeTest {
         setContent {
-            PasswordTextFieldOutlined(
+            TextFieldOutlinedPassword(
                 value = PASSWORD,
                 onValueChange = {},
             )
@@ -72,7 +72,7 @@ class PasswordTextFieldOutlinedKtTest : ComposeTest() {
     @Test
     fun `should display show password icon when hide password icon is clicked`() = runComposeTest {
         setContent {
-            PasswordTextFieldOutlined(
+            TextFieldOutlinedPassword(
                 value = PASSWORD,
                 onValueChange = {},
             )
diff --git a/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedSelectTest.kt b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedSelectTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..50ad54da58fd9a22fc9ca287639aa1e46dbe63ee
--- /dev/null
+++ b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedSelectTest.kt
@@ -0,0 +1,68 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlin.test.Test
+import kotlinx.collections.immutable.persistentListOf
+
+private const val TEST_TAG = "TextFieldOutlinedSelect"
+
+class TextFieldOutlinedSelectTest : ComposeTest() {
+    @Test
+    fun `should call onValueChange when value changes`() = runComposeTest {
+        var value = "option1"
+        setContent {
+            TextFieldOutlinedSelect(
+                options = persistentListOf("option1", "option2"),
+                selectedOption = value,
+                onValueChange = { value = it },
+                modifier = Modifier.testTag(TEST_TAG),
+            )
+        }
+
+        onNodeWithTag(TEST_TAG).performClick()
+
+        onNodeWithText("option2").performClick()
+        assertThat(value).isEqualTo("option2")
+    }
+
+    @Test
+    fun `should not show dropdown when not enabled`() = runComposeTest {
+        setContent {
+            TextFieldOutlinedSelect(
+                options = persistentListOf("option1", "option2"),
+                selectedOption = "option1",
+                onValueChange = {},
+                modifier = Modifier.testTag(TEST_TAG),
+                isEnabled = false,
+            )
+        }
+
+        onNodeWithTag(TEST_TAG).performClick()
+
+        onNodeWithText("option2").assertDoesNotExist()
+    }
+
+    @Test
+    fun `should not show dropdown when read-only`() = runComposeTest {
+        setContent {
+            TextFieldOutlinedSelect(
+                options = persistentListOf("option1", "option2"),
+                selectedOption = "option1",
+                onValueChange = {},
+                modifier = Modifier.testTag(TEST_TAG),
+                isReadOnly = true,
+            )
+        }
+
+        onNodeWithTag(TEST_TAG).performClick()
+
+        onNodeWithText("option2").assertDoesNotExist()
+    }
+}
diff --git a/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextInputTextFieldTest.kt b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextInputTextFieldTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7beecff87647d9c18521f8b905eadb16d142dd20
--- /dev/null
+++ b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextInputTextFieldTest.kt
@@ -0,0 +1,91 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performTextInput
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.ParameterizedRobolectricTestRunner
+
+data class TextInputTextFieldTestData(
+    val name: String,
+    val input: String,
+    val content: @Composable (
+        value: String,
+        onValueChange: (String) -> Unit,
+        modifier: Modifier,
+    ) -> Unit,
+)
+
+@RunWith(ParameterizedRobolectricTestRunner::class)
+class TextInputTextFieldTest(
+    data: TextInputTextFieldTestData,
+) : ComposeTest() {
+
+    private val testSubjectName = data.name
+    private val testSubject = data.content
+    private val testInput = data.input
+
+    @Test
+    fun `should call onValueChange when value changes`() = runComposeTest {
+        var value = testInput
+        setContent {
+            testSubject(
+                value = value,
+                onValueChange = { value = it },
+                modifier = Modifier.testTag(testSubjectName),
+            )
+        }
+
+        onNodeWithTag(testSubjectName).performClick()
+        onNodeWithTag(testSubjectName).performTextInput(" + added text")
+
+        assertThat(value).isEqualTo("$testInput + added text")
+    }
+
+    companion object {
+        @JvmStatic
+        @ParameterizedRobolectricTestRunner.Parameters(name = "{0}")
+        fun data(): List<TextInputTextFieldTestData> = listOf(
+            TextInputTextFieldTestData(
+                name = "TextFieldOutlined",
+                input = "value",
+                content = { value, onValueChange: (String) -> Unit, modifier ->
+                    TextFieldOutlined(
+                        value = value,
+                        onValueChange = onValueChange,
+                        modifier = modifier,
+                    )
+                },
+            ),
+            TextInputTextFieldTestData(
+                name = "TextFieldOutlinedPassword",
+                input = "value",
+                content = { value, onValueChange: (String) -> Unit, modifier ->
+                    TextFieldOutlinedPassword(
+                        value = value,
+                        onValueChange = onValueChange,
+                        modifier = modifier,
+                    )
+                },
+            ),
+            TextInputTextFieldTestData(
+                name = "TextFieldOutlinedEmail",
+                input = "value",
+                content = { value, onValueChange: (String) -> Unit, modifier ->
+                    TextFieldOutlinedEmailAddress(
+                        value = value,
+                        onValueChange = onValueChange,
+                        modifier = modifier,
+                    )
+                },
+            ),
+        )
+    }
+}
diff --git a/core/ui/compose/testing/build.gradle.kts b/core/ui/compose/testing/build.gradle.kts
index b72db636647c0def5ad660ec78f7a4bc040d5d95..5d4ed211d6cba868d240f0e5981159321380bf12 100644
--- a/core/ui/compose/testing/build.gradle.kts
+++ b/core/ui/compose/testing/build.gradle.kts
@@ -7,6 +7,8 @@ android {
 }
 
 dependencies {
+    api(projects.core.testing)
+
     implementation(projects.core.ui.compose.theme)
     implementation(libs.androidx.compose.material)
 
diff --git a/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/ComposeTest.kt b/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/ComposeTest.kt
index 855d0cc3aed171b74e7eb8c31850f929d8cb0ee8..471eb13d20fa97ad6337c1267005a0b9ce747a28 100644
--- a/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/ComposeTest.kt
+++ b/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/ComposeTest.kt
@@ -1,8 +1,16 @@
 package app.k9mail.core.ui.compose.testing
 
 import androidx.annotation.StringRes
+import androidx.compose.runtime.Composable
 import androidx.compose.ui.test.junit4.ComposeContentTestRule
 import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onAllNodesWithContentDescription
+import androidx.compose.ui.test.onAllNodesWithTag
+import androidx.compose.ui.test.onAllNodesWithText
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.onRoot
 import org.junit.Rule
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
@@ -20,3 +28,45 @@ open class ComposeTest {
         testContent()
     }
 }
+
+fun ComposeTest.setContent(content: @Composable () -> Unit) = composeTestRule.setContent(content)
+
+fun ComposeTest.onNodeWithTag(
+    tag: String,
+    useUnmergedTree: Boolean = false,
+) = composeTestRule.onNodeWithTag(tag, useUnmergedTree)
+
+fun ComposeTest.onAllNodesWithTag(
+    tag: String,
+    useUnmergedTree: Boolean = false,
+) = composeTestRule.onAllNodesWithTag(tag, useUnmergedTree)
+
+fun ComposeTest.onNodeWithContentDescription(
+    label: String,
+    substring: Boolean = false,
+    ignoreCase: Boolean = false,
+    useUnmergedTree: Boolean = false,
+) = composeTestRule.onNodeWithContentDescription(label, substring, ignoreCase, useUnmergedTree)
+
+fun ComposeTest.onNodeWithText(
+    text: String,
+    substring: Boolean = false,
+    ignoreCase: Boolean = false,
+    useUnmergedTree: Boolean = false,
+) = composeTestRule.onNodeWithText(text, substring, ignoreCase, useUnmergedTree)
+
+fun ComposeTest.onAllNodesWithText(
+    text: String,
+    substring: Boolean = false,
+    ignoreCase: Boolean = false,
+    useUnmergedTree: Boolean = false,
+) = composeTestRule.onAllNodesWithText(text, substring, ignoreCase, useUnmergedTree)
+
+fun ComposeTest.onAllNodesWithContentDescription(
+    label: String,
+    substring: Boolean = false,
+    ignoreCase: Boolean = false,
+    useUnmergedTree: Boolean = false,
+) = composeTestRule.onAllNodesWithContentDescription(label, substring, ignoreCase, useUnmergedTree)
+
+fun ComposeTest.onRoot(useUnmergedTree: Boolean = false) = composeTestRule.onRoot(useUnmergedTree)
diff --git a/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/MainDispatcherRule.kt b/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/MainDispatcherRule.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d19e2742be19d79eaea927a84ff4e3f74975c3c0
--- /dev/null
+++ b/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/MainDispatcherRule.kt
@@ -0,0 +1,23 @@
+package app.k9mail.core.ui.compose.testing
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.test.TestDispatcher
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import org.junit.rules.TestWatcher
+
+/**
+ * A JUnit rule that swaps the [Dispatchers.Main] dispatcher with a [TestDispatcher] for the duration of the test.
+ */
+class MainDispatcherRule(
+    val testDispatcher: TestDispatcher = UnconfinedTestDispatcher(),
+) : TestWatcher() {
+    override fun starting(description: org.junit.runner.Description?) {
+        Dispatchers.setMain(testDispatcher)
+    }
+
+    override fun finished(description: org.junit.runner.Description?) {
+        Dispatchers.resetMain()
+    }
+}
diff --git a/core/ui/compose/theme/build.gradle.kts b/core/ui/compose/theme/build.gradle.kts
index 08dae1d6cb4acf6e7c5dbbb5a5dd442845438079..30b8ecc1ae6ecab856b32c170b4a1fd9d497f22e 100644
--- a/core/ui/compose/theme/build.gradle.kts
+++ b/core/ui/compose/theme/build.gradle.kts
@@ -11,4 +11,5 @@ dependencies {
     api(projects.core.ui.compose.common)
     implementation(libs.accompanist.systemuicontroller)
     implementation(libs.androidx.compose.material)
+    implementation(libs.androidx.compose.material.icons.extended)
 }
diff --git a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Icons.kt b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Icons.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c27cb69b790357139885273f325d424c579f53e4
--- /dev/null
+++ b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Icons.kt
@@ -0,0 +1,50 @@
+package app.k9mail.core.ui.compose.theme
+
+import androidx.compose.material.icons.filled.AccountCircle
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.filled.Error
+import androidx.compose.material.icons.filled.Menu
+import androidx.compose.material.icons.filled.MoveToInbox
+import androidx.compose.material.icons.filled.Notifications
+import androidx.compose.material.icons.filled.Outbox
+import androidx.compose.material.icons.filled.Security
+import androidx.compose.material.icons.filled.Visibility
+import androidx.compose.material.icons.filled.VisibilityOff
+import androidx.compose.material.icons.outlined.ArrowBack
+import androidx.compose.material.icons.outlined.ArrowDropDown
+import androidx.compose.material.icons.outlined.ArrowDropUp
+import androidx.compose.material.icons.outlined.Check
+import androidx.compose.material.icons.outlined.Error
+import androidx.compose.material.icons.outlined.ErrorOutline
+import androidx.compose.material.icons.outlined.ExpandLess
+import androidx.compose.material.icons.outlined.ExpandMore
+import androidx.compose.material.icons.outlined.Info
+import androidx.compose.material.icons.outlined.Menu
+import androidx.compose.material.icons.outlined.WarningAmber
+import androidx.compose.material.icons.Icons as MaterialIcons
+
+object Icons {
+    object Filled {
+        val error = MaterialIcons.Filled.Error
+        val inbox = MaterialIcons.Filled.MoveToInbox
+        val notification = MaterialIcons.Filled.Notifications
+        val outbox = MaterialIcons.Filled.Outbox
+        val security = MaterialIcons.Filled.Security
+        val passwordVisibility = MaterialIcons.Filled.Visibility
+        val passwordVisibilityOff = MaterialIcons.Filled.VisibilityOff
+        val user = MaterialIcons.Filled.AccountCircle
+    }
+
+    object Outlined {
+        val arrowBack = MaterialIcons.Outlined.ArrowBack
+        val arrowDropDown = MaterialIcons.Outlined.ArrowDropDown
+        val arrowDropUp = MaterialIcons.Outlined.ArrowDropUp
+        val menu = MaterialIcons.Outlined.Menu
+        val check = MaterialIcons.Outlined.Check
+        val info = MaterialIcons.Outlined.Info
+        val warning = MaterialIcons.Outlined.WarningAmber
+        val error = MaterialIcons.Outlined.ErrorOutline
+        val expandMore = MaterialIcons.Outlined.ExpandMore
+        val expandLess = MaterialIcons.Outlined.ExpandLess
+    }
+}
diff --git a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/MainTheme.kt b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/MainTheme.kt
index 2d48f928545319d1fc9854aa8cd3b1977d015ba3..daf78a40edda43351d0b8ec4dce8e02cb1e0ced0 100644
--- a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/MainTheme.kt
+++ b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/MainTheme.kt
@@ -2,7 +2,6 @@ package app.k9mail.core.ui.compose.theme
 
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Shapes
 import androidx.compose.material.Typography
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
@@ -34,17 +33,20 @@ fun MainTheme(
 
     SetSystemBarsColor(color = colors.toolbar)
 
+    val shapes = MainTheme.shapes
+
     CompositionLocalProvider(
         LocalColors provides colors,
         LocalElevations provides Elevations(),
         LocalImages provides images,
         LocalSizes provides Sizes(),
         LocalSpacings provides Spacings(),
+        LocalShapes provides shapes,
     ) {
         MaterialTheme(
             colors = colors.toMaterialColors(),
             typography = typography,
-            shapes = shapes,
+            shapes = shapes.toMaterialShapes(),
             content = content,
         )
     }
@@ -64,7 +66,7 @@ object MainTheme {
     val shapes: Shapes
         @Composable
         @ReadOnlyComposable
-        get() = MaterialTheme.shapes
+        get() = LocalShapes.current
 
     val spacings: Spacings
         @Composable
diff --git a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Shapes.kt b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Shapes.kt
index 722200dfc92568a05dd0a232cae52cc24137d7c5..6ff96291a9d5251e8d99f2a66def8f8f7148e115 100644
--- a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Shapes.kt
+++ b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Shapes.kt
@@ -1,11 +1,23 @@
 package app.k9mail.core.ui.compose.theme
 
+import androidx.compose.foundation.shape.CornerBasedShape
 import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.Shapes
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.ui.unit.dp
+import androidx.compose.material.Shapes as MaterialShapes
 
-val shapes = Shapes(
-    small = RoundedCornerShape(8.dp),
-    medium = RoundedCornerShape(4.dp),
-    large = RoundedCornerShape(0.dp),
+@Immutable
+data class Shapes(
+    val small: CornerBasedShape = RoundedCornerShape(8.dp),
+    val medium: CornerBasedShape = RoundedCornerShape(4.dp),
+    val large: CornerBasedShape = RoundedCornerShape(0.dp),
 )
+
+internal fun Shapes.toMaterialShapes() = MaterialShapes(
+    small = small,
+    medium = medium,
+    large = large,
+)
+
+internal val LocalShapes = staticCompositionLocalOf { Shapes() }
diff --git a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Sizes.kt b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Sizes.kt
index 8053c6f00ee92d6940d9fb0aacde06e106c8abf5..148270cf7b2871fe12f3ab6e81fab76c9a60b054 100644
--- a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Sizes.kt
+++ b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Sizes.kt
@@ -14,6 +14,11 @@ data class Sizes(
     val larger: Dp = 128.dp,
     val huge: Dp = 256.dp,
     val huger: Dp = 384.dp,
+
+    val icon: Dp = 24.dp,
+
+    val topBarHeight: Dp = 56.dp,
+    val bottomBarHeight: Dp = 56.dp,
 )
 
 internal val LocalSizes = staticCompositionLocalOf { Sizes() }
diff --git a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Spacings.kt b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Spacings.kt
index 5691998d36c3cda591cbac05c922ae7a5bca6f56..8db26b1b95b251cfd4f671327f5f0db152f6a70c 100644
--- a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Spacings.kt
+++ b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Spacings.kt
@@ -7,6 +7,8 @@ import androidx.compose.ui.unit.dp
 
 @Immutable
 data class Spacings(
+    val zero: Dp = 0.dp,
+
     val quarter: Dp = 2.dp,
     val half: Dp = 4.dp,
     val default: Dp = 8.dp,
diff --git a/fastlane/metadata/android/en-US/changelogs/36002.txt b/fastlane/metadata/android/en-US/changelogs/36002.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b38624fb1ede331b83c7936816d6dcc76a746cf2
--- /dev/null
+++ b/fastlane/metadata/android/en-US/changelogs/36002.txt
@@ -0,0 +1 @@
+- Change primary action in message view header from "reply all" to "reply"
diff --git a/fastlane/metadata/android/en-US/changelogs/37004.txt b/fastlane/metadata/android/en-US/changelogs/37004.txt
new file mode 100644
index 0000000000000000000000000000000000000000..60b807daea1661d361b40d2de3d8fc68f2d90948
--- /dev/null
+++ b/fastlane/metadata/android/en-US/changelogs/37004.txt
@@ -0,0 +1,4 @@
+- Changed primary action in message view header from "reply all" to "reply"
+- Fixed the app so it runs on devices that don't support home screen widgets
+- Fixed bug where "Cannot connect to crypto provider" was displayed when the problem wasn't the crypto provider
+- Updated translations
diff --git a/fastlane/metadata/android/en-US/changelogs/37005.txt b/fastlane/metadata/android/en-US/changelogs/37005.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a20be7dbc65f4330a5ec990230c34b8e312e0fcd
--- /dev/null
+++ b/fastlane/metadata/android/en-US/changelogs/37005.txt
@@ -0,0 +1,7 @@
+- Adding to contacts should now allow you again to add the email address to an existing contact
+- Fixed display issue with recipients in message view screen
+- Fixed appearance of "Sign in with Google" button
+- Fixed bugs with importing and exporting identities
+- Manually entering names containing non-latin characters is now possible when composing messages
+- The app will no longer ask to save a draft when no changes have been made to an existing draft message
+- Updated translations
diff --git a/fastlane/metadata/android/en-US/changelogs/37006.txt b/fastlane/metadata/android/en-US/changelogs/37006.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3ec017936ff8fc31bc890c4a4979968385edf2a7
--- /dev/null
+++ b/fastlane/metadata/android/en-US/changelogs/37006.txt
@@ -0,0 +1,2 @@
+- Fixed a bug that lead to folders appearing to be empty
+- Don't use nickname as display name when auto-completing recipient using the nickname
diff --git a/fastlane/metadata/android/en-US/changelogs/37007.txt b/fastlane/metadata/android/en-US/changelogs/37007.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7c115cf14087e9d2f14547c6c05c8b582de4a5e9
--- /dev/null
+++ b/fastlane/metadata/android/en-US/changelogs/37007.txt
@@ -0,0 +1 @@
+- Fixed bug where navigating to a different screen after using the system back button/gesture could crash the app
diff --git a/fastlane/metadata/android/en-US/images/phoneScreenshots/1.png b/fastlane/metadata/android/en-US/images/phoneScreenshots/1.png
index 1fd78aba1fad850f12513dc8a0d2d46ecaa846cb..6ff66dd4d2f5781d28941bb94b0d44e5236ca650 100644
Binary files a/fastlane/metadata/android/en-US/images/phoneScreenshots/1.png and b/fastlane/metadata/android/en-US/images/phoneScreenshots/1.png differ
diff --git a/fastlane/metadata/android/en-US/images/phoneScreenshots/2.png b/fastlane/metadata/android/en-US/images/phoneScreenshots/2.png
index 0c2dbfb6374768f945e2f99768c5c40175350b64..9e13396bdd982fe3565ce70f7dfd0a364ba45265 100644
Binary files a/fastlane/metadata/android/en-US/images/phoneScreenshots/2.png and b/fastlane/metadata/android/en-US/images/phoneScreenshots/2.png differ
diff --git a/fastlane/metadata/android/en-US/images/phoneScreenshots/3.png b/fastlane/metadata/android/en-US/images/phoneScreenshots/3.png
index 2a04a9f21800ad20883dae05d770793fd6050999..0feca6c286fd968db461dce07e4ab622612691b6 100644
Binary files a/fastlane/metadata/android/en-US/images/phoneScreenshots/3.png and b/fastlane/metadata/android/en-US/images/phoneScreenshots/3.png differ
diff --git a/fastlane/metadata/android/en-US/images/phoneScreenshots/4.png b/fastlane/metadata/android/en-US/images/phoneScreenshots/4.png
index d9388175cb5cb3729c202e786ecbc1bf4fb11db7..c4088f9c38504422a2c7dce33e44ad1eabda1975 100644
Binary files a/fastlane/metadata/android/en-US/images/phoneScreenshots/4.png and b/fastlane/metadata/android/en-US/images/phoneScreenshots/4.png differ
diff --git a/fastlane/metadata/android/en-US/images/phoneScreenshots/5.png b/fastlane/metadata/android/en-US/images/phoneScreenshots/5.png
index b10056b5144414c310044f1c5dd9502076278863..233190fbeae977c15adbf60e66ca65dd7b263510 100644
Binary files a/fastlane/metadata/android/en-US/images/phoneScreenshots/5.png and b/fastlane/metadata/android/en-US/images/phoneScreenshots/5.png differ
diff --git a/fastlane/metadata/android/en-US/images/sevenInchScreenshots/1.png b/fastlane/metadata/android/en-US/images/sevenInchScreenshots/1.png
index 05aa907f8c63b2d13528330b9ab23325bd62163f..631c557418a013acc1f529f13a02c0a4ce80a991 100644
Binary files a/fastlane/metadata/android/en-US/images/sevenInchScreenshots/1.png and b/fastlane/metadata/android/en-US/images/sevenInchScreenshots/1.png differ
diff --git a/fastlane/metadata/android/en-US/images/tenInchScreenshots/1.png b/fastlane/metadata/android/en-US/images/tenInchScreenshots/1.png
index f0ddcb7b601a0616af7684ef2140ccd08b520e4f..ad32cab3f3a68de1700ef516f5e4a376615e12a8 100644
Binary files a/fastlane/metadata/android/en-US/images/tenInchScreenshots/1.png and b/fastlane/metadata/android/en-US/images/tenInchScreenshots/1.png differ
diff --git a/feature/account/setup/build.gradle.kts b/feature/account/setup/build.gradle.kts
index a0758baa90d4b67c4ab973d41ed75b4414eceef0..e946434e51f1365820ee23351cd4e04465b16f9e 100644
--- a/feature/account/setup/build.gradle.kts
+++ b/feature/account/setup/build.gradle.kts
@@ -9,4 +9,9 @@ android {
 
 dependencies {
     implementation(projects.core.ui.compose.designsystem)
+    implementation(projects.core.common)
+
+    implementation(projects.feature.autodiscovery.service)
+
+    testImplementation(projects.core.ui.compose.testing)
 }
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/AccountSetupModule.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/AccountSetupModule.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3081e8c71d048780724e91bfc22e63a694633d77
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/AccountSetupModule.kt
@@ -0,0 +1,64 @@
+package app.k9mail.feature.account.setup
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryService
+import app.k9mail.autodiscovery.service.RealAutoDiscoveryService
+import app.k9mail.feature.account.setup.domain.DomainContract
+import app.k9mail.feature.account.setup.domain.usecase.GetAutoDiscovery
+import app.k9mail.feature.account.setup.ui.AccountSetupViewModel
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryValidator
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryViewModel
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigValidator
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigViewModel
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsValidator
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsViewModel
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigValidator
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigViewModel
+import org.koin.androidx.viewmodel.dsl.viewModel
+import org.koin.core.module.Module
+import org.koin.dsl.module
+
+val featureAccountSetupModule: Module = module {
+    single<AutoDiscoveryService> {
+        RealAutoDiscoveryService(
+            okHttpClient = get(),
+        )
+    }
+
+    single<DomainContract.UseCase.GetAutoDiscovery> {
+        GetAutoDiscovery(
+            service = get(),
+        )
+    }
+
+    factory<AccountAutoDiscoveryContract.Validator> { AccountAutoDiscoveryValidator() }
+    factory<AccountIncomingConfigContract.Validator> { AccountIncomingConfigValidator() }
+    factory<AccountOutgoingConfigContract.Validator> { AccountOutgoingConfigValidator() }
+    factory<AccountOptionsContract.Validator> { AccountOptionsValidator() }
+
+    viewModel { AccountSetupViewModel() }
+    viewModel {
+        AccountAutoDiscoveryViewModel(
+            validator = get(),
+            getAutoDiscovery = get(),
+        )
+    }
+    viewModel {
+        AccountIncomingConfigViewModel(
+            validator = get(),
+        )
+    }
+    viewModel {
+        AccountOutgoingConfigViewModel(
+            validator = get(),
+        )
+    }
+    viewModel {
+        AccountOptionsViewModel(
+            validator = get(),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/DomainContract.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/DomainContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..46a949ae8df2a23d57206ef3e176c4f79c5800f0
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/DomainContract.kt
@@ -0,0 +1,53 @@
+package app.k9mail.feature.account.setup.domain
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+
+internal interface DomainContract {
+
+    interface UseCase {
+        fun interface GetAutoDiscovery {
+            suspend fun execute(emailAddress: String): AutoDiscoveryResult
+        }
+
+        fun interface ValidateEmailAddress {
+            fun execute(emailAddress: String): ValidationResult
+        }
+
+        fun interface ValidatePassword {
+            fun execute(password: String): ValidationResult
+        }
+
+        fun interface ValidateConfigurationApproval {
+            fun execute(isApproved: Boolean?, isAutoDiscoveryTrusted: Boolean?): ValidationResult
+        }
+
+        fun interface ValidateServer {
+            fun execute(server: String): ValidationResult
+        }
+
+        fun interface ValidatePort {
+            fun execute(port: Long?): ValidationResult
+        }
+
+        fun interface ValidateUsername {
+            fun execute(username: String): ValidationResult
+        }
+
+        fun interface ValidateImapPrefix {
+            fun execute(imapPrefix: String): ValidationResult
+        }
+
+        fun interface ValidateAccountName {
+            fun execute(accountName: String): ValidationResult
+        }
+
+        fun interface ValidateDisplayName {
+            fun execute(displayName: String): ValidationResult
+        }
+
+        fun interface ValidateEmailSignature {
+            fun execute(emailSignature: String): ValidationResult
+        }
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AuthenticationType.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AuthenticationType.kt
new file mode 100644
index 0000000000000000000000000000000000000000..bd7ec2a0b5635fd4e219a96431d4c7defbcffa1d
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AuthenticationType.kt
@@ -0,0 +1,15 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import kotlinx.collections.immutable.toImmutableList
+
+internal enum class AuthenticationType {
+    PasswordCleartext,
+    PasswordEncrypted,
+    OAuth2,
+    ;
+
+    companion object {
+        val DEFAULT = PasswordCleartext
+        fun all() = values().toList().toImmutableList()
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoveryConnectionSecurity.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoveryConnectionSecurity.kt
new file mode 100644
index 0000000000000000000000000000000000000000..56eac260346977914ceadd507e47131f380bbe14
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoveryConnectionSecurity.kt
@@ -0,0 +1,3 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+internal typealias AutoDiscoveryConnectionSecurity = app.k9mail.autodiscovery.api.ConnectionSecurity
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/ConnectionSecurity.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/ConnectionSecurity.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f8eb6116e3b88c5c534cffcef7a559afdc3cf1f7
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/ConnectionSecurity.kt
@@ -0,0 +1,45 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity.None
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity.StartTLS
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity.TLS
+import kotlinx.collections.immutable.toImmutableList
+
+enum class ConnectionSecurity {
+    None,
+    StartTLS,
+    TLS,
+    ;
+
+    companion object {
+        val DEFAULT = TLS
+        fun all() = values().toList().toImmutableList()
+    }
+}
+
+@Suppress("MagicNumber")
+internal fun ConnectionSecurity.toSmtpDefaultPort(): Long {
+    return when (this) {
+        None -> 587
+        StartTLS -> 587
+        TLS -> 465
+    }
+}
+
+@Suppress("MagicNumber")
+internal fun ConnectionSecurity.toImapDefaultPort(): Long {
+    return when (this) {
+        None -> 143
+        StartTLS -> 143
+        TLS -> 993
+    }
+}
+
+@Suppress("MagicNumber")
+internal fun ConnectionSecurity.toPop3DefaultPort(): Long {
+    return when (this) {
+        None -> 110
+        StartTLS -> 110
+        TLS -> 995
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/EmailCheckFrequency.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/EmailCheckFrequency.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a90a09730b453c3457b2b00ba6455608025fa736
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/EmailCheckFrequency.kt
@@ -0,0 +1,29 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import kotlinx.collections.immutable.toImmutableList
+
+@Suppress("MagicNumber")
+enum class EmailCheckFrequency(
+    val minutes: Int,
+) {
+    MANUAL(-1),
+    EVERY_15_MINUTES(15),
+    EVERY_30_MINUTES(30),
+    EVERY_HOUR(1.fromHour()),
+    EVERY_2_HOURS(2.fromHour()),
+    EVERY_3_HOURS(3.fromHour()),
+    EVERY_6_HOURS(6.fromHour()),
+    EVERY_12_HOURS(12.fromHour()),
+    EVERY_24_HOURS(24.fromHour()),
+    ;
+
+    companion object {
+        val DEFAULT = EVERY_HOUR
+        fun all() = values().toList().toImmutableList()
+    }
+}
+
+@Suppress("MagicNumber")
+private fun Int.fromHour(): Int {
+    return 60 * this
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/EmailDisplayCount.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/EmailDisplayCount.kt
new file mode 100644
index 0000000000000000000000000000000000000000..6a683080018b9cb07015a609ff8b5b2dd196038b
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/EmailDisplayCount.kt
@@ -0,0 +1,22 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import kotlinx.collections.immutable.toImmutableList
+
+@Suppress("MagicNumber")
+enum class EmailDisplayCount(
+    val count: Int,
+) {
+    MESSAGES_10(10),
+    MESSAGES_25(25),
+    MESSAGES_50(50),
+    MESSAGES_100(100),
+    MESSAGES_250(250),
+    MESSAGES_500(500),
+    MESSAGES_1000(1000),
+    ;
+
+    companion object {
+        val DEFAULT = MESSAGES_25
+        fun all() = values().toList().toImmutableList()
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingProtocolType.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingProtocolType.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fcd486cd2a5d410ea01682a57ac9bc0a2e11788f
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingProtocolType.kt
@@ -0,0 +1,25 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import kotlinx.collections.immutable.toImmutableList
+
+enum class IncomingProtocolType(
+    val defaultName: String,
+    val defaultConnectionSecurity: ConnectionSecurity,
+) {
+    IMAP("imap", ConnectionSecurity.TLS),
+    POP3("pop3", ConnectionSecurity.TLS),
+    ;
+
+    companion object {
+        val DEFAULT = IMAP
+
+        fun all() = values().toList().toImmutableList()
+    }
+}
+
+internal fun IncomingProtocolType.toDefaultPort(connectionSecurity: ConnectionSecurity): Long {
+    return when (this) {
+        IncomingProtocolType.IMAP -> connectionSecurity.toImapDefaultPort()
+        IncomingProtocolType.POP3 -> connectionSecurity.toPop3DefaultPort()
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/OutgoingProtocolType.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/OutgoingProtocolType.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c90cde0aba168b12a6c62e94e0ea0c2839b5f46c
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/OutgoingProtocolType.kt
@@ -0,0 +1,23 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import kotlinx.collections.immutable.toImmutableList
+
+internal enum class OutgoingProtocolType(
+    val defaultName: String,
+    val defaultConnectionSecurity: ConnectionSecurity,
+) {
+    SMTP("smtp", ConnectionSecurity.TLS),
+    ;
+
+    companion object {
+        val DEFAULT = SMTP
+
+        fun all() = values().toList().toImmutableList()
+    }
+}
+
+internal fun OutgoingProtocolType.toDefaultPort(connectionSecurity: ConnectionSecurity): Long {
+    return when (this) {
+        OutgoingProtocolType.SMTP -> connectionSecurity.toSmtpDefaultPort()
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/BooleanInputField.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/BooleanInputField.kt
new file mode 100644
index 0000000000000000000000000000000000000000..561e56257228ef10fe01b8c1577e7dc2faac476a
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/BooleanInputField.kt
@@ -0,0 +1,74 @@
+package app.k9mail.feature.account.setup.domain.input
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+
+class BooleanInputField(
+    override val value: Boolean? = null,
+    override val error: ValidationError? = null,
+    override val isValid: Boolean = false,
+) : InputField<Boolean?> {
+    override fun updateValue(value: Boolean?): BooleanInputField {
+        return BooleanInputField(
+            value = value,
+            error = null,
+            isValid = false,
+        )
+    }
+
+    override fun updateError(error: ValidationError?): BooleanInputField {
+        return BooleanInputField(
+            value = value,
+            error = error,
+            isValid = false,
+        )
+    }
+
+    override fun updateValidity(isValid: Boolean): BooleanInputField {
+        if (isValid == this.isValid) return this
+
+        return BooleanInputField(
+            value = value,
+            error = null,
+            isValid = isValid,
+        )
+    }
+
+    override fun updateFromValidationResult(result: ValidationResult): BooleanInputField {
+        return when (result) {
+            is ValidationResult.Success -> BooleanInputField(
+                value = value,
+                error = null,
+                isValid = true,
+            )
+
+            is ValidationResult.Failure -> BooleanInputField(
+                value = value,
+                error = result.error,
+                isValid = false,
+            )
+        }
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as BooleanInputField
+
+        if (value != other.value) return false
+        if (error != other.error) return false
+        return isValid == other.isValid
+    }
+
+    override fun hashCode(): Int {
+        var result = value?.hashCode() ?: 0
+        result = 31 * result + (error?.hashCode() ?: 0)
+        result = 31 * result + isValid.hashCode()
+        return result
+    }
+
+    override fun toString(): String {
+        return "BooleanInputField(value=$value, error=$error, isValid=$isValid)"
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/InputField.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/InputField.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9aa75019fd3709e4857becc22147511cd015b5d8
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/InputField.kt
@@ -0,0 +1,48 @@
+package app.k9mail.feature.account.setup.domain.input
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+
+/**
+ * InputField is an interface defining the state of an input field.
+ *
+ * @param T The type of the value the input field holds.
+ */
+interface InputField<T> {
+    val value: T
+    val error: ValidationError?
+    val isValid: Boolean
+
+    /**
+     * Updates the current value of the input field.
+     *
+     * @param value The new value to be set for the input field.
+     * @return a new InputField instance with the updated value.
+     */
+    fun updateValue(value: T): InputField<T>
+
+    /**
+     * Updates the current error of the input field.
+     *
+     * @param error The new error to be set for the input field.
+     */
+    fun updateError(error: ValidationError?): InputField<T>
+
+    /**
+     * Updates the current validity of the input field.
+     *
+     * @param isValid The new validity to be set for the input field.
+     */
+    fun updateValidity(isValid: Boolean): InputField<T>
+
+    /**
+     * Checks if the input field currently has an error.
+     *
+     * @return a Boolean indicating whether the input field has an error.
+     */
+    fun hasError(): Boolean {
+        return error != null
+    }
+
+    fun updateFromValidationResult(result: ValidationResult): InputField<T>
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/NumberInputField.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/NumberInputField.kt
new file mode 100644
index 0000000000000000000000000000000000000000..34b8a825133119f27756b206564214c99fff99e5
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/NumberInputField.kt
@@ -0,0 +1,75 @@
+package app.k9mail.feature.account.setup.domain.input
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+
+class NumberInputField(
+    override val value: Long? = null,
+    override val error: ValidationError? = null,
+    override val isValid: Boolean = false,
+) : InputField<Long?> {
+
+    override fun updateValue(value: Long?): NumberInputField {
+        return NumberInputField(
+            value = value,
+            error = null,
+            isValid = false,
+        )
+    }
+
+    override fun updateError(error: ValidationError?): NumberInputField {
+        return NumberInputField(
+            value = value,
+            error = error,
+            isValid = false,
+        )
+    }
+
+    override fun updateValidity(isValid: Boolean): NumberInputField {
+        if (isValid == this.isValid) return this
+
+        return NumberInputField(
+            value = value,
+            error = null,
+            isValid = isValid,
+        )
+    }
+
+    override fun updateFromValidationResult(result: ValidationResult): NumberInputField {
+        return when (result) {
+            is ValidationResult.Success -> NumberInputField(
+                value = value,
+                error = null,
+                isValid = true,
+            )
+
+            is ValidationResult.Failure -> NumberInputField(
+                value = value,
+                error = result.error,
+                isValid = false,
+            )
+        }
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as NumberInputField
+
+        if (value != other.value) return false
+        if (error != other.error) return false
+        return isValid == other.isValid
+    }
+
+    override fun hashCode(): Int {
+        var result = value?.hashCode() ?: 0
+        result = 31 * result + (error?.hashCode() ?: 0)
+        result = 31 * result + isValid.hashCode()
+        return result
+    }
+
+    override fun toString(): String {
+        return "NumberInputField(value=$value, error=$error, isValid=$isValid)"
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/StringInputField.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/StringInputField.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a793eb5320f4b7c348b5425880fe07fd0908e79e
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/StringInputField.kt
@@ -0,0 +1,75 @@
+package app.k9mail.feature.account.setup.domain.input
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+
+class StringInputField(
+    override val value: String = "",
+    override val error: ValidationError? = null,
+    override val isValid: Boolean = false,
+) : InputField<String> {
+
+    override fun updateValue(value: String): StringInputField {
+        return StringInputField(
+            value = value,
+            error = null,
+            isValid = false,
+        )
+    }
+
+    override fun updateError(error: ValidationError?): StringInputField {
+        return StringInputField(
+            value = value,
+            error = error,
+            isValid = false,
+        )
+    }
+
+    override fun updateValidity(isValid: Boolean): StringInputField {
+        if (isValid == this.isValid) return this
+
+        return StringInputField(
+            value = value,
+            error = null,
+            isValid = isValid,
+        )
+    }
+
+    override fun updateFromValidationResult(result: ValidationResult): StringInputField {
+        return when (result) {
+            is ValidationResult.Success -> StringInputField(
+                value = value,
+                error = null,
+                isValid = true,
+            )
+
+            is ValidationResult.Failure -> StringInputField(
+                value = value,
+                error = result.error,
+                isValid = false,
+            )
+        }
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as StringInputField
+
+        if (value != other.value) return false
+        if (error != other.error) return false
+        return isValid == other.isValid
+    }
+
+    override fun hashCode(): Int {
+        var result = value.hashCode()
+        result = 31 * result + (error?.hashCode() ?: 0)
+        result = 31 * result + isValid.hashCode()
+        return result
+    }
+
+    override fun toString(): String {
+        return "StringInputField(value='$value', error=$error, isValid=$isValid)"
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/GetAutoDiscovery.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/GetAutoDiscovery.kt
new file mode 100644
index 0000000000000000000000000000000000000000..88717707d10407a644e264bae0d435120df05f3e
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/GetAutoDiscovery.kt
@@ -0,0 +1,80 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.autodiscovery.api.AuthenticationType
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.AutoDiscoveryService
+import app.k9mail.autodiscovery.api.ConnectionSecurity
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.mail.toUserEmailAddress
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+import app.k9mail.feature.account.setup.domain.DomainContract
+import java.io.IOException
+import kotlin.random.Random
+import kotlinx.coroutines.delay
+
+internal class GetAutoDiscovery(
+    private val service: AutoDiscoveryService,
+) : DomainContract.UseCase.GetAutoDiscovery {
+    override suspend fun execute(emailAddress: String): AutoDiscoveryResult {
+        val fakeResult: AutoDiscoveryResult? = if (emailAddress.contains("empty")) {
+            AutoDiscoveryResult.NoUsableSettingsFound
+        } else if (emailAddress.contains("test")) {
+            getFakeAutoDiscovery(emailAddress)
+        } else if (emailAddress.contains("error")) {
+            AutoDiscoveryResult.NetworkError(IOException("Failed to load config"))
+        } else if (emailAddress.contains("unexpected")) {
+            AutoDiscoveryResult.UnexpectedException(Exception("Unexpected exception"))
+        } else {
+            null
+        }
+
+        if (fakeResult != null) {
+            return provideWithDelay(fakeResult)
+        }
+
+        return service.discover(emailAddress.toUserEmailAddress())!!
+    }
+
+    @Suppress("MagicNumber")
+    private suspend fun provideWithDelay(autoDiscoveryResult: AutoDiscoveryResult): AutoDiscoveryResult {
+        delay(Random(0).nextLong(500, 2000))
+        return autoDiscoveryResult
+    }
+
+    @Suppress("MagicNumber")
+    private fun getFakeAutoDiscovery(emailAddress: String): AutoDiscoveryResult.Settings {
+        val hasIncomingOauth = emailAddress.contains("in")
+        val hasOutgoingOauth = emailAddress.contains("out")
+        val isTrusted = emailAddress.contains("trust")
+
+        return AutoDiscoveryResult.Settings(
+            incomingServerSettings = ImapServerSettings(
+                hostname = "imap.${getHost(emailAddress)}".toHostname(),
+                port = 993.toPort(),
+                connectionSecurity = ConnectionSecurity.TLS,
+                authenticationType = if (hasIncomingOauth) {
+                    AuthenticationType.OAuth2
+                } else {
+                    AuthenticationType.PasswordEncrypted
+                },
+                username = "username",
+            ),
+            outgoingServerSettings = SmtpServerSettings(
+                hostname = "smtp.${getHost(emailAddress)}".toHostname(),
+                port = 993.toPort(),
+                connectionSecurity = ConnectionSecurity.TLS,
+                authenticationType = if (hasOutgoingOauth) {
+                    AuthenticationType.OAuth2
+                } else {
+                    AuthenticationType.PasswordEncrypted
+                },
+                username = "username",
+            ),
+            isTrusted = isTrusted,
+        )
+    }
+
+    private fun getHost(emailAddress: String) = emailAddress.split("@").last()
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateAccountName.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateAccountName.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9366b5aadd62f9a5dbba9ac98c3b592cab2fb6c0
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateAccountName.kt
@@ -0,0 +1,19 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class ValidateAccountName : DomainContract.UseCase.ValidateAccountName {
+    override fun execute(accountName: String): ValidationResult {
+        return when {
+            accountName.isEmpty() -> ValidationResult.Success
+            accountName.isBlank() -> ValidationResult.Failure(ValidateAccountNameError.BlankAccountName)
+            else -> ValidationResult.Success
+        }
+    }
+
+    sealed interface ValidateAccountNameError : ValidationError {
+        object BlankAccountName : ValidateAccountNameError
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateConfigurationApproval.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateConfigurationApproval.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3184af8abaacaf3052c548c730b2e7a7c0058649
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateConfigurationApproval.kt
@@ -0,0 +1,23 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract.UseCase
+
+class ValidateConfigurationApproval : UseCase.ValidateConfigurationApproval {
+    override fun execute(isApproved: Boolean?, isAutoDiscoveryTrusted: Boolean?): ValidationResult {
+        return if (isApproved == null && isAutoDiscoveryTrusted == null) {
+            ValidationResult.Success
+        } else if (isAutoDiscoveryTrusted == true) {
+            ValidationResult.Success
+        } else if (isApproved == true) {
+            ValidationResult.Success
+        } else {
+            ValidationResult.Failure(ValidateConfigurationApprovalError.ApprovalRequired)
+        }
+    }
+
+    sealed interface ValidateConfigurationApprovalError : ValidationError {
+        object ApprovalRequired : ValidateConfigurationApprovalError
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateDisplayName.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateDisplayName.kt
new file mode 100644
index 0000000000000000000000000000000000000000..dd57455253ce6a7f431c33b850e4a1863150d33a
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateDisplayName.kt
@@ -0,0 +1,19 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class ValidateDisplayName : DomainContract.UseCase.ValidateDisplayName {
+
+    override fun execute(displayName: String): ValidationResult {
+        return when {
+            displayName.isBlank() -> ValidationResult.Failure(ValidateDisplayNameError.EmptyDisplayName)
+            else -> ValidationResult.Success
+        }
+    }
+
+    sealed interface ValidateDisplayNameError : ValidationError {
+        object EmptyDisplayName : ValidateDisplayNameError
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailAddress.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailAddress.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b53451a62126892f1f698c976273b5f439e631d6
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailAddress.kt
@@ -0,0 +1,31 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class ValidateEmailAddress : DomainContract.UseCase.ValidateEmailAddress {
+
+    // TODO replace by new email validation
+    override fun execute(emailAddress: String): ValidationResult {
+        return when {
+            emailAddress.isBlank() -> ValidationResult.Failure(ValidateEmailAddressError.EmptyEmailAddress)
+
+            !EMAIL_ADDRESS.matches(emailAddress) -> ValidationResult.Failure(
+                ValidateEmailAddressError.InvalidEmailAddress,
+            )
+
+            else -> ValidationResult.Success
+        }
+    }
+
+    sealed interface ValidateEmailAddressError : ValidationError {
+        object EmptyEmailAddress : ValidateEmailAddressError
+        object InvalidEmailAddress : ValidateEmailAddressError
+    }
+
+    private companion object {
+        val EMAIL_ADDRESS =
+            "[a-zA-Z0-9+._%\\-]{1,256}@[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}(\\.[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25})+".toRegex()
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailSignature.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailSignature.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fd52d8c54ce45d56f39849955531f5708b78b68d
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailSignature.kt
@@ -0,0 +1,22 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+import app.k9mail.feature.account.setup.domain.usecase.ValidateEmailSignature.ValidateEmailSignatureError.BlankEmailSignature
+
+// TODO check signature for input validity
+internal class ValidateEmailSignature : DomainContract.UseCase.ValidateEmailSignature {
+
+    override fun execute(emailSignature: String): ValidationResult {
+        return when {
+            emailSignature.isEmpty() -> ValidationResult.Success
+            emailSignature.isBlank() -> ValidationResult.Failure(error = BlankEmailSignature)
+            else -> ValidationResult.Success
+        }
+    }
+
+    sealed interface ValidateEmailSignatureError : ValidationError {
+        object BlankEmailSignature : ValidateEmailSignatureError
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateImapPrefix.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateImapPrefix.kt
new file mode 100644
index 0000000000000000000000000000000000000000..486d0725833dced58b35b7fd13e610fa358c8c87
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateImapPrefix.kt
@@ -0,0 +1,21 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class ValidateImapPrefix : DomainContract.UseCase.ValidateImapPrefix {
+
+    override fun execute(imapPrefix: String): ValidationResult {
+        return when {
+            imapPrefix.isEmpty() -> ValidationResult.Success
+            imapPrefix.isBlank() -> ValidationResult.Failure(ValidateImapPrefixError.BlankImapPrefix)
+
+            else -> ValidationResult.Success
+        }
+    }
+
+    sealed interface ValidateImapPrefixError : ValidationError {
+        object BlankImapPrefix : ValidateImapPrefixError
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePassword.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePassword.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f7c25483226e98ce55c7c0c164960a63187a0d46
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePassword.kt
@@ -0,0 +1,21 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class ValidatePassword : DomainContract.UseCase.ValidatePassword {
+
+    // TODO change behavior to allow empty password when no password is required based on auth type
+    override fun execute(password: String): ValidationResult {
+        return when {
+            password.isBlank() -> ValidationResult.Failure(ValidatePasswordError.EmptyPassword)
+
+            else -> ValidationResult.Success
+        }
+    }
+
+    sealed interface ValidatePasswordError : ValidationError {
+        object EmptyPassword : ValidatePasswordError
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePort.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePort.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f0e31b67b8b5ac070ad4b2b4a8e1e4709bc83b36
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePort.kt
@@ -0,0 +1,26 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class ValidatePort : DomainContract.UseCase.ValidatePort {
+
+    override fun execute(port: Long?): ValidationResult {
+        return when (port) {
+            null -> ValidationResult.Failure(ValidatePortError.EmptyPort)
+            in MIN_PORT_NUMBER..MAX_PORT_NUMBER -> ValidationResult.Success
+            else -> ValidationResult.Failure(ValidatePortError.InvalidPort)
+        }
+    }
+
+    sealed interface ValidatePortError : ValidationError {
+        object EmptyPort : ValidatePortError
+        object InvalidPort : ValidatePortError
+    }
+
+    companion object {
+        const val MAX_PORT_NUMBER = 65535
+        const val MIN_PORT_NUMBER = 1
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServer.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServer.kt
new file mode 100644
index 0000000000000000000000000000000000000000..31fcfb63df72a1faa0c100e59d4455ad1cce0f49
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServer.kt
@@ -0,0 +1,20 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class ValidateServer : DomainContract.UseCase.ValidateServer {
+
+    // TODO validate domain, ip4 or ip6
+    override fun execute(server: String): ValidationResult {
+        return when {
+            server.isBlank() -> ValidationResult.Failure(ValidateServerError.EmptyServer)
+            else -> ValidationResult.Success
+        }
+    }
+
+    sealed interface ValidateServerError : ValidationError {
+        object EmptyServer : ValidateServerError
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateUsername.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateUsername.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7399330bb76613eec4a06a38a676f91e0c686afd
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateUsername.kt
@@ -0,0 +1,20 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class ValidateUsername : DomainContract.UseCase.ValidateUsername {
+
+    override fun execute(username: String): ValidationResult {
+        return when {
+            username.isBlank() -> ValidationResult.Failure(ValidateUsernameError.EmptyUsername)
+
+            else -> ValidationResult.Success
+        }
+    }
+
+    sealed interface ValidateUsernameError : ValidationError {
+        object EmptyUsername : ValidateUsernameError
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/navigation/AccountSetupNavigation.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/navigation/AccountSetupNavigation.kt
index 2a9ddfafb9f544077e465ec6ee0b754d8f9ad0fb..6bd25fda0b8f9e3c4fe97277d1b5115adbc6493f 100644
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/navigation/AccountSetupNavigation.kt
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/navigation/AccountSetupNavigation.kt
@@ -12,14 +12,14 @@ fun NavController.navigateToAccountSetup(navOptions: NavOptions? = null) {
     navigate(NAVIGATION_ROUTE_ACCOUNT_SETUP, navOptions)
 }
 
-fun NavGraphBuilder.accountSetupScreen(
-    onBackClick: () -> Unit,
-    onFinishClick: () -> Unit,
+fun NavGraphBuilder.accountSetupRoute(
+    onBack: () -> Unit,
+    onFinish: () -> Unit,
 ) {
     composable(route = NAVIGATION_ROUTE_ACCOUNT_SETUP) {
         AccountSetupScreen(
-            onBackClick = onBackClick,
-            onFinishClick = onFinishClick,
+            onBack = onBack,
+            onFinish = onFinish,
         )
     }
 }
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupContract.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9043235db3326edb9dd1ce70104d60e3d75b79b7
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupContract.kt
@@ -0,0 +1,29 @@
+package app.k9mail.feature.account.setup.ui
+
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+
+interface AccountSetupContract {
+
+    enum class SetupStep {
+        AUTO_CONFIG,
+        INCOMING_CONFIG,
+        OUTGOING_CONFIG,
+        OPTIONS,
+    }
+
+    interface ViewModel : UnidirectionalViewModel<State, Event, Effect>
+
+    data class State(
+        val setupStep: SetupStep = SetupStep.AUTO_CONFIG,
+    )
+
+    sealed interface Event {
+        object OnNext : Event
+        object OnBack : Event
+    }
+
+    sealed interface Effect {
+        object NavigateNext : Effect
+        object NavigateBack : Effect
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupScreen.kt
index 3dcd99b09ff4d041cc5a8b457a479ddfc2090dfa..6d3c004572847f376f1a9b8a84e4d54550016bad 100644
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupScreen.kt
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupScreen.kt
@@ -1,65 +1,83 @@
 package app.k9mail.feature.account.setup.ui
 
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
 import androidx.compose.ui.tooling.preview.Preview
-import app.k9mail.feature.account.setup.ui.autoconfig.AccountAutoConfigScreen
-import app.k9mail.feature.account.setup.ui.manualconfig.AccountManualConfigScreen
+import app.k9mail.core.ui.compose.common.mvi.observe
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Effect
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Event
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.SetupStep
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.ViewModel
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryScreen
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryViewModel
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigScreen
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigViewModel
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract
 import app.k9mail.feature.account.setup.ui.options.AccountOptionsScreen
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsViewModel
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigScreen
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigViewModel
+import org.koin.androidx.compose.koinViewModel
 
 @Composable
 fun AccountSetupScreen(
-    onFinishClick: () -> Unit,
-    onBackClick: () -> Unit,
+    onFinish: () -> Unit,
+    onBack: () -> Unit,
+    viewModel: ViewModel = koinViewModel<AccountSetupViewModel>(),
+    autoDiscoveryViewModel: AccountAutoDiscoveryContract.ViewModel = koinViewModel<AccountAutoDiscoveryViewModel>(),
+    incomingViewModel: AccountIncomingConfigContract.ViewModel = koinViewModel<AccountIncomingConfigViewModel>(),
+    outgoingViewModel: AccountOutgoingConfigContract.ViewModel = koinViewModel<AccountOutgoingConfigViewModel>(),
+    optionsViewModel: AccountOptionsContract.ViewModel = koinViewModel<AccountOptionsViewModel>(),
 ) {
-    val accountSetupSteps = remember { mutableStateOf(AccountSetupSteps.AUTO_CONFIG) }
+    val (state, dispatch) = viewModel.observe { effect ->
+        when (effect) {
+            Effect.NavigateBack -> onBack()
+            Effect.NavigateNext -> onFinish()
+        }
+    }
 
-    when (accountSetupSteps.value) {
-        AccountSetupSteps.AUTO_CONFIG -> {
-            AccountAutoConfigScreen(
-                onNextClick = {
-                    // TODO validate config
-                    accountSetupSteps.value = AccountSetupSteps.MANUAL_CONFIG
-                },
-                onBackClick = onBackClick,
+    when (state.value.setupStep) {
+        SetupStep.AUTO_CONFIG -> {
+            AccountAutoDiscoveryScreen(
+                onNext = { dispatch(Event.OnNext) },
+                onBack = { dispatch(Event.OnBack) },
+                viewModel = autoDiscoveryViewModel,
             )
         }
 
-        AccountSetupSteps.MANUAL_CONFIG -> {
-            AccountManualConfigScreen(
-                onNextClick = {
-                    accountSetupSteps.value = AccountSetupSteps.OPTIONS
-                },
-                onBackClick = {
-                    accountSetupSteps.value = AccountSetupSteps.AUTO_CONFIG
-                },
+        SetupStep.INCOMING_CONFIG -> {
+            AccountIncomingConfigScreen(
+                onNext = { dispatch(Event.OnNext) },
+                onBack = { dispatch(Event.OnBack) },
+                viewModel = incomingViewModel,
             )
         }
 
-        AccountSetupSteps.OPTIONS -> {
+        SetupStep.OUTGOING_CONFIG -> {
+            AccountOutgoingConfigScreen(
+                onNext = { dispatch(Event.OnNext) },
+                onBack = { dispatch(Event.OnBack) },
+                viewModel = outgoingViewModel,
+            )
+        }
+
+        SetupStep.OPTIONS -> {
             AccountOptionsScreen(
-                // validate account
-                onFinishClick = onFinishClick,
-                onBackClick = {
-                    accountSetupSteps.value = AccountSetupSteps.MANUAL_CONFIG
-                },
+                onNext = { dispatch(Event.OnNext) },
+                onBack = { dispatch(Event.OnBack) },
+                viewModel = optionsViewModel,
             )
         }
     }
 }
 
-enum class AccountSetupSteps {
-    AUTO_CONFIG,
-    MANUAL_CONFIG,
-    OPTIONS,
-}
-
 @Preview(showBackground = true)
 @Composable
 internal fun AccountSetupScreenPreview() {
     AccountSetupScreen(
-        onFinishClick = {},
-        onBackClick = {},
+        onFinish = {},
+        onBack = {},
     )
 }
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupViewModel.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupViewModel.kt
index 26cf5cd18b1fd245fcc0b07a56f95bbb8f8b2f89..7fa573d8d8e2cd993ab8edaf8765a9a3585dc9b6 100644
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupViewModel.kt
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupViewModel.kt
@@ -1,5 +1,54 @@
 package app.k9mail.feature.account.setup.ui
 
-import androidx.lifecycle.ViewModel
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Effect
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Event
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.SetupStep
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.State
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.ViewModel
 
-class AccountSetupViewModel : ViewModel()
+class AccountSetupViewModel(
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), ViewModel {
+
+    override fun event(event: Event) {
+        when (event) {
+            Event.OnBack -> onBack()
+            Event.OnNext -> onNext()
+        }
+    }
+
+    private fun onBack() {
+        when (state.value.setupStep) {
+            SetupStep.AUTO_CONFIG -> navigateBack()
+            SetupStep.INCOMING_CONFIG -> changeToSetupStep(SetupStep.AUTO_CONFIG)
+            SetupStep.OUTGOING_CONFIG -> changeToSetupStep(SetupStep.INCOMING_CONFIG)
+            SetupStep.OPTIONS -> changeToSetupStep(SetupStep.OUTGOING_CONFIG)
+        }
+    }
+
+    private fun onNext() {
+        when (state.value.setupStep) {
+            SetupStep.AUTO_CONFIG -> changeToSetupStep(SetupStep.INCOMING_CONFIG)
+            SetupStep.INCOMING_CONFIG -> changeToSetupStep(SetupStep.OUTGOING_CONFIG)
+            SetupStep.OUTGOING_CONFIG -> changeToSetupStep(SetupStep.OPTIONS)
+            SetupStep.OPTIONS -> navigateNext()
+        }
+    }
+
+    private fun changeToSetupStep(setupStep: SetupStep) {
+        updateState {
+            it.copy(
+                setupStep = setupStep,
+            )
+        }
+    }
+
+    private fun navigateNext() {
+        // TODO: validate account
+
+        emitEffect(Effect.NavigateNext)
+    }
+
+    private fun navigateBack() = emitEffect(Effect.NavigateBack)
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autoconfig/AccountAutoConfigContent.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autoconfig/AccountAutoConfigContent.kt
deleted file mode 100644
index 69c60bfc826e910a773760ebbf02fb343caa4877..0000000000000000000000000000000000000000
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autoconfig/AccountAutoConfigContent.kt
+++ /dev/null
@@ -1,141 +0,0 @@
-package app.k9mail.feature.account.setup.ui.autoconfig
-
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.requiredHeight
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import app.k9mail.core.ui.compose.common.DevicePreviews
-import app.k9mail.core.ui.compose.designsystem.atom.button.Button
-import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonOutlined
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline2
-import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlined
-import app.k9mail.core.ui.compose.designsystem.template.LazyColumnWithHeaderFooter
-import app.k9mail.core.ui.compose.designsystem.template.ResponsiveContentWithBackground
-import app.k9mail.core.ui.compose.theme.K9Theme
-import app.k9mail.core.ui.compose.theme.MainTheme
-import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
-import app.k9mail.feature.account.setup.R
-
-@Composable
-internal fun AccountAutoConfigContent(
-    onNextClick: () -> Unit,
-    onBackClick: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    ResponsiveContentWithBackground(
-        modifier = modifier,
-    ) {
-        LazyColumnWithHeaderFooter(
-            modifier = Modifier.fillMaxSize(),
-            header = {
-                AccountSetupHeader()
-            },
-            footer = {
-                AccountSetupFooter(
-                    onNextClick = onNextClick,
-                    onBackClick = onBackClick,
-                )
-            },
-            verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.double, Alignment.CenterVertically),
-        ) {
-            item { Spacer(modifier = Modifier.height(MainTheme.sizes.larger)) }
-            item {
-                AccountSetupEmailForm(
-                    modifier = Modifier.fillMaxWidth(),
-                )
-            }
-            item { Spacer(modifier = Modifier.height(MainTheme.sizes.larger)) }
-        }
-    }
-}
-
-@Composable
-private fun AccountSetupHeader(
-    modifier: Modifier = Modifier,
-) {
-    Column(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(
-                start = MainTheme.spacings.double,
-                end = MainTheme.spacings.double,
-                bottom = MainTheme.spacings.triple,
-            )
-            .requiredHeight(MainTheme.sizes.larger)
-            .then(modifier),
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.Bottom,
-    ) {
-        TextHeadline2(text = stringResource(id = R.string.account_setup_title))
-    }
-}
-
-@Composable
-private fun AccountSetupEmailForm(
-    modifier: Modifier = Modifier,
-) {
-    Column(
-        modifier = modifier,
-        horizontalAlignment = Alignment.CenterHorizontally,
-    ) {
-        TextFieldOutlined(
-            value = "",
-            onValueChange = { /*TODO*/ },
-            label = "Email address",
-        )
-    }
-}
-
-@Composable
-private fun AccountSetupFooter(
-    onNextClick: () -> Unit,
-    onBackClick: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(
-                start = MainTheme.spacings.quadruple,
-                top = MainTheme.spacings.triple,
-                end = MainTheme.spacings.quadruple,
-                bottom = MainTheme.spacings.double,
-            )
-            .then(modifier),
-        horizontalArrangement = Arrangement.SpaceBetween,
-    ) {
-        ButtonOutlined(
-            text = stringResource(id = R.string.account_setup_button_back),
-            onClick = onBackClick,
-        )
-        Button(
-            text = stringResource(id = R.string.account_setup_button_next),
-            onClick = onNextClick,
-        )
-    }
-}
-
-@Composable
-@DevicePreviews
-internal fun AccountAutoConfigContentK9Preview() {
-    K9Theme {
-        AccountAutoConfigContent({}, {})
-    }
-}
-
-@Composable
-@DevicePreviews
-internal fun AccountAutoConfigContentThunderbirdPreview() {
-    ThunderbirdTheme {
-        AccountAutoConfigContent({}, {})
-    }
-}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autoconfig/AccountAutoConfigScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autoconfig/AccountAutoConfigScreen.kt
deleted file mode 100644
index 75b20c9c25371bb413703e83123b1de3940b4dc4..0000000000000000000000000000000000000000
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autoconfig/AccountAutoConfigScreen.kt
+++ /dev/null
@@ -1,14 +0,0 @@
-package app.k9mail.feature.account.setup.ui.autoconfig
-
-import androidx.compose.runtime.Composable
-
-@Composable
-fun AccountAutoConfigScreen(
-    onNextClick: () -> Unit,
-    onBackClick: () -> Unit,
-) {
-    AccountAutoConfigContent(
-        onNextClick = onNextClick,
-        onBackClick = onBackClick,
-    )
-}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryContent.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..62ac6a72935b1794e2ec277f338926ede4966c68
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryContent.kt
@@ -0,0 +1,96 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveWidthContainer
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Event
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.State
+import app.k9mail.feature.account.setup.ui.autodiscovery.item.contentItems
+import app.k9mail.feature.account.setup.ui.common.item.ErrorItem
+import app.k9mail.feature.account.setup.ui.common.item.LoadingItem
+
+@Composable
+internal fun AccountAutoDiscoveryContent(
+    state: State,
+    onEvent: (Event) -> Unit,
+    contentPadding: PaddingValues,
+    modifier: Modifier = Modifier,
+) {
+    ResponsiveWidthContainer(
+        modifier = Modifier
+            .testTag("AccountAutoDiscoveryContent")
+            .padding(contentPadding)
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        val resources = LocalContext.current.resources
+
+        LazyColumn(
+            modifier = Modifier
+                .fillMaxSize()
+                .imePadding(),
+            verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.double, Alignment.CenterVertically),
+        ) {
+            if (state.isLoading) {
+                item(key = "loading") {
+                    LoadingItem(
+                        message = stringResource(id = R.string.account_setup_auto_config_loading_message),
+                    )
+                }
+            } else if (state.error != null) {
+                item(key = "error") {
+                    ErrorItem(
+                        title = stringResource(id = R.string.account_setup_auto_config_loading_error),
+                        message = state.error.toResourceString(resources),
+                        onRetry = { onEvent(Event.OnRetryClicked) },
+                    )
+                }
+            } else {
+                contentItems(
+                    state = state,
+                    onEvent = onEvent,
+                )
+            }
+        }
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountAutoDiscoveryContentK9Preview() {
+    K9Theme {
+        AccountAutoDiscoveryContent(
+            state = State(),
+            onEvent = {},
+            contentPadding = PaddingValues(),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountAutoDiscoveryContentThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountAutoDiscoveryContent(
+            state = State(),
+            onEvent = {},
+            contentPadding = PaddingValues(),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryContract.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..44f8ebada9f36bbda90ae91c3e92dd3bb73ed3d3
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryContract.kt
@@ -0,0 +1,57 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+import app.k9mail.feature.account.setup.domain.input.BooleanInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+
+interface AccountAutoDiscoveryContract {
+
+    enum class ConfigStep {
+        EMAIL_ADDRESS,
+        OAUTH,
+        PASSWORD,
+    }
+
+    interface ViewModel : UnidirectionalViewModel<State, Event, Effect> {
+        fun initState(state: State)
+    }
+
+    data class State(
+        val configStep: ConfigStep = ConfigStep.EMAIL_ADDRESS,
+        val emailAddress: StringInputField = StringInputField(),
+        val password: StringInputField = StringInputField(),
+        val autoDiscoverySettings: AutoDiscoveryResult.Settings? = null,
+        val configurationApproved: BooleanInputField = BooleanInputField(),
+        val error: Error? = null,
+        val isLoading: Boolean = false,
+    )
+
+    sealed class Event {
+        data class EmailAddressChanged(val emailAddress: String) : Event()
+        data class PasswordChanged(val password: String) : Event()
+        data class ConfigurationApprovalChanged(val confirmed: Boolean) : Event()
+
+        object OnNextClicked : Event()
+        object OnBackClicked : Event()
+        object OnRetryClicked : Event()
+        object OnEditConfigurationClicked : Event()
+    }
+
+    sealed class Effect {
+        object NavigateNext : Effect()
+        object NavigateBack : Effect()
+    }
+
+    interface Validator {
+        fun validateEmailAddress(emailAddress: String): ValidationResult
+        fun validatePassword(password: String): ValidationResult
+        fun validateConfigurationApproval(isApproved: Boolean?, isAutoDiscoveryTrusted: Boolean?): ValidationResult
+    }
+
+    sealed interface Error {
+        object NetworkError : Error
+        object UnknownError : Error
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..6e15f1082275094344a9806c27546512110f9876
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryScreen.kt
@@ -0,0 +1,83 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.common.mvi.observe
+import app.k9mail.core.ui.compose.designsystem.template.Scaffold
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Effect
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Event
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.ViewModel
+import app.k9mail.feature.account.setup.ui.common.AccountSetupBottomBar
+import app.k9mail.feature.account.setup.ui.common.AccountSetupTopHeader
+
+@Composable
+internal fun AccountAutoDiscoveryScreen(
+    onNext: () -> Unit,
+    onBack: () -> Unit,
+    viewModel: ViewModel,
+    modifier: Modifier = Modifier,
+) {
+    val (state, dispatch) = viewModel.observe { effect ->
+        when (effect) {
+            Effect.NavigateBack -> onBack()
+            Effect.NavigateNext -> onNext()
+        }
+    }
+
+    Scaffold(
+        topBar = {
+            AccountSetupTopHeader()
+        },
+        bottomBar = {
+            AccountSetupBottomBar(
+                nextButtonText = stringResource(id = R.string.account_setup_button_next),
+                backButtonText = stringResource(id = R.string.account_setup_button_back),
+                onNextClick = { dispatch(Event.OnNextClicked) },
+                onBackClick = { dispatch(Event.OnBackClicked) },
+            )
+        },
+        modifier = modifier,
+    ) { innerPadding ->
+        AccountAutoDiscoveryContent(
+            state = state.value,
+            onEvent = { dispatch(it) },
+            contentPadding = innerPadding,
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountAutoDiscoveryScreenK9Preview() {
+    K9Theme {
+        AccountAutoDiscoveryScreen(
+            onNext = {},
+            onBack = {},
+            viewModel = AccountAutoDiscoveryViewModel(
+                validator = AccountAutoDiscoveryValidator(),
+                getAutoDiscovery = { AutoDiscoveryResult.NoUsableSettingsFound },
+            ),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountAutoDiscoveryScreenThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountAutoDiscoveryScreen(
+            onNext = {},
+            onBack = {},
+            viewModel = AccountAutoDiscoveryViewModel(
+                validator = AccountAutoDiscoveryValidator(),
+                getAutoDiscovery = { AutoDiscoveryResult.NoUsableSettingsFound },
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryValidator.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2ae80059e509faa8599ce6b8fe667839493ba861
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryValidator.kt
@@ -0,0 +1,29 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract.UseCase
+import app.k9mail.feature.account.setup.domain.usecase.ValidateConfigurationApproval
+import app.k9mail.feature.account.setup.domain.usecase.ValidateEmailAddress
+import app.k9mail.feature.account.setup.domain.usecase.ValidatePassword
+
+internal class AccountAutoDiscoveryValidator(
+    private val emailAddressValidator: UseCase.ValidateEmailAddress = ValidateEmailAddress(),
+    private val passwordValidator: UseCase.ValidatePassword = ValidatePassword(),
+    private val configurationApprovalValidator: UseCase.ValidateConfigurationApproval = ValidateConfigurationApproval(),
+) : AccountAutoDiscoveryContract.Validator {
+
+    override fun validateEmailAddress(emailAddress: String): ValidationResult {
+        return emailAddressValidator.execute(emailAddress)
+    }
+
+    override fun validatePassword(password: String): ValidationResult {
+        return passwordValidator.execute(password)
+    }
+
+    override fun validateConfigurationApproval(
+        isApproved: Boolean?,
+        isAutoDiscoveryTrusted: Boolean?,
+    ): ValidationResult {
+        return configurationApprovalValidator.execute(isApproved, isAutoDiscoveryTrusted)
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryViewModel.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4dec1e2cf450d8bed400d629fb0921872a2b717b
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryViewModel.kt
@@ -0,0 +1,204 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import androidx.lifecycle.viewModelScope
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.domain.DomainContract.UseCase
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.ConfigStep
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Effect
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Error
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Event
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.State
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Validator
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.ViewModel
+import kotlinx.coroutines.launch
+
+@Suppress("TooManyFunctions")
+internal class AccountAutoDiscoveryViewModel(
+    initialState: State = State(),
+    private val validator: Validator,
+    private val getAutoDiscovery: UseCase.GetAutoDiscovery,
+) : BaseViewModel<State, Event, Effect>(initialState), ViewModel {
+
+    override fun initState(state: State) {
+        updateState {
+            state.copy()
+        }
+    }
+
+    override fun event(event: Event) {
+        when (event) {
+            is Event.EmailAddressChanged -> changeEmailAddress(event.emailAddress)
+            is Event.PasswordChanged -> changePassword(event.password)
+            is Event.ConfigurationApprovalChanged -> changeConfigurationApproval(event.confirmed)
+
+            Event.OnNextClicked -> onNext()
+            Event.OnBackClicked -> onBack()
+            Event.OnRetryClicked -> retry()
+            Event.OnEditConfigurationClicked -> navigateNext()
+        }
+    }
+
+    private fun changeEmailAddress(emailAddress: String) {
+        updateState {
+            State(
+                emailAddress = StringInputField(value = emailAddress),
+            )
+        }
+    }
+
+    private fun changePassword(password: String) {
+        updateState {
+            it.copy(
+                password = it.password.updateValue(password),
+            )
+        }
+    }
+
+    private fun changeConfigurationApproval(approved: Boolean) {
+        updateState {
+            it.copy(
+                configurationApproved = it.configurationApproved.updateValue(approved),
+            )
+        }
+    }
+
+    private fun onNext() {
+        when (state.value.configStep) {
+            ConfigStep.EMAIL_ADDRESS ->
+                if (state.value.error != null) {
+                    updateState {
+                        it.copy(
+                            error = null,
+                            configStep = ConfigStep.PASSWORD,
+                        )
+                    }
+                } else {
+                    submitEmail()
+                }
+
+            ConfigStep.PASSWORD -> submitPassword()
+            ConfigStep.OAUTH -> TODO()
+        }
+    }
+
+    private fun retry() {
+        updateState {
+            it.copy(error = null)
+        }
+        loadAutoDiscovery()
+    }
+
+    private fun submitEmail() {
+        with(state.value) {
+            val emailValidationResult = validator.validateEmailAddress(emailAddress.value)
+            val hasError = emailValidationResult is ValidationResult.Failure
+
+            updateState {
+                it.copy(
+                    emailAddress = it.emailAddress.updateFromValidationResult(emailValidationResult),
+                )
+            }
+
+            if (!hasError) {
+                loadAutoDiscovery()
+            }
+        }
+    }
+
+    private fun loadAutoDiscovery() {
+        viewModelScope.launch {
+            updateState {
+                it.copy(
+                    isLoading = true,
+                )
+            }
+
+            val result = getAutoDiscovery.execute(state.value.emailAddress.value)
+            when (result) {
+                AutoDiscoveryResult.NoUsableSettingsFound -> updateAutoDiscoverySettings(null)
+                is AutoDiscoveryResult.Settings -> updateAutoDiscoverySettings(result)
+                is AutoDiscoveryResult.NetworkError -> updateError(Error.NetworkError)
+                is AutoDiscoveryResult.UnexpectedException -> updateError(Error.UnknownError)
+            }
+        }
+    }
+
+    private fun updateAutoDiscoverySettings(settings: AutoDiscoveryResult.Settings?) {
+        updateState {
+            it.copy(
+                isLoading = false,
+                autoDiscoverySettings = settings,
+                configStep = ConfigStep.PASSWORD, // TODO use oauth if applicable
+            )
+        }
+    }
+
+    private fun updateError(error: Error) {
+        updateState {
+            it.copy(
+                isLoading = false,
+                error = error,
+            )
+        }
+    }
+
+    private fun submitPassword() {
+        with(state.value) {
+            val emailValidationResult = validator.validateEmailAddress(emailAddress.value)
+            val passwordValidationResult = validator.validatePassword(password.value)
+            val configurationApprovalValidationResult = validator.validateConfigurationApproval(
+                isApproved = configurationApproved.value,
+                isAutoDiscoveryTrusted = autoDiscoverySettings?.isTrusted,
+            )
+            val hasError = listOf(
+                emailValidationResult,
+                passwordValidationResult,
+                configurationApprovalValidationResult,
+            ).any { it is ValidationResult.Failure }
+
+            updateState {
+                it.copy(
+                    emailAddress = it.emailAddress.updateFromValidationResult(emailValidationResult),
+                    password = it.password.updateFromValidationResult(passwordValidationResult),
+                    configurationApproved = it.configurationApproved.updateFromValidationResult(
+                        configurationApprovalValidationResult,
+                    ),
+                )
+            }
+
+            if (!hasError) {
+                navigateNext()
+            }
+        }
+    }
+
+    private fun onBack() {
+        when (state.value.configStep) {
+            ConfigStep.EMAIL_ADDRESS -> {
+                if (state.value.error != null) {
+                    updateState {
+                        it.copy(error = null)
+                    }
+                } else {
+                    navigateBack()
+                }
+            }
+
+            ConfigStep.PASSWORD -> updateState {
+                it.copy(
+                    configStep = ConfigStep.EMAIL_ADDRESS,
+                    password = StringInputField(),
+                )
+            }
+
+            ConfigStep.OAUTH -> TODO()
+        }
+    }
+
+    private fun navigateBack() = emitEffect(Effect.NavigateBack)
+
+    private fun navigateNext() = emitEffect(Effect.NavigateNext)
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AutoDiscoveryStringMapper.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AutoDiscoveryStringMapper.kt
new file mode 100644
index 0000000000000000000000000000000000000000..19d8749ce7b9679f79b6631650822dbfbeb49dde
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AutoDiscoveryStringMapper.kt
@@ -0,0 +1,46 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import android.content.res.Resources
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.domain.entity.AutoDiscoveryConnectionSecurity
+import app.k9mail.feature.account.setup.domain.usecase.ValidateConfigurationApproval
+
+internal fun AutoDiscoveryConnectionSecurity.toResourceString(resources: Resources): String {
+    return when (this) {
+        AutoDiscoveryConnectionSecurity.StartTLS -> resources.getString(
+            R.string.account_setup_connection_security_start_tls,
+        )
+
+        AutoDiscoveryConnectionSecurity.TLS -> resources.getString(
+            R.string.account_setup_connection_security_ssl,
+        )
+    }
+}
+
+internal fun AccountAutoDiscoveryContract.Error.toResourceString(resources: Resources): String {
+    return when (this) {
+        AccountAutoDiscoveryContract.Error.NetworkError -> resources.getString(R.string.account_setup_error_network)
+        AccountAutoDiscoveryContract.Error.UnknownError -> resources.getString(R.string.account_setup_error_unknown)
+    }
+}
+
+internal fun ValidationError.toResourceString(resources: Resources): String {
+    return when (this) {
+        is ValidateConfigurationApproval.ValidateConfigurationApprovalError -> toConfigurationApprovalErrorString(
+            resources,
+        )
+
+        else -> throw IllegalArgumentException("Unknown error: $this")
+    }
+}
+
+private fun ValidateConfigurationApproval.ValidateConfigurationApprovalError.toConfigurationApprovalErrorString(
+    resources: Resources,
+): String {
+    return when (this) {
+        ValidateConfigurationApproval.ValidateConfigurationApprovalError.ApprovalRequired -> resources.getString(
+            R.string.account_setup_error_configuration_approval_required,
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/AutoDiscoveryStatusItem.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/AutoDiscoveryStatusItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f4af10b3bae25917283c6e5e241574bf2efbbef0
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/AutoDiscoveryStatusItem.kt
@@ -0,0 +1,24 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.item
+
+import androidx.compose.foundation.lazy.LazyItemScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.feature.account.setup.ui.autodiscovery.view.AutoDiscoveryStatusView
+import app.k9mail.feature.account.setup.ui.common.item.ListItem
+
+@Composable
+internal fun LazyItemScope.AutoDiscoveryStatusItem(
+    autoDiscoverySettings: AutoDiscoveryResult.Settings?,
+    onEditConfigurationClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    ListItem(
+        modifier = modifier,
+    ) {
+        AutoDiscoveryStatusView(
+            settings = autoDiscoverySettings,
+            onEditConfigurationClick = onEditConfigurationClick,
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/ConfigurationApprovalItem.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/ConfigurationApprovalItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c6a8b7e2dfc89526fca468e9379ea7bc058a1f21
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/ConfigurationApprovalItem.kt
@@ -0,0 +1,24 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.item
+
+import androidx.compose.foundation.lazy.LazyItemScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.feature.account.setup.domain.input.BooleanInputField
+import app.k9mail.feature.account.setup.ui.autodiscovery.view.ConfigurationApprovalView
+import app.k9mail.feature.account.setup.ui.common.item.ListItem
+
+@Composable
+internal fun LazyItemScope.ConfigurationApprovalItem(
+    approvalState: BooleanInputField,
+    onConfigurationApprovalChange: (Boolean) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    ListItem(
+        modifier = modifier,
+    ) {
+        ConfigurationApprovalView(
+            approvalState = approvalState,
+            onConfigurationApprovalChange = onConfigurationApprovalChange,
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/ContentItems.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/ContentItems.kt
new file mode 100644
index 0000000000000000000000000000000000000000..29c5f07ae6d1d05e26913627b5f524fa5663f083
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/ContentItems.kt
@@ -0,0 +1,47 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.item
+
+import androidx.compose.foundation.lazy.LazyListScope
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.ConfigStep
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Event
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.State
+
+internal fun LazyListScope.contentItems(
+    state: State,
+    onEvent: (Event) -> Unit,
+) {
+    if (state.configStep == ConfigStep.PASSWORD) {
+        item(key = "autodiscovery") {
+            AutoDiscoveryStatusItem(
+                autoDiscoverySettings = state.autoDiscoverySettings,
+                onEditConfigurationClick = { onEvent(Event.OnEditConfigurationClicked) },
+            )
+        }
+        if (state.autoDiscoverySettings != null && state.autoDiscoverySettings.isTrusted.not()) {
+            item(key = "config_approval") {
+                ConfigurationApprovalItem(
+                    approvalState = state.configurationApproved,
+                    onConfigurationApprovalChange = { onEvent(Event.ConfigurationApprovalChanged(it)) },
+                )
+            }
+        }
+    }
+
+    item(key = "email") {
+        EmailAddressItem(
+            emailAddress = state.emailAddress.value,
+            error = state.emailAddress.error,
+            onEmailAddressChange = { onEvent(Event.EmailAddressChanged(it)) },
+            isEnabled = state.configStep == ConfigStep.EMAIL_ADDRESS,
+        )
+    }
+
+    if (state.configStep == ConfigStep.PASSWORD) {
+        item(key = "password") {
+            PasswordItem(
+                password = state.password.value,
+                error = state.password.error,
+                onPasswordChange = { onEvent(Event.PasswordChanged(it)) },
+            )
+        }
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/EmailAddressItem.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/EmailAddressItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4a9eec5abe6a7475776d924bb56c739dd0d78f1c
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/EmailAddressItem.kt
@@ -0,0 +1,34 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.item
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.lazy.LazyItemScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.ui.compose.designsystem.molecule.input.EmailAddressInput
+import app.k9mail.feature.account.setup.ui.common.item.ListItem
+import app.k9mail.feature.account.setup.ui.common.toResourceString
+
+@Composable
+internal fun LazyItemScope.EmailAddressItem(
+    emailAddress: String,
+    error: ValidationError?,
+    onEmailAddressChange: (String) -> Unit,
+    modifier: Modifier = Modifier,
+    isEnabled: Boolean = true,
+) {
+    val resources = LocalContext.current.resources
+
+    ListItem(
+        modifier = modifier,
+    ) {
+        EmailAddressInput(
+            emailAddress = emailAddress,
+            errorMessage = error?.toResourceString(resources),
+            onEmailAddressChange = onEmailAddressChange,
+            isEnabled = isEnabled,
+            contentPadding = PaddingValues(),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/PasswordItem.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/PasswordItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1c7dee5be56a7c8fa0c7b9059b48767f10e9c1f5
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/PasswordItem.kt
@@ -0,0 +1,32 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.item
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.lazy.LazyItemScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.ui.compose.designsystem.molecule.input.PasswordInput
+import app.k9mail.feature.account.setup.ui.common.item.ListItem
+import app.k9mail.feature.account.setup.ui.common.toResourceString
+
+@Composable
+internal fun LazyItemScope.PasswordItem(
+    password: String,
+    error: ValidationError?,
+    onPasswordChange: (String) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val resources = LocalContext.current.resources
+
+    ListItem(
+        modifier = modifier,
+    ) {
+        PasswordInput(
+            password = password,
+            errorMessage = error?.toResourceString(resources),
+            onPasswordChange = onPasswordChange,
+            contentPadding = PaddingValues(),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryServerSettingsView.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryServerSettingsView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d20b0748fb4040567fe9064b01fcd7cef316a683
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryServerSettingsView.kt
@@ -0,0 +1,174 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.view
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.withStyle
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.autodiscovery.api.ConnectionSecurity
+import app.k9mail.core.common.net.Hostname
+import app.k9mail.core.common.net.isIpAddress
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.ui.compose.designsystem.atom.Icon
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody2
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import app.k9mail.feature.account.setup.ui.autodiscovery.toResourceString
+import app.k9mail.feature.account.setup.ui.common.toResourceString
+
+@Composable
+internal fun AutoDiscoveryServerSettingsView(
+    protocolName: String,
+    serverHostname: Hostname,
+    serverPort: Int,
+    connectionSecurity: ConnectionSecurity,
+    modifier: Modifier = Modifier,
+    username: String = "",
+    isIncoming: Boolean = true,
+) {
+    val resources = LocalContext.current.resources
+    Column(
+        verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+        modifier = modifier,
+    ) {
+        TextBody1(
+            text = buildAnnotatedString {
+                append(if (isIncoming) "Incoming" else "Outgoing")
+                append(" ")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append(protocolName.uppercase())
+                }
+                append(" ")
+                append("configuration")
+            },
+        )
+
+        ServerSettingRow(
+            icon = if (isIncoming) Icons.Filled.inbox else Icons.Filled.outbox,
+            text = buildAnnotatedString {
+                append("Server")
+                append(": ")
+                if (serverHostname.isIpAddress()) {
+                    append(serverHostname.value)
+                } else {
+                    append(serverHostname.value.substringBefore(".") + ".")
+                    withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                        append(serverHostname.value.substringAfter("."))
+                    }
+                }
+                append(":$serverPort")
+            },
+        )
+
+        ServerSettingRow(
+            icon = Icons.Filled.security,
+            text = buildAnnotatedString {
+                append("Security: ")
+                append(connectionSecurity.toResourceString(resources))
+            },
+        )
+
+        if (username.isNotEmpty()) {
+            ServerSettingRow(
+                icon = Icons.Filled.user,
+                text = buildAnnotatedString {
+                    append("Username: ")
+                    append(username)
+                },
+            )
+        }
+    }
+}
+
+@Composable
+private fun ServerSettingRow(
+    icon: ImageVector,
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    showIcon: Boolean = false,
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .then(modifier),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        if (showIcon) {
+            Icon(
+                imageVector = icon,
+                modifier = Modifier.padding(end = MainTheme.spacings.default),
+            )
+        }
+        TextBody2(
+            text = text,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryServerSettingsViewPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryServerSettingsView(
+            protocolName = "IMAP",
+            serverHostname = "imap.example.com".toHostname(),
+            serverPort = 993,
+            connectionSecurity = ConnectionSecurity.TLS,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryServerSettingsViewOutgoingPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryServerSettingsView(
+            protocolName = "IMAP",
+            serverHostname = "imap.example.com".toHostname(),
+            serverPort = 993,
+            connectionSecurity = ConnectionSecurity.TLS,
+            isIncoming = false,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryServerSettingsViewWithUserPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryServerSettingsView(
+            protocolName = "IMAP",
+            serverHostname = "imap.example.com".toHostname(),
+            serverPort = 993,
+            connectionSecurity = ConnectionSecurity.TLS,
+            username = "username",
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryServerSettingsViewWithIpAddressPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryServerSettingsView(
+            protocolName = "IMAP",
+            serverHostname = "127.0.0.1".toHostname(),
+            serverPort = 993,
+            connectionSecurity = ConnectionSecurity.TLS,
+            username = "username",
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusBodyView.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusBodyView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e5a0bd12043c18fc57b8a451343e956b3cd37d7a
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusBodyView.kt
@@ -0,0 +1,133 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.view
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.autodiscovery.api.AuthenticationType
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.ConnectionSecurity
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonText
+import app.k9mail.core.ui.compose.designsystem.atom.button.buttonContentPadding
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody2
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import app.k9mail.feature.account.setup.R
+
+@Composable
+internal fun AutoDiscoveryStatusBodyView(
+    settings: AutoDiscoveryResult.Settings,
+    onEditConfigurationClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = MainTheme.spacings.default)
+            .then(modifier),
+        verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+    ) {
+        if (settings.isTrusted.not()) {
+            Spacer(modifier = Modifier.height(MainTheme.sizes.smaller))
+            TextBody2(
+                text = stringResource(
+                    id = R.string.account_setup_auto_config_status_disclaimer_untrusted_configuration,
+                ),
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+
+        val incomingServerSettings = settings.incomingServerSettings
+        if (incomingServerSettings is ImapServerSettings) {
+            Spacer(modifier = Modifier.height(MainTheme.sizes.smaller))
+            AutoDiscoveryServerSettingsView(
+                protocolName = "IMAP",
+                serverHostname = incomingServerSettings.hostname,
+                serverPort = incomingServerSettings.port.value,
+                connectionSecurity = incomingServerSettings.connectionSecurity,
+                username = incomingServerSettings.username,
+                isIncoming = true,
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+
+        val outgoingServerSettings = settings.outgoingServerSettings
+        if (outgoingServerSettings is SmtpServerSettings) {
+            Spacer(modifier = Modifier.height(MainTheme.sizes.smaller))
+            AutoDiscoveryServerSettingsView(
+                protocolName = "SMTP",
+                serverHostname = outgoingServerSettings.hostname,
+                serverPort = outgoingServerSettings.port.value,
+                connectionSecurity = outgoingServerSettings.connectionSecurity,
+                username = outgoingServerSettings.username,
+                isIncoming = false,
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+
+        EditConfigurationButton(
+            onEditConfigurationClick = onEditConfigurationClick,
+        )
+    }
+}
+
+@Composable
+internal fun EditConfigurationButton(
+    modifier: Modifier = Modifier,
+    onEditConfigurationClick: () -> Unit,
+) {
+    Row(
+        horizontalArrangement = Arrangement.End,
+        modifier = Modifier
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        ButtonText(
+            text = stringResource(id = R.string.account_setup_auto_config_status_edit_configuration_button_label),
+            onClick = onEditConfigurationClick,
+            color = MainTheme.colors.warning,
+            contentPadding = buttonContentPadding(
+                start = MainTheme.spacings.double,
+                end = MainTheme.spacings.double,
+            ),
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryStatusBodyViewPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryStatusBodyView(
+            settings = AutoDiscoveryResult.Settings(
+                incomingServerSettings = ImapServerSettings(
+                    hostname = "imap.example.com".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = ConnectionSecurity.TLS,
+                    authenticationType = AuthenticationType.PasswordEncrypted,
+                    username = "",
+                ),
+                outgoingServerSettings = SmtpServerSettings(
+                    hostname = "smtp.example.com".toHostname(),
+                    port = 465.toPort(),
+                    connectionSecurity = ConnectionSecurity.TLS,
+                    authenticationType = AuthenticationType.PasswordEncrypted,
+                    username = "",
+                ),
+                isTrusted = true,
+            ),
+            onEditConfigurationClick = {},
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusHeaderState.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusHeaderState.kt
new file mode 100644
index 0000000000000000000000000000000000000000..de36f44fcc2d36e64280c2fd5121fb49431f5615
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusHeaderState.kt
@@ -0,0 +1,34 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.view
+
+import androidx.annotation.StringRes
+import androidx.compose.ui.graphics.vector.ImageVector
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.feature.account.setup.R
+
+enum class AutoDiscoveryStatusHeaderState(
+    val icon: ImageVector,
+    @StringRes val titleResourceId: Int,
+    @StringRes val subtitleResourceId: Int,
+    val isExpandable: Boolean,
+) {
+    NoSettings(
+        icon = Icons.Outlined.info,
+        titleResourceId = R.string.account_setup_auto_config_status_header_title_configuration_not_found,
+        subtitleResourceId = R.string.account_setup_auto_config_status_header_subtitle_configuration_not_found,
+        isExpandable = false,
+    ),
+
+    Trusted(
+        icon = Icons.Outlined.check,
+        titleResourceId = R.string.account_setup_auto_config_status_header_title_configuration_found,
+        subtitleResourceId = R.string.account_setup_auto_config_status_header_subtitle_configuration_trusted,
+        isExpandable = true,
+    ),
+
+    Untrusted(
+        icon = Icons.Outlined.info,
+        titleResourceId = R.string.account_setup_auto_config_status_header_title_configuration_found,
+        subtitleResourceId = R.string.account_setup_auto_config_status_header_subtitle_configuration_untrusted,
+        isExpandable = true,
+    ),
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusHeaderView.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusHeaderView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..31c5906027b294db23b00ff476ec414681fc1bc1
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusHeaderView.kt
@@ -0,0 +1,129 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.view
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.requiredSize
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.Icon
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody2
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline6
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Suppress("LongMethod")
+@Composable
+internal fun AutoDiscoveryStatusHeaderView(
+    state: AutoDiscoveryStatusHeaderState,
+    isExpanded: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .then(modifier),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Icon(
+            imageVector = state.icon,
+            tint = selectColor(state),
+            modifier = Modifier
+                .padding(MainTheme.spacings.default)
+                .requiredSize(MainTheme.sizes.medium),
+        )
+        Column(
+            modifier = Modifier
+                .weight(1f)
+                .padding(
+                    start = MainTheme.spacings.default,
+                    top = MainTheme.spacings.half,
+                    bottom = MainTheme.spacings.half,
+                ),
+        ) {
+            TextHeadline6(
+                text = stringResource(state.titleResourceId),
+            )
+            TextBody2(
+                text = stringResource(state.subtitleResourceId),
+                color = selectColor(state),
+            )
+        }
+        if (state.isExpandable) {
+            Icon(
+                imageVector = if (isExpanded) Icons.Outlined.expandLess else Icons.Outlined.expandMore,
+                modifier = Modifier.padding(MainTheme.spacings.default),
+            )
+        }
+    }
+}
+
+@Composable
+private fun selectColor(state: AutoDiscoveryStatusHeaderState): Color {
+    return when (state) {
+        AutoDiscoveryStatusHeaderState.NoSettings -> MainTheme.colors.primary
+        AutoDiscoveryStatusHeaderState.Trusted -> MainTheme.colors.success
+        AutoDiscoveryStatusHeaderState.Untrusted -> MainTheme.colors.warning
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryStatusHeaderViewTrustedCollapsedPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryStatusHeaderView(
+            state = AutoDiscoveryStatusHeaderState.Trusted,
+            isExpanded = true,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryStatusHeaderViewTrustedExpandedPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryStatusHeaderView(
+            state = AutoDiscoveryStatusHeaderState.Trusted,
+            isExpanded = false,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryStatusHeaderViewUntrustedCollapsedPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryStatusHeaderView(
+            state = AutoDiscoveryStatusHeaderState.Untrusted,
+            isExpanded = true,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryStatusHeaderViewUntrustedExpandedPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryStatusHeaderView(
+            state = AutoDiscoveryStatusHeaderState.Untrusted,
+            isExpanded = false,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryStatusHeaderNoSettingsPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryStatusHeaderView(
+            state = AutoDiscoveryStatusHeaderState.NoSettings,
+            isExpanded = false,
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusView.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8c5cdf6fd37895d5d9ab27c484a4a001137b0340
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusView.kt
@@ -0,0 +1,122 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.view
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import app.k9mail.autodiscovery.api.AuthenticationType
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.ConnectionSecurity
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+import app.k9mail.core.ui.compose.designsystem.atom.Surface
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+internal fun AutoDiscoveryStatusView(
+    settings: AutoDiscoveryResult.Settings?,
+    onEditConfigurationClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val expanded = remember { mutableStateOf(false) }
+
+    Column(
+        modifier = modifier,
+    ) {
+        Surface(
+            shape = MainTheme.shapes.small,
+            modifier = Modifier
+                .border(1.dp, Color.Gray.copy(alpha = 0.5f))
+                .clickable { expanded.value = !expanded.value },
+        ) {
+            Column(
+                modifier = Modifier.padding(MainTheme.spacings.default),
+            ) {
+                AutoDiscoveryStatusHeaderView(
+                    state = if (settings == null) {
+                        AutoDiscoveryStatusHeaderState.NoSettings
+                    } else if (settings.isTrusted) {
+                        AutoDiscoveryStatusHeaderState.Trusted
+                    } else {
+                        AutoDiscoveryStatusHeaderState.Untrusted
+                    },
+                    isExpanded = expanded.value,
+                )
+
+                if (settings != null) {
+                    AnimatedVisibility(visible = expanded.value) {
+                        AutoDiscoveryStatusBodyView(
+                            settings = settings,
+                            onEditConfigurationClick = onEditConfigurationClick,
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun AutoDiscoveryStatusViewTrustedPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryStatusView(
+            settings = AutoDiscoveryResult.Settings(
+                incomingServerSettings = ImapServerSettings(
+                    hostname = "imap.example.com".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = ConnectionSecurity.TLS,
+                    authenticationType = AuthenticationType.PasswordEncrypted,
+                    username = "",
+                ),
+                outgoingServerSettings = SmtpServerSettings(
+                    hostname = "smtp.example.com".toHostname(),
+                    port = 465.toPort(),
+                    connectionSecurity = ConnectionSecurity.TLS,
+                    authenticationType = AuthenticationType.PasswordEncrypted,
+                    username = "",
+                ),
+                isTrusted = true,
+            ),
+            onEditConfigurationClick = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun AutoDiscoveryStatusViewUntrustedPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryStatusView(
+            settings = AutoDiscoveryResult.Settings(
+                incomingServerSettings = ImapServerSettings(
+                    hostname = "imap.example.com".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = ConnectionSecurity.TLS,
+                    authenticationType = AuthenticationType.PasswordEncrypted,
+                    username = "",
+                ),
+                outgoingServerSettings = SmtpServerSettings(
+                    hostname = "smtp.example.com".toHostname(),
+                    port = 465.toPort(),
+                    connectionSecurity = ConnectionSecurity.TLS,
+                    authenticationType = AuthenticationType.PasswordEncrypted,
+                    username = "",
+                ),
+                isTrusted = false,
+            ),
+            onEditConfigurationClick = {},
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/ConfigurationApprovalView.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/ConfigurationApprovalView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2bd6c81b27df2fdd9e22907afedfe0b8351fa199
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/ConfigurationApprovalView.kt
@@ -0,0 +1,34 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.view
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.height
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.designsystem.molecule.input.CheckboxInput
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.domain.input.BooleanInputField
+import app.k9mail.feature.account.setup.ui.autodiscovery.toResourceString
+
+@Composable
+internal fun ConfigurationApprovalView(
+    approvalState: BooleanInputField,
+    onConfigurationApprovalChange: (Boolean) -> Unit,
+) {
+    val resources = LocalContext.current.resources
+
+    Spacer(modifier = Modifier.height(MainTheme.spacings.default))
+
+    CheckboxInput(
+        text = stringResource(
+            id = R.string.account_setup_auto_config_status_checkbox_configuration_untrusted_confirmation_label,
+        ),
+        checked = approvalState.value ?: false,
+        onCheckedChange = onConfigurationApprovalChange,
+        errorMessage = approvalState.error?.toResourceString(resources),
+        contentPadding = PaddingValues(),
+    )
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupBottomBar.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupBottomBar.kt
new file mode 100644
index 0000000000000000000000000000000000000000..31fe76e432aecebc62a112f95e117522bbeffbf9
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupBottomBar.kt
@@ -0,0 +1,77 @@
+package app.k9mail.feature.account.setup.ui.common
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.designsystem.atom.button.Button
+import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonOutlined
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveWidthContainer
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+
+@Composable
+internal fun AccountSetupBottomBar(
+    nextButtonText: String,
+    backButtonText: String,
+    onNextClick: () -> Unit,
+    onBackClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    ResponsiveWidthContainer(
+        modifier = Modifier
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        Row(
+            modifier = Modifier
+                .padding(
+                    start = MainTheme.spacings.quadruple,
+                    top = MainTheme.spacings.default,
+                    end = MainTheme.spacings.quadruple,
+                    bottom = MainTheme.spacings.double,
+                )
+                .fillMaxWidth(),
+            horizontalArrangement = Arrangement.SpaceBetween,
+        ) {
+            ButtonOutlined(
+                text = backButtonText,
+                onClick = onBackClick,
+            )
+            Button(
+                text = nextButtonText,
+                onClick = onNextClick,
+            )
+        }
+    }
+}
+
+@DevicePreviews
+@Composable
+internal fun AccountSetupBottomBarK9Preview() {
+    K9Theme {
+        AccountSetupBottomBar(
+            nextButtonText = "Next",
+            backButtonText = "Back",
+            onNextClick = {},
+            onBackClick = {},
+        )
+    }
+}
+
+@DevicePreviews
+@Composable
+internal fun AccountSetupBottomBarThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountSetupBottomBar(
+            nextButtonText = "Next",
+            backButtonText = "Back",
+            onNextClick = {},
+            onBackClick = {},
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupStringMapper.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupStringMapper.kt
new file mode 100644
index 0000000000000000000000000000000000000000..15b40d767ac552ea291c8c26232fdc159d1db753
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupStringMapper.kt
@@ -0,0 +1,88 @@
+package app.k9mail.feature.account.setup.ui.common
+
+import android.content.res.Resources
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.usecase.ValidateEmailAddress.ValidateEmailAddressError
+import app.k9mail.feature.account.setup.domain.usecase.ValidateImapPrefix.ValidateImapPrefixError
+import app.k9mail.feature.account.setup.domain.usecase.ValidatePassword.ValidatePasswordError
+import app.k9mail.feature.account.setup.domain.usecase.ValidatePort.ValidatePortError
+import app.k9mail.feature.account.setup.domain.usecase.ValidateServer.ValidateServerError
+import app.k9mail.feature.account.setup.domain.usecase.ValidateUsername.ValidateUsernameError
+
+internal fun ConnectionSecurity.toResourceString(resources: Resources): String {
+    return when (this) {
+        ConnectionSecurity.None -> resources.getString(R.string.account_setup_connection_security_none)
+        ConnectionSecurity.StartTLS -> resources.getString(R.string.account_setup_connection_security_start_tls)
+        ConnectionSecurity.TLS -> resources.getString(R.string.account_setup_connection_security_ssl)
+    }
+}
+
+internal fun ValidationError.toResourceString(resources: Resources): String {
+    return when (this) {
+        is ValidateEmailAddressError -> toEmailAddressErrorString(resources)
+        is ValidateServerError -> toServerErrorString(resources)
+        is ValidatePortError -> toPortErrorString(resources)
+        is ValidateUsernameError -> toUsernameErrorString(resources)
+        is ValidatePasswordError -> toPasswordErrorString(resources)
+        is ValidateImapPrefixError -> toImapPrefixErrorString(resources)
+        else -> throw IllegalArgumentException("Unknown error: $this")
+    }
+}
+
+private fun ValidateEmailAddressError.toEmailAddressErrorString(resources: Resources): String {
+    return when (this) {
+        is ValidateEmailAddressError.EmptyEmailAddress -> resources.getString(
+            R.string.account_setup_validation_error_email_address_required,
+        )
+
+        is ValidateEmailAddressError.InvalidEmailAddress -> resources.getString(
+            R.string.account_setup_validation_error_email_address_invalid,
+        )
+    }
+}
+
+private fun ValidateServerError.toServerErrorString(resources: Resources): String {
+    return when (this) {
+        is ValidateServerError.EmptyServer -> resources.getString(
+            R.string.account_setup_validation_error_server_required,
+        )
+    }
+}
+
+private fun ValidatePortError.toPortErrorString(resources: Resources): String {
+    return when (this) {
+        is ValidatePortError.EmptyPort -> resources.getString(
+            R.string.account_setup_validation_error_port_required,
+        )
+
+        is ValidatePortError.InvalidPort -> resources.getString(
+            R.string.account_setup_validation_error_port_invalid,
+        )
+    }
+}
+
+private fun ValidateUsernameError.toUsernameErrorString(resources: Resources): String {
+    return when (this) {
+        ValidateUsernameError.EmptyUsername -> resources.getString(
+            R.string.account_setup_validation_error_username_required,
+        )
+    }
+}
+
+private fun ValidatePasswordError.toPasswordErrorString(resources: Resources): String {
+    return when (this) {
+        ValidatePasswordError.EmptyPassword -> resources.getString(
+            R.string.account_setup_validation_error_password_required,
+        )
+    }
+}
+
+private fun ValidateImapPrefixError.toImapPrefixErrorString(resources: Resources): String {
+    return when (this) {
+        ValidateImapPrefixError.BlankImapPrefix -> resources.getString(
+            R.string.account_setup_validation_error_imap_prefix_blank,
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupTopAppBar.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupTopAppBar.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c5f07c409357e3fc40aef365e255d6af87970a4a
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupTopAppBar.kt
@@ -0,0 +1,44 @@
+package app.k9mail.feature.account.setup.ui.common
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.designsystem.organism.TopAppBar
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.setup.R.string
+
+@Composable
+internal fun AccountSetupTopAppBar(
+    title: String,
+) {
+    TopAppBar(
+        title = title,
+        subtitle = stringResource(id = string.account_setup_title),
+        titleContentPadding = PaddingValues(
+            start = MainTheme.spacings.double,
+        ),
+    )
+}
+
+@DevicePreviews
+@Composable
+internal fun AccountSetupTopAppBarK9Preview() {
+    K9Theme {
+        AccountSetupTopAppBar(
+            title = "Title",
+        )
+    }
+}
+
+@DevicePreviews
+@Composable
+internal fun AccountSetupTopAppBarThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountSetupTopAppBar(
+            title = "Title",
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupTopHeader.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupTopHeader.kt
new file mode 100644
index 0000000000000000000000000000000000000000..bf4bc7bdf2255b5d0211842c795196a3e1dcec78
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupTopHeader.kt
@@ -0,0 +1,70 @@
+package app.k9mail.feature.account.setup.ui.common
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.withStyle
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline2
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveWidthContainer
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import app.k9mail.feature.account.setup.R.string
+
+@Composable
+internal fun AccountSetupTopHeader(
+    modifier: Modifier = Modifier,
+) {
+    ResponsiveWidthContainer(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(
+                top = MainTheme.spacings.quadruple,
+                bottom = MainTheme.spacings.default,
+            )
+            .then(modifier),
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(
+                    start = MainTheme.spacings.half,
+                    end = MainTheme.spacings.quadruple,
+                )
+                .then(modifier),
+            horizontalArrangement = Arrangement.Center,
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            Image(
+                painter = painterResource(id = MainTheme.images.logo),
+                contentDescription = null,
+            )
+
+            TextHeadline2(
+                text = buildAnnotatedString {
+                    withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                        append(stringResource(id = string.account_setup_title))
+                    }
+                },
+            )
+        }
+    }
+}
+
+@Preview
+@Composable
+internal fun AccountSetupTopHeaderPreview() {
+    PreviewWithThemes {
+        AccountSetupTopHeader()
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/item/ErrorItem.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/item/ErrorItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7082cba50bd322f5270a981548c776d4a18205d0
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/item/ErrorItem.kt
@@ -0,0 +1,24 @@
+package app.k9mail.feature.account.setup.ui.common.item
+
+import androidx.compose.foundation.lazy.LazyItemScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.designsystem.molecule.ErrorView
+
+@Composable
+internal fun LazyItemScope.ErrorItem(
+    title: String,
+    modifier: Modifier = Modifier,
+    message: String? = null,
+    onRetry: () -> Unit = { },
+) {
+    ListItem(
+        modifier = modifier,
+    ) {
+        ErrorView(
+            title = title,
+            message = message,
+            onRetry = onRetry,
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/item/ItemPadding.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/item/ItemPadding.kt
new file mode 100644
index 0000000000000000000000000000000000000000..860ab2e52f89666268d5141488f7e43c1295ddce
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/item/ItemPadding.kt
@@ -0,0 +1,19 @@
+package app.k9mail.feature.account.setup.ui.common.item
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.runtime.Composable
+import app.k9mail.core.ui.compose.theme.MainTheme
+
+@Composable
+internal fun defaultHeadlineItemPadding() = PaddingValues(
+    start = MainTheme.spacings.quadruple,
+    top = MainTheme.spacings.triple,
+    end = MainTheme.spacings.quadruple,
+    bottom = MainTheme.spacings.default,
+)
+
+@Composable
+internal fun defaultItemPadding() = PaddingValues(
+    horizontal = MainTheme.spacings.quadruple,
+    vertical = MainTheme.spacings.zero,
+)
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/item/ListItem.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/item/ListItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8ba642f7a61a839530bdfa1656de34ccb59617aa
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/item/ListItem.kt
@@ -0,0 +1,28 @@
+package app.k9mail.feature.account.setup.ui.common.item
+
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyItemScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+
+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+internal fun LazyItemScope.ListItem(
+    modifier: Modifier = Modifier,
+    contentPaddingValues: PaddingValues = defaultItemPadding(),
+    content: @Composable () -> Unit,
+) {
+    Box(
+        modifier = Modifier
+            .padding(contentPaddingValues)
+            .animateItemPlacement()
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        content()
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/item/LoadingItem.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/item/LoadingItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9467596288c8ed2aad1b903fc93043182a48515b
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/item/LoadingItem.kt
@@ -0,0 +1,20 @@
+package app.k9mail.feature.account.setup.ui.common.item
+
+import androidx.compose.foundation.lazy.LazyItemScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.designsystem.molecule.LoadingView
+
+@Composable
+internal fun LazyItemScope.LoadingItem(
+    modifier: Modifier = Modifier,
+    message: String? = null,
+) {
+    ListItem(
+        modifier = modifier,
+    ) {
+        LoadingView(
+            message = message,
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigContent.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..88073b551e55089a53779c2d2384011589785f53
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigContent.kt
@@ -0,0 +1,198 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.requiredHeight
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.designsystem.molecule.input.CheckboxInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.NumberInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.PasswordInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.SelectInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.TextInput
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveWidthContainer
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.IncomingProtocolType
+import app.k9mail.feature.account.setup.ui.common.item.defaultItemPadding
+import app.k9mail.feature.account.setup.ui.common.toResourceString
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.State
+import kotlinx.collections.immutable.persistentListOf
+
+@Suppress("LongMethod")
+@Composable
+internal fun AccountIncomingConfigContent(
+    state: State,
+    onEvent: (Event) -> Unit,
+    contentPadding: PaddingValues,
+    modifier: Modifier = Modifier,
+) {
+    val resources = LocalContext.current.resources
+
+    ResponsiveWidthContainer(
+        modifier = Modifier
+            .testTag("AccountIncomingConfigContent")
+            .padding(contentPadding)
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        LazyColumn(
+            modifier = Modifier
+                .fillMaxSize()
+                .imePadding(),
+            horizontalAlignment = Alignment.Start,
+            verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+        ) {
+            item {
+                Spacer(modifier = Modifier.requiredHeight(MainTheme.sizes.smaller))
+            }
+
+            item {
+                SelectInput(
+                    options = IncomingProtocolType.all(),
+                    selectedOption = state.protocolType,
+                    onOptionChange = { onEvent(Event.ProtocolTypeChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_incoming_config_protocol_type_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                TextInput(
+                    text = state.server.value,
+                    errorMessage = state.server.error?.toResourceString(resources),
+                    onTextChange = { onEvent(Event.ServerChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_incoming_config_server_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                SelectInput(
+                    options = ConnectionSecurity.all(),
+                    optionToStringTransformation = { it.toResourceString(resources) },
+                    selectedOption = state.security,
+                    onOptionChange = { onEvent(Event.SecurityChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_incoming_config_security_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                NumberInput(
+                    value = state.port.value,
+                    errorMessage = state.port.error?.toResourceString(resources),
+                    onValueChange = { onEvent(Event.PortChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_outgoing_config_port_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                TextInput(
+                    text = state.username.value,
+                    errorMessage = state.username.error?.toResourceString(resources),
+                    onTextChange = { onEvent(Event.UsernameChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_outgoing_config_username_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                PasswordInput(
+                    password = state.password.value,
+                    errorMessage = state.password.error?.toResourceString(resources),
+                    onPasswordChange = { onEvent(Event.PasswordChanged(it)) },
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                // TODO add client certificate support
+                SelectInput(
+                    options = persistentListOf(
+                        stringResource(
+                            id = R.string.account_setup_client_certificate_none_available,
+                        ),
+                    ),
+                    optionToStringTransformation = { it },
+                    selectedOption = stringResource(
+                        id = R.string.account_setup_client_certificate_none_available,
+                    ),
+                    onOptionChange = { onEvent(Event.ClientCertificateChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_outgoing_config_client_certificate_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            if (state.protocolType == IncomingProtocolType.IMAP) {
+                item {
+                    CheckboxInput(
+                        text = stringResource(id = R.string.account_setup_incoming_config_imap_namespace_label),
+                        checked = state.imapAutodetectNamespaceEnabled,
+                        onCheckedChange = { onEvent(Event.ImapAutoDetectNamespaceChanged(it)) },
+                        contentPadding = defaultItemPadding(),
+                    )
+                }
+
+                item {
+                    TextInput(
+                        text = state.imapPrefix.value,
+                        errorMessage = state.imapPrefix.error?.toResourceString(resources),
+                        onTextChange = { onEvent(Event.ImapPrefixChanged(it)) },
+                        label = stringResource(id = R.string.account_setup_incoming_config_imap_prefix_label),
+                        contentPadding = defaultItemPadding(),
+                    )
+                }
+            }
+
+            item {
+                CheckboxInput(
+                    text = stringResource(id = R.string.account_setup_incoming_config_compression_label),
+                    checked = state.useCompression,
+                    onCheckedChange = { onEvent(Event.UseCompressionChanged(it)) },
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+        }
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountIncomingConfigContentK9Preview() {
+    K9Theme {
+        AccountIncomingConfigContent(
+            onEvent = { },
+            state = State(),
+            contentPadding = PaddingValues(),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountIncomingConfigContentThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountIncomingConfigContent(
+            onEvent = { },
+            state = State(),
+            contentPadding = PaddingValues(),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigContract.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ec561d9fc549014987139e3b3df1cf583da075a0
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigContract.kt
@@ -0,0 +1,59 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.IncomingProtocolType
+import app.k9mail.feature.account.setup.domain.entity.toDefaultPort
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+
+interface AccountIncomingConfigContract {
+
+    interface ViewModel : UnidirectionalViewModel<State, Event, Effect> {
+        fun initState(state: State)
+    }
+
+    data class State(
+        val protocolType: IncomingProtocolType = IncomingProtocolType.DEFAULT,
+        val server: StringInputField = StringInputField(),
+        val security: ConnectionSecurity = IncomingProtocolType.DEFAULT.defaultConnectionSecurity,
+        val port: NumberInputField = NumberInputField(
+            IncomingProtocolType.DEFAULT.toDefaultPort(IncomingProtocolType.DEFAULT.defaultConnectionSecurity),
+        ),
+        val username: StringInputField = StringInputField(),
+        val password: StringInputField = StringInputField(),
+        val clientCertificate: String = "",
+        val imapAutodetectNamespaceEnabled: Boolean = true,
+        val imapPrefix: StringInputField = StringInputField(),
+        val useCompression: Boolean = true,
+    )
+
+    sealed class Event {
+        data class ProtocolTypeChanged(val protocolType: IncomingProtocolType) : Event()
+        data class ServerChanged(val server: String) : Event()
+        data class SecurityChanged(val security: ConnectionSecurity) : Event()
+        data class PortChanged(val port: Long?) : Event()
+        data class UsernameChanged(val username: String) : Event()
+        data class PasswordChanged(val password: String) : Event()
+        data class ClientCertificateChanged(val clientCertificate: String) : Event()
+        data class ImapAutoDetectNamespaceChanged(val enabled: Boolean) : Event()
+        data class ImapPrefixChanged(val imapPrefix: String) : Event()
+        data class UseCompressionChanged(val useCompression: Boolean) : Event()
+        object OnNextClicked : Event()
+        object OnBackClicked : Event()
+    }
+
+    sealed class Effect {
+        object NavigateNext : Effect()
+        object NavigateBack : Effect()
+    }
+
+    interface Validator {
+        fun validateServer(server: String): ValidationResult
+        fun validatePort(port: Long?): ValidationResult
+        fun validateUsername(username: String): ValidationResult
+        fun validatePassword(password: String): ValidationResult
+        fun validateImapPrefix(imapPrefix: String): ValidationResult
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0909d304e507add3861f283f69c23ff9ec0fae4a
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigScreen.kt
@@ -0,0 +1,82 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.common.mvi.observe
+import app.k9mail.core.ui.compose.designsystem.template.Scaffold
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.ui.common.AccountSetupBottomBar
+import app.k9mail.feature.account.setup.ui.common.AccountSetupTopAppBar
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.ViewModel
+
+@Composable
+internal fun AccountIncomingConfigScreen(
+    onNext: () -> Unit,
+    onBack: () -> Unit,
+    viewModel: ViewModel,
+    modifier: Modifier = Modifier,
+) {
+    val (state, dispatch) = viewModel.observe { effect ->
+        when (effect) {
+            is Effect.NavigateNext -> onNext()
+            is Effect.NavigateBack -> onBack()
+        }
+    }
+
+    Scaffold(
+        topBar = {
+            AccountSetupTopAppBar(
+                title = stringResource(id = R.string.account_setup_incoming_config_top_bar_title),
+            )
+        },
+        bottomBar = {
+            AccountSetupBottomBar(
+                nextButtonText = stringResource(id = R.string.account_setup_button_next),
+                backButtonText = stringResource(id = R.string.account_setup_button_back),
+                onNextClick = { dispatch(Event.OnNextClicked) },
+                onBackClick = { dispatch(Event.OnBackClicked) },
+            )
+        },
+        modifier = modifier,
+    ) { innerPadding ->
+        AccountIncomingConfigContent(
+            onEvent = { dispatch(it) },
+            state = state.value,
+            contentPadding = innerPadding,
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountIncomingConfigScreenK9Preview() {
+    K9Theme {
+        AccountIncomingConfigScreen(
+            onNext = {},
+            onBack = {},
+            viewModel = AccountIncomingConfigViewModel(
+                validator = AccountIncomingConfigValidator(),
+            ),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountIncomingConfigScreenThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountIncomingConfigScreen(
+            onNext = {},
+            onBack = {},
+            viewModel = AccountIncomingConfigViewModel(
+                validator = AccountIncomingConfigValidator(),
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigValidator.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9a5753759089cd9b46423b21753d95c1ad4b2d97
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigValidator.kt
@@ -0,0 +1,36 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.usecase.ValidateImapPrefix
+import app.k9mail.feature.account.setup.domain.usecase.ValidatePassword
+import app.k9mail.feature.account.setup.domain.usecase.ValidatePort
+import app.k9mail.feature.account.setup.domain.usecase.ValidateServer
+import app.k9mail.feature.account.setup.domain.usecase.ValidateUsername
+
+internal class AccountIncomingConfigValidator(
+    private val serverValidator: ValidateServer = ValidateServer(),
+    private val portValidator: ValidatePort = ValidatePort(),
+    private val usernameValidator: ValidateUsername = ValidateUsername(),
+    private val passwordValidator: ValidatePassword = ValidatePassword(),
+    private val imapPrefixValidator: ValidateImapPrefix = ValidateImapPrefix(),
+) : AccountIncomingConfigContract.Validator {
+    override fun validateServer(server: String): ValidationResult {
+        return serverValidator.execute(server)
+    }
+
+    override fun validatePort(port: Long?): ValidationResult {
+        return portValidator.execute(port)
+    }
+
+    override fun validateUsername(username: String): ValidationResult {
+        return usernameValidator.execute(username)
+    }
+
+    override fun validatePassword(password: String): ValidationResult {
+        return passwordValidator.execute(password)
+    }
+
+    override fun validateImapPrefix(imapPrefix: String): ValidationResult {
+        return imapPrefixValidator.execute(imapPrefix)
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigViewModel.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4ff01ffcf03275cd65e15cf197a3b3f3d1752464
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigViewModel.kt
@@ -0,0 +1,104 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.IncomingProtocolType
+import app.k9mail.feature.account.setup.domain.entity.toDefaultPort
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event.ClientCertificateChanged
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event.ImapAutoDetectNamespaceChanged
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event.ImapPrefixChanged
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event.OnBackClicked
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event.OnNextClicked
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event.PasswordChanged
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event.PortChanged
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event.ProtocolTypeChanged
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event.SecurityChanged
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event.ServerChanged
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event.UseCompressionChanged
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event.UsernameChanged
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.State
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Validator
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.ViewModel
+
+internal class AccountIncomingConfigViewModel(
+    initialState: State = State(),
+    private val validator: Validator,
+) : BaseViewModel<State, Event, Effect>(initialState), ViewModel {
+
+    override fun initState(state: State) {
+        updateState {
+            state.copy()
+        }
+    }
+
+    override fun event(event: Event) {
+        when (event) {
+            is ProtocolTypeChanged -> updateProtocolType(event.protocolType)
+            is ServerChanged -> updateState { it.copy(server = it.server.updateValue(event.server)) }
+            is SecurityChanged -> updateSecurity(event.security)
+            is PortChanged -> updateState { it.copy(port = it.port.updateValue(event.port)) }
+            is UsernameChanged -> updateState { it.copy(username = it.username.updateValue(event.username)) }
+            is PasswordChanged -> updateState { it.copy(password = it.password.updateValue(event.password)) }
+            is ClientCertificateChanged -> updateState { it.copy(clientCertificate = event.clientCertificate) }
+            is ImapAutoDetectNamespaceChanged -> updateState { it.copy(imapAutodetectNamespaceEnabled = event.enabled) }
+            is ImapPrefixChanged -> updateState { it.copy(imapPrefix = it.imapPrefix.updateValue(event.imapPrefix)) }
+            is UseCompressionChanged -> updateState { it.copy(useCompression = event.useCompression) }
+
+            OnBackClicked -> navigateBack()
+            OnNextClicked -> submit()
+        }
+    }
+
+    private fun updateProtocolType(protocolType: IncomingProtocolType) {
+        updateState {
+            it.copy(
+                protocolType = protocolType,
+                security = protocolType.defaultConnectionSecurity,
+                port = it.port.updateValue(
+                    protocolType.toDefaultPort(protocolType.defaultConnectionSecurity),
+                ),
+            )
+        }
+    }
+
+    private fun updateSecurity(security: ConnectionSecurity) {
+        updateState {
+            it.copy(
+                security = security,
+                port = it.port.updateValue(it.protocolType.toDefaultPort(security)),
+            )
+        }
+    }
+
+    private fun submit() = with(state.value) {
+        val serverResult = validator.validateServer(server.value)
+        val portResult = validator.validatePort(port.value)
+        val usernameResult = validator.validateUsername(username.value)
+        val passwordResult = validator.validatePassword(password.value)
+        val imapPrefixResult = validator.validateImapPrefix(imapPrefix.value)
+
+        val hasError = listOf(serverResult, portResult, usernameResult, passwordResult, imapPrefixResult)
+            .any { it is ValidationResult.Failure }
+
+        updateState {
+            it.copy(
+                server = it.server.updateFromValidationResult(serverResult),
+                port = it.port.updateFromValidationResult(portResult),
+                username = it.username.updateFromValidationResult(usernameResult),
+                password = it.password.updateFromValidationResult(passwordResult),
+                imapPrefix = it.imapPrefix.updateFromValidationResult(imapPrefixResult),
+            )
+        }
+
+        if (!hasError) {
+            navigateNext()
+        }
+    }
+
+    private fun navigateBack() = emitEffect(Effect.NavigateBack)
+
+    private fun navigateNext() = emitEffect(Effect.NavigateNext)
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/manualconfig/AccountManualConfigContent.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/manualconfig/AccountManualConfigContent.kt
deleted file mode 100644
index f7b58b6291b6f9d996ab77e4ff8c5ef1bb6e8be1..0000000000000000000000000000000000000000
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/manualconfig/AccountManualConfigContent.kt
+++ /dev/null
@@ -1,99 +0,0 @@
-package app.k9mail.feature.account.setup.ui.manualconfig
-
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import app.k9mail.core.ui.compose.common.DevicePreviews
-import app.k9mail.core.ui.compose.designsystem.atom.button.Button
-import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonOutlined
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline5
-import app.k9mail.core.ui.compose.designsystem.template.LazyColumnWithHeaderFooter
-import app.k9mail.core.ui.compose.designsystem.template.ResponsiveContentWithBackground
-import app.k9mail.core.ui.compose.theme.K9Theme
-import app.k9mail.core.ui.compose.theme.MainTheme
-import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
-import app.k9mail.feature.account.setup.R
-
-@Composable
-internal fun AccountManualConfigContent(
-    onNextClick: () -> Unit,
-    onBackClick: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    ResponsiveContentWithBackground(
-        modifier = modifier,
-    ) {
-        LazyColumnWithHeaderFooter(
-            modifier = Modifier.fillMaxSize(),
-            verticalArrangement = Arrangement.SpaceEvenly,
-            horizontalAlignment = Alignment.CenterHorizontally,
-            footer = {
-                AccountManualConfigFooter(
-                    onNextClick = onNextClick,
-                    onBackClick = onBackClick,
-                )
-            },
-        ) {
-            item {
-                TextHeadline5(text = "Manual Config")
-            }
-        }
-    }
-}
-
-@Composable
-private fun AccountManualConfigFooter(
-    onNextClick: () -> Unit,
-    onBackClick: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(
-                start = MainTheme.spacings.quadruple,
-                top = MainTheme.spacings.triple,
-                end = MainTheme.spacings.quadruple,
-                bottom = MainTheme.spacings.double,
-            )
-            .then(modifier),
-        horizontalArrangement = Arrangement.SpaceBetween,
-    ) {
-        ButtonOutlined(
-            text = stringResource(id = R.string.account_setup_button_back),
-            onClick = onBackClick,
-        )
-        Button(
-            text = stringResource(id = R.string.account_setup_button_next),
-            onClick = onNextClick,
-        )
-    }
-}
-
-@Composable
-@DevicePreviews
-internal fun AccountManualConfigContentK9Preview() {
-    K9Theme {
-        AccountManualConfigContent(
-            onNextClick = { },
-            onBackClick = { },
-        )
-    }
-}
-
-@Composable
-@DevicePreviews
-internal fun AccountManualConfigContentThunderbirdPreview() {
-    ThunderbirdTheme {
-        AccountManualConfigContent(
-            onNextClick = { },
-            onBackClick = { },
-        )
-    }
-}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/manualconfig/AccountManualConfigScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/manualconfig/AccountManualConfigScreen.kt
deleted file mode 100644
index 58d6c798144591a9303d5d1bc8d842cfedab2b68..0000000000000000000000000000000000000000
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/manualconfig/AccountManualConfigScreen.kt
+++ /dev/null
@@ -1,14 +0,0 @@
-package app.k9mail.feature.account.setup.ui.manualconfig
-
-import androidx.compose.runtime.Composable
-
-@Composable
-fun AccountManualConfigScreen(
-    onNextClick: () -> Unit,
-    onBackClick: () -> Unit,
-) {
-    AccountManualConfigContent(
-        onNextClick = onNextClick,
-        onBackClick = onBackClick,
-    )
-}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsContent.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsContent.kt
index 04228c766e64289e410826951748f23003877c58..7af019c260d70e1099f322ecea0acf68269f2e56 100644
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsContent.kt
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsContent.kt
@@ -1,78 +1,149 @@
 package app.k9mail.feature.account.setup.ui.options
 
 import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.consumeWindowInsets
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.imePadding
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.requiredHeight
+import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.res.stringResource
 import app.k9mail.core.ui.compose.common.DevicePreviews
-import app.k9mail.core.ui.compose.designsystem.atom.button.Button
-import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonOutlined
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline5
-import app.k9mail.core.ui.compose.designsystem.template.LazyColumnWithHeaderFooter
-import app.k9mail.core.ui.compose.designsystem.template.ResponsiveContentWithBackground
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextOverline
+import app.k9mail.core.ui.compose.designsystem.molecule.input.SelectInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.SwitchInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.TextInput
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveWidthContainer
 import app.k9mail.core.ui.compose.theme.K9Theme
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
 import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.domain.entity.EmailCheckFrequency
+import app.k9mail.feature.account.setup.domain.entity.EmailDisplayCount
+import app.k9mail.feature.account.setup.ui.common.item.defaultHeadlineItemPadding
+import app.k9mail.feature.account.setup.ui.common.item.defaultItemPadding
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.State
 
+@OptIn(ExperimentalLayoutApi::class)
+@Suppress("LongMethod")
 @Composable
 internal fun AccountOptionsContent(
-    onFinishClick: () -> Unit,
-    onBackClick: () -> Unit,
+    state: State,
+    onEvent: (Event) -> Unit,
+    contentPadding: PaddingValues,
     modifier: Modifier = Modifier,
 ) {
-    ResponsiveContentWithBackground(
-        modifier = modifier,
+    val resources = LocalContext.current.resources
+
+    ResponsiveWidthContainer(
+        modifier = Modifier
+            .testTag("AccountOptionsContent")
+            .consumeWindowInsets(contentPadding)
+            .padding(contentPadding)
+            .then(modifier),
     ) {
-        LazyColumnWithHeaderFooter(
-            modifier = Modifier.fillMaxSize(),
-            verticalArrangement = Arrangement.SpaceEvenly,
-            horizontalAlignment = Alignment.CenterHorizontally,
-            footer = {
-                AccountOptionsFooter(
-                    onFinishClick = onFinishClick,
-                    onBackClick = onBackClick,
-                )
-            },
+        LazyColumn(
+            modifier = Modifier
+                .fillMaxSize()
+                .imePadding(),
+            horizontalAlignment = Alignment.Start,
+            verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
         ) {
             item {
-                TextHeadline5(text = "Options")
+                TextOverline(
+                    text = stringResource(id = R.string.account_setup_options_section_display_options),
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(defaultHeadlineItemPadding()),
+                )
             }
-        }
-    }
-}
 
-@Composable
-private fun AccountOptionsFooter(
-    onFinishClick: () -> Unit,
-    onBackClick: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(
-                start = MainTheme.spacings.quadruple,
-                top = MainTheme.spacings.triple,
-                end = MainTheme.spacings.quadruple,
-                bottom = MainTheme.spacings.double,
-            )
-            .then(modifier),
-        horizontalArrangement = Arrangement.SpaceBetween,
-    ) {
-        ButtonOutlined(
-            text = stringResource(id = R.string.account_setup_button_back),
-            onClick = onBackClick,
-        )
-        Button(
-            text = stringResource(id = R.string.account_setup_button_finish),
-            onClick = onFinishClick,
-        )
+            item {
+                TextInput(
+                    text = state.accountName.value,
+                    errorMessage = state.accountName.error?.toResourceString(resources),
+                    onTextChange = { onEvent(Event.OnAccountNameChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_options_account_name_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                TextInput(
+                    text = state.displayName.value,
+                    errorMessage = state.displayName.error?.toResourceString(resources),
+                    onTextChange = { onEvent(Event.OnDisplayNameChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_options_display_name_label),
+                    contentPadding = defaultItemPadding(),
+                    isRequired = true,
+                )
+            }
+
+            item {
+                TextInput(
+                    text = state.emailSignature.value,
+                    errorMessage = state.emailSignature.error?.toResourceString(resources),
+                    onTextChange = { onEvent(Event.OnEmailSignatureChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_options_email_signature_label),
+                    contentPadding = defaultItemPadding(),
+                    isSingleLine = false,
+                )
+            }
+
+            item {
+                TextOverline(
+                    text = stringResource(id = R.string.account_setup_options_section_sync_options_),
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(defaultHeadlineItemPadding()),
+                )
+            }
+
+            item {
+                SelectInput(
+                    options = EmailCheckFrequency.all(),
+                    optionToStringTransformation = { it.toResourceString(resources) },
+                    selectedOption = state.checkFrequency,
+                    onOptionChange = { onEvent(Event.OnCheckFrequencyChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_options_account_check_frequency_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                SelectInput(
+                    options = EmailDisplayCount.all(),
+                    optionToStringTransformation = { it.toResourceString(resources) },
+                    selectedOption = state.messageDisplayCount,
+                    onOptionChange = { onEvent(Event.OnMessageDisplayCountChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_options_email_display_count_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                SwitchInput(
+                    text = stringResource(id = R.string.account_setup_options_show_notifications_label),
+                    checked = state.showNotification,
+                    onCheckedChange = { onEvent(Event.OnShowNotificationChanged(it)) },
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                Spacer(modifier = Modifier.requiredHeight(MainTheme.sizes.smaller))
+            }
+        }
     }
 }
 
@@ -81,8 +152,9 @@ private fun AccountOptionsFooter(
 internal fun AccountOptionsContentK9Preview() {
     K9Theme {
         AccountOptionsContent(
-            onFinishClick = { },
-            onBackClick = { },
+            state = State(),
+            onEvent = {},
+            contentPadding = PaddingValues(),
         )
     }
 }
@@ -92,8 +164,9 @@ internal fun AccountOptionsContentK9Preview() {
 internal fun AccountOptionsContentThunderbirdPreview() {
     ThunderbirdTheme {
         AccountOptionsContent(
-            onFinishClick = { },
-            onBackClick = { },
+            state = State(),
+            onEvent = {},
+            contentPadding = PaddingValues(),
         )
     }
 }
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsContract.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..539bb31a1e148525148ed9c148d9d4cb134730a5
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsContract.kt
@@ -0,0 +1,46 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+import app.k9mail.feature.account.setup.domain.entity.EmailCheckFrequency
+import app.k9mail.feature.account.setup.domain.entity.EmailDisplayCount
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+
+interface AccountOptionsContract {
+
+    interface ViewModel : UnidirectionalViewModel<State, Event, Effect> {
+        fun initState(state: State)
+    }
+
+    data class State(
+        val accountName: StringInputField = StringInputField(),
+        val displayName: StringInputField = StringInputField(),
+        val emailSignature: StringInputField = StringInputField(),
+        val checkFrequency: EmailCheckFrequency = EmailCheckFrequency.DEFAULT,
+        val messageDisplayCount: EmailDisplayCount = EmailDisplayCount.DEFAULT,
+        val showNotification: Boolean = false,
+    )
+
+    sealed class Event {
+        data class OnAccountNameChanged(val accountName: String) : Event()
+        data class OnDisplayNameChanged(val displayName: String) : Event()
+        data class OnEmailSignatureChanged(val emailSignature: String) : Event()
+        data class OnCheckFrequencyChanged(val checkFrequency: EmailCheckFrequency) : Event()
+        data class OnMessageDisplayCountChanged(val messageDisplayCount: EmailDisplayCount) : Event()
+        data class OnShowNotificationChanged(val showNotification: Boolean) : Event()
+
+        object OnNextClicked : Event()
+        object OnBackClicked : Event()
+    }
+
+    sealed class Effect {
+        object NavigateNext : Effect()
+        object NavigateBack : Effect()
+    }
+
+    interface Validator {
+        fun validateAccountName(accountName: String): ValidationResult
+        fun validateDisplayName(displayName: String): ValidationResult
+        fun validateEmailSignature(emailSignature: String): ValidationResult
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsScreen.kt
index 7635554e3bbee136074b20bc5dbc29111aa05bd7..55452d3224dc12d1313c76808e7133bef0e3a836 100644
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsScreen.kt
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsScreen.kt
@@ -1,14 +1,89 @@
 package app.k9mail.feature.account.setup.ui.options
 
+import android.widget.Toast
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.common.mvi.observe
+import app.k9mail.core.ui.compose.designsystem.template.Scaffold
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.setup.R.string
+import app.k9mail.feature.account.setup.ui.common.AccountSetupBottomBar
+import app.k9mail.feature.account.setup.ui.common.AccountSetupTopAppBar
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Effect
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.ViewModel
 
 @Composable
-fun AccountOptionsScreen(
-    onFinishClick: () -> Unit,
-    onBackClick: () -> Unit,
+internal fun AccountOptionsScreen(
+    onNext: () -> Unit,
+    onBack: () -> Unit,
+    viewModel: ViewModel,
+    modifier: Modifier = Modifier,
 ) {
-    AccountOptionsContent(
-        onFinishClick = onFinishClick,
-        onBackClick = onBackClick,
-    )
+    val context = LocalContext.current
+
+    val (state, dispatch) = viewModel.observe { effect ->
+        when (effect) {
+            Effect.NavigateBack -> onBack()
+            Effect.NavigateNext -> {
+                Toast.makeText(context, "Input is valid", Toast.LENGTH_SHORT).show() // TODO remove
+                onNext()
+            }
+        }
+    }
+
+    Scaffold(
+        topBar = {
+            AccountSetupTopAppBar(
+                title = stringResource(id = string.account_setup_options_top_bar_title),
+            )
+        },
+        bottomBar = {
+            AccountSetupBottomBar(
+                nextButtonText = stringResource(id = string.account_setup_button_finish),
+                backButtonText = stringResource(id = string.account_setup_button_back),
+                onNextClick = { dispatch(Event.OnNextClicked) },
+                onBackClick = { dispatch(Event.OnBackClicked) },
+            )
+        },
+        modifier = modifier,
+    ) { innerPadding ->
+        AccountOptionsContent(
+            state = state.value,
+            onEvent = { dispatch(it) },
+            contentPadding = innerPadding,
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOptionsScreenK9Preview() {
+    K9Theme {
+        AccountOptionsScreen(
+            onNext = {},
+            onBack = {},
+            viewModel = AccountOptionsViewModel(
+                validator = AccountOptionsValidator(),
+            ),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOptionsScreenThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountOptionsScreen(
+            onNext = {},
+            onBack = {},
+            viewModel = AccountOptionsViewModel(
+                validator = AccountOptionsValidator(),
+            ),
+        )
+    }
 }
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStringMapper.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStringMapper.kt
new file mode 100644
index 0000000000000000000000000000000000000000..eae82030ce269d979c88155b85753aab9b3c1ab6
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStringMapper.kt
@@ -0,0 +1,65 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import android.content.res.Resources
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.domain.entity.EmailCheckFrequency
+import app.k9mail.feature.account.setup.domain.entity.EmailDisplayCount
+import app.k9mail.feature.account.setup.domain.usecase.ValidateAccountName.ValidateAccountNameError
+import app.k9mail.feature.account.setup.domain.usecase.ValidateAccountName.ValidateAccountNameError.BlankAccountName
+import app.k9mail.feature.account.setup.domain.usecase.ValidateDisplayName.ValidateDisplayNameError
+import app.k9mail.feature.account.setup.domain.usecase.ValidateDisplayName.ValidateDisplayNameError.EmptyDisplayName
+import app.k9mail.feature.account.setup.domain.usecase.ValidateEmailSignature.ValidateEmailSignatureError
+import app.k9mail.feature.account.setup.domain.usecase.ValidateEmailSignature.ValidateEmailSignatureError.BlankEmailSignature
+
+internal fun EmailDisplayCount.toResourceString(resources: Resources) = resources.getQuantityString(
+    R.plurals.account_setup_options_email_display_count_messages,
+    count,
+    count,
+)
+
+@Suppress("MagicNumber")
+internal fun EmailCheckFrequency.toResourceString(resources: Resources): String {
+    return when (minutes) {
+        -1 -> resources.getString(R.string.account_setup_options_email_check_frequency_never)
+
+        in 1..59 -> resources.getQuantityString(
+            R.plurals.account_setup_options_email_check_frequency_minutes,
+            minutes,
+            minutes,
+        )
+
+        else -> resources.getQuantityString(
+            R.plurals.account_setup_options_email_check_frequency_hours,
+            (minutes / 60),
+            (minutes / 60),
+        )
+    }
+}
+
+internal fun ValidationError.toResourceString(resources: Resources): String {
+    return when (this) {
+        is ValidateAccountNameError -> toAccountNameErrorString(resources)
+        is ValidateDisplayNameError -> toDisplayNameErrorString(resources)
+        is ValidateEmailSignatureError -> toEmailSignatureErrorString(resources)
+        else -> throw IllegalArgumentException("Unknown error: $this")
+    }
+}
+
+private fun ValidateAccountNameError.toAccountNameErrorString(resources: Resources): String {
+    return when (this) {
+        is BlankAccountName -> resources.getString(R.string.account_setup_options_account_name_error_blank)
+    }
+}
+
+private fun ValidateDisplayNameError.toDisplayNameErrorString(resources: Resources): String {
+    return when (this) {
+        is EmptyDisplayName -> resources.getString(R.string.account_setup_options_display_name_error_required)
+    }
+}
+
+private fun ValidateEmailSignatureError.toEmailSignatureErrorString(resources: Resources): String {
+    return when (this) {
+        is BlankEmailSignature -> resources.getString(R.string.account_setup_options_email_signature_error_blank)
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsValidator.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4a167b311d55bfbd5a45ae7d623d11642259d289
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsValidator.kt
@@ -0,0 +1,25 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.usecase.ValidateAccountName
+import app.k9mail.feature.account.setup.domain.usecase.ValidateDisplayName
+import app.k9mail.feature.account.setup.domain.usecase.ValidateEmailSignature
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Validator
+
+internal class AccountOptionsValidator(
+    private val accountNameValidator: ValidateAccountName = ValidateAccountName(),
+    private val displayNameValidator: ValidateDisplayName = ValidateDisplayName(),
+    private val emailSignatureValidator: ValidateEmailSignature = ValidateEmailSignature(),
+) : Validator {
+    override fun validateAccountName(accountName: String): ValidationResult {
+        return accountNameValidator.execute(accountName)
+    }
+
+    override fun validateDisplayName(displayName: String): ValidationResult {
+        return displayNameValidator.execute(displayName)
+    }
+
+    override fun validateEmailSignature(emailSignature: String): ValidationResult {
+        return emailSignatureValidator.execute(emailSignature)
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsViewModel.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..bad0147b625d9f174e578e5e95237ed40da43789
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsViewModel.kt
@@ -0,0 +1,100 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Effect
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event.OnAccountNameChanged
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event.OnBackClicked
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event.OnCheckFrequencyChanged
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event.OnDisplayNameChanged
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event.OnEmailSignatureChanged
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event.OnMessageDisplayCountChanged
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event.OnNextClicked
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event.OnShowNotificationChanged
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.State
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Validator
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.ViewModel
+
+internal class AccountOptionsViewModel(
+    private val validator: Validator,
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), ViewModel {
+
+    override fun initState(state: State) {
+        updateState {
+            state.copy()
+        }
+    }
+
+    override fun event(event: Event) {
+        when (event) {
+            is OnAccountNameChanged -> updateState { state ->
+                state.copy(
+                    accountName = state.accountName.updateValue(event.accountName),
+                )
+            }
+
+            is OnDisplayNameChanged -> updateState {
+                it.copy(
+                    displayName = it.displayName.updateValue(event.displayName),
+                )
+            }
+
+            is OnEmailSignatureChanged -> updateState {
+                it.copy(
+                    emailSignature = it.emailSignature.updateValue(event.emailSignature),
+                )
+            }
+
+            is OnCheckFrequencyChanged -> updateState {
+                it.copy(
+                    checkFrequency = event.checkFrequency,
+                )
+            }
+
+            is OnMessageDisplayCountChanged -> updateState { state ->
+                state.copy(
+                    messageDisplayCount = event.messageDisplayCount,
+                )
+            }
+
+            is OnShowNotificationChanged -> updateState { state ->
+                state.copy(
+                    showNotification = event.showNotification,
+                )
+            }
+
+            OnNextClicked -> submit()
+            OnBackClicked -> navigateBack()
+        }
+    }
+
+    private fun submit() = with(state.value) {
+        val accountNameResult = validator.validateAccountName(accountName.value)
+        val displayNameResult = validator.validateDisplayName(displayName.value)
+        val emailSignatureResult = validator.validateEmailSignature(emailSignature.value)
+
+        val hasError = listOf(
+            accountNameResult,
+            displayNameResult,
+            emailSignatureResult,
+        ).any { it is ValidationResult.Failure }
+
+        updateState {
+            it.copy(
+                accountName = it.accountName.updateFromValidationResult(accountNameResult),
+                displayName = it.displayName.updateFromValidationResult(displayNameResult),
+                emailSignature = it.emailSignature.updateFromValidationResult(emailSignatureResult),
+            )
+        }
+
+        if (!hasError) {
+            navigateNext()
+        }
+    }
+
+    private fun navigateBack() = emitEffect(Effect.NavigateBack)
+
+    private fun navigateNext() = emitEffect(Effect.NavigateNext)
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigContent.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c739253b8d9920bd4bfd27941e87c662b6088bb6
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigContent.kt
@@ -0,0 +1,179 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.requiredHeight
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.designsystem.molecule.input.CheckboxInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.NumberInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.PasswordInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.SelectInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.TextInput
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveWidthContainer
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.ui.common.item.defaultItemPadding
+import app.k9mail.feature.account.setup.ui.common.toResourceString
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.State
+import kotlinx.collections.immutable.persistentListOf
+
+@Suppress("LongMethod")
+@Composable
+internal fun AccountOutgoingConfigContent(
+    state: State,
+    onEvent: (Event) -> Unit,
+    contentPadding: PaddingValues,
+    modifier: Modifier = Modifier,
+) {
+    val resources = LocalContext.current.resources
+
+    ResponsiveWidthContainer(
+        modifier = Modifier
+            .testTag("AccountOutgoingConfigContent")
+            .padding(contentPadding)
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        LazyColumn(
+            modifier = Modifier
+                .fillMaxSize()
+                .imePadding(),
+            horizontalAlignment = Alignment.Start,
+            verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+        ) {
+            item {
+                Spacer(modifier = Modifier.requiredHeight(MainTheme.sizes.smaller))
+            }
+
+            item {
+                TextInput(
+                    text = state.server.value,
+                    errorMessage = state.server.error?.toResourceString(resources),
+                    onTextChange = { onEvent(Event.ServerChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_outgoing_config_server_label),
+                    isRequired = true,
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                SelectInput(
+                    options = ConnectionSecurity.all(),
+                    optionToStringTransformation = { it.toResourceString(resources) },
+                    selectedOption = state.security,
+                    onOptionChange = { onEvent(Event.SecurityChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_outgoing_config_security_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                NumberInput(
+                    value = state.port.value,
+                    errorMessage = state.port.error?.toResourceString(resources),
+                    onValueChange = { onEvent(Event.PortChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_outgoing_config_port_label),
+                    isRequired = true,
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                TextInput(
+                    text = state.username.value,
+                    errorMessage = state.username.error?.toResourceString(resources),
+                    onTextChange = { onEvent(Event.UsernameChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_outgoing_config_username_label),
+                    isRequired = true,
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                PasswordInput(
+                    password = state.password.value,
+                    errorMessage = state.password.error?.toResourceString(resources),
+                    onPasswordChange = { onEvent(Event.PasswordChanged(it)) },
+                    isRequired = true,
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                // TODO add client certificate support
+                SelectInput(
+                    options = persistentListOf(
+                        stringResource(
+                            id = R.string.account_setup_client_certificate_none_available,
+                        ),
+                    ),
+                    optionToStringTransformation = { it },
+                    selectedOption = stringResource(
+                        id = R.string.account_setup_client_certificate_none_available,
+                    ),
+                    onOptionChange = { onEvent(Event.ClientCertificateChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_outgoing_config_client_certificate_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                CheckboxInput(
+                    text = stringResource(id = R.string.account_setup_outgoing_config_imap_namespace_label),
+                    checked = state.imapAutodetectNamespaceEnabled,
+                    onCheckedChange = { onEvent(Event.ImapAutoDetectNamespaceChanged(it)) },
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                CheckboxInput(
+                    text = stringResource(id = R.string.account_setup_outgoing_config_compression_label),
+                    checked = state.useCompression,
+                    onCheckedChange = { onEvent(Event.UseCompressionChanged(it)) },
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+        }
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOutgoingConfigContentK9Preview() {
+    K9Theme {
+        AccountOutgoingConfigContent(
+            onEvent = { },
+            state = State(),
+            contentPadding = PaddingValues(),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOutgoingConfigContentThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountOutgoingConfigContent(
+            onEvent = { },
+            state = State(),
+            contentPadding = PaddingValues(),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigContract.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..dee148124ba2bfbdb4d7d8c694a86dea6589907f
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigContract.kt
@@ -0,0 +1,51 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.toSmtpDefaultPort
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+
+interface AccountOutgoingConfigContract {
+
+    interface ViewModel : UnidirectionalViewModel<State, Event, Effect> {
+        fun initState(state: State)
+    }
+
+    data class State(
+        val server: StringInputField = StringInputField(),
+        val security: ConnectionSecurity = ConnectionSecurity.DEFAULT,
+        val port: NumberInputField = NumberInputField(ConnectionSecurity.DEFAULT.toSmtpDefaultPort()),
+        val username: StringInputField = StringInputField(),
+        val password: StringInputField = StringInputField(),
+        val clientCertificate: String = "",
+        val imapAutodetectNamespaceEnabled: Boolean = true,
+        val useCompression: Boolean = true,
+    )
+
+    sealed class Event {
+        data class ServerChanged(val server: String) : Event()
+        data class SecurityChanged(val security: ConnectionSecurity) : Event()
+        data class PortChanged(val port: Long?) : Event()
+        data class UsernameChanged(val username: String) : Event()
+        data class PasswordChanged(val password: String) : Event()
+        data class ClientCertificateChanged(val clientCertificate: String) : Event()
+        data class ImapAutoDetectNamespaceChanged(val enabled: Boolean) : Event()
+        data class UseCompressionChanged(val useCompression: Boolean) : Event()
+        object OnNextClicked : Event()
+        object OnBackClicked : Event()
+    }
+
+    sealed class Effect {
+        object NavigateNext : Effect()
+        object NavigateBack : Effect()
+    }
+
+    interface Validator {
+        fun validateServer(server: String): ValidationResult
+        fun validatePort(port: Long?): ValidationResult
+        fun validateUsername(username: String): ValidationResult
+        fun validatePassword(password: String): ValidationResult
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3294f7c50fdcca51e724bb97c4f50647cbb72d3c
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigScreen.kt
@@ -0,0 +1,82 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.common.mvi.observe
+import app.k9mail.core.ui.compose.designsystem.template.Scaffold
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.ui.common.AccountSetupBottomBar
+import app.k9mail.feature.account.setup.ui.common.AccountSetupTopAppBar
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.ViewModel
+
+@Composable
+internal fun AccountOutgoingConfigScreen(
+    onNext: () -> Unit,
+    onBack: () -> Unit,
+    viewModel: ViewModel,
+    modifier: Modifier = Modifier,
+) {
+    val (state, dispatch) = viewModel.observe { effect ->
+        when (effect) {
+            Effect.NavigateBack -> onBack()
+            Effect.NavigateNext -> onNext()
+        }
+    }
+
+    Scaffold(
+        topBar = {
+            AccountSetupTopAppBar(
+                title = stringResource(id = R.string.account_setup_outgoing_config_top_bar_title),
+            )
+        },
+        bottomBar = {
+            AccountSetupBottomBar(
+                nextButtonText = stringResource(id = R.string.account_setup_button_next),
+                backButtonText = stringResource(id = R.string.account_setup_button_back),
+                onNextClick = { dispatch(Event.OnNextClicked) },
+                onBackClick = { dispatch(Event.OnBackClicked) },
+            )
+        },
+        modifier = modifier,
+    ) { innerPadding ->
+        AccountOutgoingConfigContent(
+            state = state.value,
+            onEvent = { dispatch(it) },
+            contentPadding = innerPadding,
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOutgoingConfigScreenK9Preview() {
+    K9Theme {
+        AccountOutgoingConfigScreen(
+            onNext = {},
+            onBack = {},
+            viewModel = AccountOutgoingConfigViewModel(
+                validator = AccountOutgoingConfigValidator(),
+            ),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOutgoingConfigScreenThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountOutgoingConfigScreen(
+            onNext = {},
+            onBack = {},
+            viewModel = AccountOutgoingConfigViewModel(
+                validator = AccountOutgoingConfigValidator(),
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigValidator.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a4c71d35e4af58d48b2f2019bf9c37788257eb24
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigValidator.kt
@@ -0,0 +1,30 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.usecase.ValidatePassword
+import app.k9mail.feature.account.setup.domain.usecase.ValidatePort
+import app.k9mail.feature.account.setup.domain.usecase.ValidateServer
+import app.k9mail.feature.account.setup.domain.usecase.ValidateUsername
+
+internal class AccountOutgoingConfigValidator(
+    private val serverValidator: ValidateServer = ValidateServer(),
+    private val portValidator: ValidatePort = ValidatePort(),
+    private val usernameValidator: ValidateUsername = ValidateUsername(),
+    private val passwordValidator: ValidatePassword = ValidatePassword(),
+) : AccountOutgoingConfigContract.Validator {
+    override fun validateServer(server: String): ValidationResult {
+        return serverValidator.execute(server)
+    }
+
+    override fun validatePort(port: Long?): ValidationResult {
+        return portValidator.execute(port)
+    }
+
+    override fun validateUsername(username: String): ValidationResult {
+        return usernameValidator.execute(username)
+    }
+
+    override fun validatePassword(password: String): ValidationResult {
+        return passwordValidator.execute(password)
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigViewModel.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3e5c4cf1e1cdc79f8e27e72bca982509c795668e
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigViewModel.kt
@@ -0,0 +1,85 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.toSmtpDefaultPort
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event.ClientCertificateChanged
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event.ImapAutoDetectNamespaceChanged
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event.OnBackClicked
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event.OnNextClicked
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event.PasswordChanged
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event.PortChanged
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event.SecurityChanged
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event.ServerChanged
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event.UseCompressionChanged
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event.UsernameChanged
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.State
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Validator
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.ViewModel
+
+internal class AccountOutgoingConfigViewModel(
+    initialState: State = State(),
+    private val validator: Validator,
+) : BaseViewModel<State, Event, Effect>(initialState), ViewModel {
+
+    override fun initState(state: State) {
+        updateState {
+            state.copy()
+        }
+    }
+
+    override fun event(event: Event) {
+        when (event) {
+            is ServerChanged -> updateState { it.copy(server = it.server.updateValue(event.server)) }
+            is SecurityChanged -> updateSecurity(event.security)
+            is PortChanged -> updateState { it.copy(port = it.port.updateValue(event.port)) }
+            is UsernameChanged -> updateState { it.copy(username = it.username.updateValue(event.username)) }
+            is PasswordChanged -> updateState { it.copy(password = it.password.updateValue(event.password)) }
+            is ClientCertificateChanged -> updateState { it.copy(clientCertificate = event.clientCertificate) }
+            is ImapAutoDetectNamespaceChanged -> updateState { it.copy(imapAutodetectNamespaceEnabled = event.enabled) }
+            is UseCompressionChanged -> updateState { it.copy(useCompression = event.useCompression) }
+
+            OnNextClicked -> submit()
+            OnBackClicked -> navigateBack()
+        }
+    }
+
+    private fun updateSecurity(security: ConnectionSecurity) {
+        updateState {
+            it.copy(
+                security = security,
+                port = it.port.updateValue(security.toSmtpDefaultPort()),
+            )
+        }
+    }
+
+    private fun submit() = with(state.value) {
+        val serverResult = validator.validateServer(server.value)
+        val portResult = validator.validatePort(port.value)
+        val usernameResult = validator.validateUsername(username.value)
+        val passwordResult = validator.validatePassword(password.value)
+
+        val hasError = listOf(serverResult, portResult, usernameResult, passwordResult)
+            .any { it is ValidationResult.Failure }
+
+        updateState {
+            it.copy(
+                server = it.server.updateFromValidationResult(serverResult),
+                port = it.port.updateFromValidationResult(portResult),
+                username = it.username.updateFromValidationResult(usernameResult),
+                password = it.password.updateFromValidationResult(passwordResult),
+            )
+        }
+
+        if (!hasError) {
+            navigateNext()
+        }
+    }
+
+    private fun navigateBack() = emitEffect(Effect.NavigateBack)
+
+    private fun navigateNext() = emitEffect(Effect.NavigateNext)
+}
diff --git a/feature/account/setup/src/main/res/values/plurals.xml b/feature/account/setup/src/main/res/values/plurals.xml
new file mode 100644
index 0000000000000000000000000000000000000000..2eb78563a6051604deee389c2746aba9c06b7286
--- /dev/null
+++ b/feature/account/setup/src/main/res/values/plurals.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <plurals name="account_setup_options_email_check_frequency_minutes">
+        <item quantity="one">Every minute</item>
+        <item quantity="other">Every %d minutes</item>
+    </plurals>
+    <plurals name="account_setup_options_email_check_frequency_hours">
+        <item quantity="one">Every hour</item>
+        <item quantity="other">Every %d hours</item>
+    </plurals>
+    <plurals name="account_setup_options_email_display_count_messages">
+        <item quantity="one">1 message</item>
+        <item quantity="other">%d messages</item>
+    </plurals>
+</resources>
diff --git a/feature/account/setup/src/main/res/values/strings.xml b/feature/account/setup/src/main/res/values/strings.xml
index ae5657699238bed0b404f93fc4fbad3b828daed7..7ec47e7f7f44c78ab63dcedc3660157c2fde0741 100644
--- a/feature/account/setup/src/main/res/values/strings.xml
+++ b/feature/account/setup/src/main/res/values/strings.xml
@@ -4,4 +4,63 @@
     <string name="account_setup_button_next">Next</string>
     <string name="account_setup_button_back">Back</string>
     <string name="account_setup_button_finish">Finish</string>
+    <string name="account_setup_connection_security_none">None</string>
+    <string name="account_setup_connection_security_ssl">SSL/TLS</string>
+    <string name="account_setup_connection_security_start_tls">StartTLS</string>
+    <string name="account_setup_client_certificate_none_available">None available</string>
+
+    <string name="account_setup_error_network">Network </string>
+    <string name="account_setup_error_unknown">Unknown error</string>
+
+    <string name="account_setup_validation_error_email_address_required">Email address is required.</string>
+    <string name="account_setup_validation_error_email_address_invalid">Email address is invalid.</string>
+    <string name="account_setup_validation_error_server_required">Server name is required.</string>
+    <string name="account_setup_validation_error_port_required">Port is required.</string>
+    <string name="account_setup_validation_error_port_invalid">Port is invalid (must be 1–65535).</string>
+    <string name="account_setup_validation_error_username_required">Username is required.</string>
+    <string name="account_setup_validation_error_password_required">Password is required.</string>
+    <string name="account_setup_validation_error_imap_prefix_blank">Imap prefix can\'t be blank.</string>
+
+    <string name="account_setup_auto_config_loading_message">Finding email details</string>
+    <string name="account_setup_auto_config_loading_error">Failed to load email configuration</string>
+    <string name="account_setup_auto_config_status_header_title_configuration_found">Configuration Found</string>
+    <string name="account_setup_auto_config_status_header_title_configuration_not_found">Configuration Not Found</string>
+    <string name="account_setup_auto_config_status_header_subtitle_configuration_trusted">Configure automatically</string>
+    <string name="account_setup_auto_config_status_header_subtitle_configuration_untrusted">This configuration is not trusted</string>
+    <string name="account_setup_auto_config_status_disclaimer_untrusted_configuration">We received the configuration for your email server over a connection that isn\'t as secure as we\'d like. This means that there is a tiny chance that someone could have altered it. Could you please double-check the provided configuration to make sure it\'s as it should be?</string>
+    <string name="account_setup_auto_config_status_header_subtitle_configuration_not_found">Configure manually</string>
+    <string name="account_setup_auto_config_status_edit_configuration_button_label">Edit configuration</string>
+    <string name="account_setup_auto_config_status_checkbox_configuration_untrusted_confirmation_label">I trust this configuration</string>
+    <string name="account_setup_error_configuration_approval_required">It is required to approve the configuration.</string>
+
+    <string name="account_setup_incoming_config_top_bar_title">Incoming server settings</string>
+    <string name="account_setup_incoming_config_protocol_type_label">Protocol</string>
+    <string name="account_setup_incoming_config_server_label">Server</string>
+    <string name="account_setup_incoming_config_security_label">Security</string>
+    <string name="account_setup_incoming_config_imap_namespace_label">Auto-detect IMAP namespace</string>
+    <string name="account_setup_incoming_config_imap_prefix_label">IMAP path prefix</string>
+    <string name="account_setup_incoming_config_compression_label">Use compression</string>
+
+    <string name="account_setup_outgoing_config_top_bar_title">Outgoing server settings</string>
+    <string name="account_setup_outgoing_config_server_label">Server</string>
+    <string name="account_setup_outgoing_config_security_label">Security</string>
+    <string name="account_setup_outgoing_config_port_label">Port</string>
+    <string name="account_setup_outgoing_config_username_label">Username</string>
+    <string name="account_setup_outgoing_config_client_certificate_label">Client certificate</string>
+    <string name="account_setup_outgoing_config_imap_namespace_label">Auto-detect IMAP namespace</string>
+    <string name="account_setup_outgoing_config_compression_label">Use compression</string>
+
+    <string name="account_setup_options_top_bar_title">Account options</string>
+    <string name="account_setup_options_section_display_options">Display options</string>
+    <string name="account_setup_options_account_name_label">Account name</string>
+    <string name="account_setup_options_account_name_error_blank">Account name can\'t be blank.</string>
+    <string name="account_setup_options_display_name_label">Display name</string>
+    <string name="account_setup_options_display_name_error_required">Display name is required.</string>
+    <string name="account_setup_options_email_signature_label">Email signature</string>
+    <string name="account_setup_options_email_signature_error_blank">Email signature name can\'t be blank.</string>
+    <string name="account_setup_options_section_sync_options_">Sync options</string>
+    <string name="account_setup_options_account_check_frequency_label">Check frequency</string>
+    <string name="account_setup_options_email_check_frequency_never">Never</string>
+    <string name="account_setup_options_email_display_count_label">Number of messages to display</string>
+    <string name="account_setup_options_show_notifications_label">Show notifications</string>
 </resources>
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/AccountSetupModuleKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/AccountSetupModuleKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1d5ec8898b8d28a2e368b845cb921863573de3a2
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/AccountSetupModuleKtTest.kt
@@ -0,0 +1,47 @@
+package app.k9mail.feature.account.setup
+
+import app.k9mail.feature.account.setup.ui.AccountSetupContract
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract
+import okhttp3.OkHttpClient
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.koin.android.ext.koin.androidContext
+import org.koin.core.annotation.KoinExperimentalAPI
+import org.koin.dsl.koinApplication
+import org.koin.dsl.module
+import org.koin.test.KoinTest
+import org.koin.test.check.checkModules
+import org.koin.test.verify.verify
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@OptIn(KoinExperimentalAPI::class)
+@RunWith(RobolectricTestRunner::class)
+class AccountSetupModuleKtTest : KoinTest {
+
+    private val networkModule = module {
+        single<OkHttpClient> { OkHttpClient() }
+    }
+
+    @Test
+    fun `should have a valid di module`() {
+        featureAccountSetupModule.verify(
+            extraTypes = listOf(
+                AccountSetupContract.State::class,
+                AccountAutoDiscoveryContract.State::class,
+                AccountIncomingConfigContract.State::class,
+                AccountOutgoingConfigContract.State::class,
+                AccountOptionsContract.State::class,
+            ),
+        )
+
+        koinApplication {
+            modules(networkModule, featureAccountSetupModule)
+            androidContext(RuntimeEnvironment.getApplication())
+            checkModules()
+        }
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoverySettingsFixture.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoverySettingsFixture.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e6ebb6e4370071a37c202166f06c3bf772be8e34
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoverySettingsFixture.kt
@@ -0,0 +1,30 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import app.k9mail.autodiscovery.api.AuthenticationType
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.ConnectionSecurity
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+
+object AutoDiscoverySettingsFixture {
+
+    val settings = AutoDiscoveryResult.Settings(
+        incomingServerSettings = ImapServerSettings(
+            hostname = "incoming.example.com".toHostname(),
+            port = 123.toPort(),
+            connectionSecurity = ConnectionSecurity.TLS,
+            authenticationType = AuthenticationType.PasswordEncrypted,
+            username = "incoming_username",
+        ),
+        outgoingServerSettings = SmtpServerSettings(
+            hostname = "outgoing.example.com".toHostname(),
+            port = 456.toPort(),
+            connectionSecurity = ConnectionSecurity.TLS,
+            authenticationType = AuthenticationType.PasswordEncrypted,
+            username = "outgoing_username",
+        ),
+        isTrusted = true,
+    )
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/ConnectionSecurityTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/ConnectionSecurityTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4cd388642222e7884ea110d8792d917edbf95ce9
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/ConnectionSecurityTest.kt
@@ -0,0 +1,59 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class ConnectionSecurityTest {
+
+    @Test
+    fun `should provide right default smtp port`() {
+        val connectionSecurities = ConnectionSecurity.all()
+
+        for (security in connectionSecurities) {
+            val port = security.toSmtpDefaultPort()
+
+            assertThat(port).isEqualTo(
+                when (security) {
+                    ConnectionSecurity.None -> 587L
+                    ConnectionSecurity.StartTLS -> 587L
+                    ConnectionSecurity.TLS -> 465L
+                },
+            )
+        }
+    }
+
+    @Test
+    fun `should provide right default imap port`() {
+        val connectionSecurities = ConnectionSecurity.all()
+
+        for (security in connectionSecurities) {
+            val port = security.toImapDefaultPort()
+
+            assertThat(port).isEqualTo(
+                when (security) {
+                    ConnectionSecurity.None -> 143L
+                    ConnectionSecurity.StartTLS -> 143L
+                    ConnectionSecurity.TLS -> 993L
+                },
+            )
+        }
+    }
+
+    @Test
+    fun `should provide right default pop3 port`() {
+        val connectionSecurities = ConnectionSecurity.all()
+
+        for (security in connectionSecurities) {
+            val port = security.toPop3DefaultPort()
+
+            assertThat(port).isEqualTo(
+                when (security) {
+                    ConnectionSecurity.None -> 110L
+                    ConnectionSecurity.StartTLS -> 110L
+                    ConnectionSecurity.TLS -> 995L
+                },
+            )
+        }
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingProtocolTypeTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingProtocolTypeTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b5220ff4ba208b0c621816cb7ff91602b6a1ab77
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingProtocolTypeTest.kt
@@ -0,0 +1,43 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class IncomingProtocolTypeTest {
+
+    @Test
+    fun `all should contain all protocol types`() {
+        val protocolTypes = IncomingProtocolType.all()
+
+        assertThat(protocolTypes).isEqualTo(
+            IncomingProtocolType.values().toList(),
+        )
+    }
+
+    @Test
+    fun `defaultConnectionSecurity should provide right default connection security`() {
+        val protocolTypeToConnectionSecurity = IncomingProtocolType.all()
+            .associateWith { it.defaultConnectionSecurity }
+
+        assertThat(protocolTypeToConnectionSecurity).isEqualTo(
+            mapOf(
+                IncomingProtocolType.IMAP to ConnectionSecurity.TLS,
+                IncomingProtocolType.POP3 to ConnectionSecurity.TLS,
+            ),
+        )
+    }
+
+    @Test
+    fun `should provide right default port`() {
+        val protocolTypeToPort = IncomingProtocolType.all()
+            .associateWith { it.toDefaultPort(it.defaultConnectionSecurity) }
+
+        assertThat(protocolTypeToPort).isEqualTo(
+            mapOf(
+                IncomingProtocolType.IMAP to 993L,
+                IncomingProtocolType.POP3 to 995L,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/OutgoingProtocolTypeTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/OutgoingProtocolTypeTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..33afc43d1ad325bef557344232b9a7ba9aa32658
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/OutgoingProtocolTypeTest.kt
@@ -0,0 +1,40 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class OutgoingProtocolTypeTest {
+
+    @Test
+    fun `all should contain all protocol types`() {
+        val protocolTypes = OutgoingProtocolType.all()
+
+        assertThat(protocolTypes).isEqualTo(
+            OutgoingProtocolType.values().toList(),
+        )
+    }
+
+    @Test
+    fun `defaultConnectionSecurity should provide right default connection security`() {
+        val protocolTypeToConnectionSecurity = OutgoingProtocolType.all().associateWith { it.defaultConnectionSecurity }
+
+        assertThat(protocolTypeToConnectionSecurity).isEqualTo(
+            mapOf(
+                OutgoingProtocolType.SMTP to ConnectionSecurity.TLS,
+            ),
+        )
+    }
+
+    @Test
+    fun `should provide right default port`() {
+        val protocolTypeToPort = OutgoingProtocolType.all()
+            .associateWith { it.toDefaultPort(it.defaultConnectionSecurity) }
+
+        assertThat(protocolTypeToPort).isEqualTo(
+            mapOf(
+                OutgoingProtocolType.SMTP to 465L,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/input/InputFieldTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/input/InputFieldTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..af3ae423eaa2e89040cd87d07ec7f18c70093887
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/input/InputFieldTest.kt
@@ -0,0 +1,261 @@
+package app.k9mail.feature.account.setup.domain.input
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import assertk.Assert
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
+import assertk.assertions.isNotSameAs
+import assertk.assertions.isNull
+import assertk.assertions.isSameAs
+import assertk.assertions.isTrue
+import assertk.assertions.prop
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+
+data class InputFieldTestData<T>(
+    val name: String,
+    val initialState: InputField<T>,
+    val initialValue: T,
+    val initialValueEmpty: T,
+    val initialError: ValidationError?,
+    val initialIsValid: Boolean,
+    val createInitialInput: (value: T, error: ValidationError?, isValid: Boolean) -> InputField<T>,
+    val updatedValue: T,
+)
+
+@RunWith(Parameterized::class)
+class InputFieldTest(
+    private val data: InputFieldTestData<Any>,
+) {
+
+    @Test
+    fun `should set default values`() {
+        assertThat(data.initialState).all {
+            hasValue(data.initialValueEmpty)
+            hasNoError()
+            isNotValid()
+        }
+    }
+
+    @Test
+    fun `should reset error and isValid when value changed`() {
+        val initialInput = data.createInitialInput(
+            data.initialValue,
+            TestValidationError,
+            true,
+        )
+
+        val result = initialInput.updateValue(data.updatedValue)
+
+        assertThat(result).all {
+            isNotSameAs(initialInput)
+            hasValue(data.updatedValue)
+            hasNoError()
+            isNotValid()
+        }
+    }
+
+    @Test
+    fun `should reset isValid when error set`() {
+        val initialInput = data.createInitialInput(
+            data.initialValue,
+            null,
+            true,
+        )
+
+        val result = initialInput.updateError(TestValidationError)
+
+        assertThat(result).all {
+            isNotSameAs(initialInput)
+            hasValue(data.initialValue)
+            hasError(TestValidationError)
+            isNotValid()
+        }
+    }
+
+    @Test
+    fun `should reset error when valid`() {
+        val initialInput = data.createInitialInput(
+            data.initialValue,
+            TestValidationError,
+            false,
+        )
+
+        val result = initialInput.updateValidity(isValid = true)
+
+        assertThat(result).all {
+            isNotSameAs(initialInput)
+            hasValue(data.initialValue)
+            hasNoError()
+            isValid()
+        }
+    }
+
+    @Test
+    fun `should not reset error when invalid`() {
+        val initialInput = data.createInitialInput(
+            data.initialValue,
+            TestValidationError,
+            false,
+        )
+
+        val result = initialInput.updateValidity(isValid = false)
+
+        assertThat(result).all {
+            isSameAs(initialInput)
+            hasValue(data.initialValue)
+            hasError(TestValidationError)
+            isNotValid()
+        }
+    }
+
+    @Test
+    fun `should change error when error changed`() {
+        val initialInput = data.createInitialInput(
+            data.initialValue,
+            TestValidationError,
+            false,
+        )
+
+        val result = initialInput.updateError(TestValidationError2)
+
+        assertThat(result).all {
+            isNotSameAs(initialInput)
+            hasValue(data.initialValue)
+            hasError(TestValidationError2)
+            isNotValid()
+        }
+    }
+
+    @Test
+    fun `should map from success ValidationResult`() {
+        val initialInput = data.createInitialInput(
+            data.initialValue,
+            TestValidationError,
+            false,
+        )
+
+        val result = initialInput.updateFromValidationResult(ValidationResult.Success)
+
+        assertThat(result).all {
+            isNotSameAs(initialInput)
+            hasValue(data.initialValue)
+            hasNoError()
+            isValid()
+        }
+    }
+
+    @Test
+    fun `should map from failure ValidationResult`() {
+        val initialInput = data.createInitialInput(
+            data.initialValue,
+            null,
+            true,
+        )
+
+        val result = initialInput.updateFromValidationResult(ValidationResult.Failure(TestValidationError))
+
+        assertThat(result).all {
+            isNotSameAs(initialInput)
+            hasValue(data.initialValue)
+            hasError(TestValidationError)
+            isNotValid()
+        }
+    }
+
+    @Test
+    fun `should decide equality on properties`() {
+        val input1 = data.createInitialInput(
+            data.initialValue,
+            data.initialError,
+            data.initialIsValid,
+        )
+        val input2 = data.createInitialInput(
+            data.initialValue,
+            data.initialError,
+            data.initialIsValid,
+        )
+
+        assertThat(input1.equals(input2)).isTrue()
+    }
+
+    @Test
+    fun `should have same hashCode`() {
+        val input1 = data.createInitialInput(
+            data.initialValue,
+            data.initialError,
+            data.initialIsValid,
+        )
+        val input2 = data.createInitialInput(
+            data.initialValue,
+            data.initialError,
+            data.initialIsValid,
+        )
+
+        assertThat(input1.hashCode()).isEqualTo(input2.hashCode())
+    }
+
+    private fun Assert<InputField<Any>>.hasValue(value: Any) {
+        prop("value") { InputField<*>::value.call(it) }.isEqualTo(value)
+    }
+
+    private fun Assert<InputField<Any>>.hasError(error: ValidationError) {
+        prop("error") { InputField<*>::error.call(it) }.isEqualTo(error)
+    }
+
+    private fun Assert<InputField<Any>>.hasNoError() {
+        prop("error") { InputField<*>::error.call(it) }.isNull()
+    }
+
+    private fun Assert<InputField<Any>>.isValid() {
+        prop("isValid") { InputField<*>::isValid.call(it) }.isTrue()
+    }
+
+    private fun Assert<InputField<Any>>.isNotValid() {
+        prop("isValid") { InputField<*>::isValid.call(it) }.isFalse()
+    }
+
+    companion object {
+        @JvmStatic
+        @Parameterized.Parameters(name = "{0}")
+        fun data(): List<InputFieldTestData<*>> = listOf(
+            InputFieldTestData(
+                name = "StringInputField",
+                createInitialInput = { value, error, isValid -> StringInputField(value, error, isValid) },
+                initialState = StringInputField(),
+                initialValue = "input",
+                initialValueEmpty = "",
+                initialError = null,
+                initialIsValid = false,
+                updatedValue = "new value",
+            ),
+            InputFieldTestData(
+                name = "NumberInputField",
+                createInitialInput = { value, error, isValid -> NumberInputField(value, error, isValid) },
+                initialState = NumberInputField(),
+                initialValue = 123L,
+                initialValueEmpty = null,
+                initialError = null,
+                initialIsValid = false,
+                updatedValue = 456L,
+            ),
+            InputFieldTestData(
+                name = "BooleanInputField",
+                createInitialInput = { value, error, isValid -> BooleanInputField(value, error, isValid) },
+                initialState = BooleanInputField(),
+                initialValue = true,
+                initialValueEmpty = null,
+                initialError = null,
+                initialIsValid = false,
+                updatedValue = false,
+            ),
+        )
+    }
+
+    private object TestValidationError : ValidationError
+    private object TestValidationError2 : ValidationError
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateAccountNameTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateAccountNameTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d38338b1e6f63c4ddc9876e5b17b5943980179dd
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateAccountNameTest.kt
@@ -0,0 +1,36 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.usecase.ValidateAccountName.ValidateAccountNameError
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidateAccountNameTest {
+
+    private val testSubject = ValidateAccountName()
+
+    @Test
+    fun `should succeed when account name is set`() {
+        val result = testSubject.execute("account name")
+
+        assertThat(result).isInstanceOf(ValidationResult.Success::class)
+    }
+
+    @Test
+    fun `should succeed when account name is empty`() {
+        val result = testSubject.execute("")
+
+        assertThat(result).isInstanceOf(ValidationResult.Success::class)
+    }
+
+    @Test
+    fun `should fail when account name is blank`() {
+        val result = testSubject.execute(" ")
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidateAccountNameError.BlankAccountName::class)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateConfigurationApprovalTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateConfigurationApprovalTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3a3badb6d01178b69f158c048f7dab2c54d7d1eb
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateConfigurationApprovalTest.kt
@@ -0,0 +1,76 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidateConfigurationApprovalTest {
+
+    private val testSubject = ValidateConfigurationApproval()
+
+    @Test
+    fun `should succeed when auto discovery is approved and trusted`() {
+        val result = testSubject.execute(isApproved = true, isAutoDiscoveryTrusted = true)
+
+        assertThat(result).isInstanceOf(ValidationResult.Success::class)
+    }
+
+    @Test
+    fun `should succeed when auto discovery not approved but is trusted`() {
+        val result = testSubject.execute(isApproved = false, isAutoDiscoveryTrusted = true)
+
+        assertThat(result).isInstanceOf(ValidationResult.Success::class)
+    }
+
+    @Test
+    fun `should succeed when auto discovery is approved but not trusted`() {
+        val result = testSubject.execute(isApproved = true, isAutoDiscoveryTrusted = false)
+
+        assertThat(result).isInstanceOf(ValidationResult.Success::class)
+    }
+
+    @Test
+    fun `should fail when auto discovery is not approved and not trusted`() {
+        val result = testSubject.execute(isApproved = false, isAutoDiscoveryTrusted = false)
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidateConfigurationApproval.ValidateConfigurationApprovalError.ApprovalRequired::class)
+    }
+
+    @Test
+    fun `should succeed when auto discovery isApproved null and is trusted`() {
+        val result = testSubject.execute(isApproved = null, isAutoDiscoveryTrusted = true)
+
+        assertThat(result).isInstanceOf(ValidationResult.Success::class)
+    }
+
+    @Test
+    fun `should fail when auto discovery is isApproved null and is not trusted`() {
+        val result = testSubject.execute(isApproved = null, isAutoDiscoveryTrusted = false)
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidateConfigurationApproval.ValidateConfigurationApprovalError.ApprovalRequired::class)
+    }
+
+    @Test
+    fun `should fail when auto discovery is approved and trusted is null`() {
+        val result = testSubject.execute(isApproved = false, isAutoDiscoveryTrusted = null)
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidateConfigurationApproval.ValidateConfigurationApprovalError.ApprovalRequired::class)
+    }
+
+    @Test
+    fun `should fail when auto discovery is not approved and trusted is null`() {
+        val result = testSubject.execute(isApproved = false, isAutoDiscoveryTrusted = null)
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidateConfigurationApproval.ValidateConfigurationApprovalError.ApprovalRequired::class)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateDisplayNameTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateDisplayNameTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5722ee01bd7d4c82cc34c4c208cc5c59fb9a3619
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateDisplayNameTest.kt
@@ -0,0 +1,38 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.usecase.ValidateDisplayName.ValidateDisplayNameError
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidateDisplayNameTest {
+
+    private val testSubject = ValidateDisplayName()
+
+    @Test
+    fun `should succeed when display name is set`() {
+        val result = testSubject.execute("display name")
+
+        assertThat(result).isInstanceOf(ValidationResult.Success::class)
+    }
+
+    @Test
+    fun `should fail when display name is empty`() {
+        val result = testSubject.execute("")
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidateDisplayNameError.EmptyDisplayName::class)
+    }
+
+    @Test
+    fun `should fail when display name is blank`() {
+        val result = testSubject.execute(" ")
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidateDisplayNameError.EmptyDisplayName::class)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailAddressTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailAddressTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e5ccc3a028303341716971e1eb95f940a3c08c1c
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailAddressTest.kt
@@ -0,0 +1,38 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.usecase.ValidateEmailAddress.ValidateEmailAddressError
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidateEmailAddressTest {
+
+    private val testSubject = ValidateEmailAddress()
+
+    @Test
+    fun `should succeed when email address is valid`() {
+        val result = testSubject.execute("test@example.com")
+
+        assertThat(result).isInstanceOf(ValidationResult.Success::class)
+    }
+
+    @Test
+    fun `should fail when email address is blank`() {
+        val result = testSubject.execute(" ")
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidateEmailAddressError.EmptyEmailAddress::class)
+    }
+
+    @Test
+    fun `should fail when email address is invalid`() {
+        val result = testSubject.execute("test")
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidateEmailAddressError.InvalidEmailAddress::class)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailSignatureTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailSignatureTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..abde66219fc9328b66fdcbb7e92d7fa159b88da8
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailSignatureTest.kt
@@ -0,0 +1,36 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.usecase.ValidateEmailSignature.ValidateEmailSignatureError
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidateEmailSignatureTest {
+
+    private val testSubject = ValidateEmailSignature()
+
+    @Test
+    fun `should succeed when email signature is set`() {
+        val result = testSubject.execute("email signature")
+
+        assertThat(result).isInstanceOf(ValidationResult.Success::class)
+    }
+
+    @Test
+    fun `should succeed when email signature is empty`() {
+        val result = testSubject.execute("")
+
+        assertThat(result).isInstanceOf(ValidationResult.Success::class)
+    }
+
+    @Test
+    fun `should fail when email signature is blank`() {
+        val result = testSubject.execute(" ")
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidateEmailSignatureError.BlankEmailSignature::class)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateImapPrefixTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateImapPrefixTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..853740792dc7405cec521c46c242d2c39f571434
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateImapPrefixTest.kt
@@ -0,0 +1,35 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidateImapPrefixTest {
+
+    private val testSubject = ValidateImapPrefix()
+
+    @Test
+    fun `should success when imap prefix is set`() {
+        val result = testSubject.execute("imap")
+
+        assertThat(result).isInstanceOf(ValidationResult.Success::class)
+    }
+
+    @Test
+    fun `should succeed when imap prefix is empty`() {
+        val result = testSubject.execute("")
+
+        assertThat(result).isInstanceOf(ValidationResult.Success::class)
+    }
+
+    @Test
+    fun `should fail when imap prefix is blank`() {
+        val result = testSubject.execute(" ")
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidateImapPrefix.ValidateImapPrefixError.BlankImapPrefix::class)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePasswordTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePasswordTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..55da945ba1f5a209f00969eddc63d0ac47bee1dd
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePasswordTest.kt
@@ -0,0 +1,37 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidatePasswordTest {
+
+    private val testSubject = ValidatePassword()
+
+    @Test
+    fun `should succeed when password is set`() {
+        val result = testSubject.execute("password")
+
+        assertThat(result).isInstanceOf(ValidationResult.Success::class)
+    }
+
+    @Test
+    fun `should fail when password is empty`() {
+        val result = testSubject.execute("")
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidatePassword.ValidatePasswordError.EmptyPassword::class)
+    }
+
+    @Test
+    fun `should fail when password is blank`() {
+        val result = testSubject.execute(" ")
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidatePassword.ValidatePasswordError.EmptyPassword::class)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePortTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePortTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4d80a8268d0b1164ecd03580c5ee4f5d21e47973
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePortTest.kt
@@ -0,0 +1,56 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.usecase.ValidatePort.ValidatePortError
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidatePortTest {
+
+    private val testSubject = ValidatePort()
+
+    @Test
+    fun `should succeed when port is set`() {
+        val result = testSubject.execute(123L)
+
+        assertThat(result).isInstanceOf(ValidationResult.Success::class)
+    }
+
+    @Test
+    fun `should fail when port is negative`() {
+        val result = testSubject.execute(-1L)
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidatePortError.InvalidPort::class)
+    }
+
+    @Test
+    fun `should fail when port is zero`() {
+        val result = testSubject.execute(0)
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidatePortError.InvalidPort::class)
+    }
+
+    @Test
+    fun `should fail when port exceeds maximum`() {
+        val result = testSubject.execute(65536L)
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidatePortError.InvalidPort::class)
+    }
+
+    @Test
+    fun `should fail when port is null`() {
+        val result = testSubject.execute(null)
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidatePortError.EmptyPort::class)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServerTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServerTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d65ea146e27739cc2be72c010cf341a03862c0ce
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServerTest.kt
@@ -0,0 +1,37 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidateServerTest {
+
+    private val testSubject = ValidateServer()
+
+    @Test
+    fun `should succeed when server is set`() {
+        val result = testSubject.execute("server")
+
+        assertThat(result).isInstanceOf(ValidationResult.Success::class)
+    }
+
+    @Test
+    fun `should fail when server is empty`() {
+        val result = testSubject.execute("")
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidateServer.ValidateServerError.EmptyServer::class)
+    }
+
+    @Test
+    fun `should fail when server is blank`() {
+        val result = testSubject.execute(" ")
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidateServer.ValidateServerError.EmptyServer::class)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateUsernameTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateUsernameTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..026763213ec1a7e7f2ed8b2b50a24ff4ad821658
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateUsernameTest.kt
@@ -0,0 +1,37 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidateUsernameTest {
+
+    private val testSubject = ValidateUsername()
+
+    @Test
+    fun `should succeed when username is set`() {
+        val result = testSubject.execute("username")
+
+        assertThat(result).isInstanceOf(ValidationResult.Success::class)
+    }
+
+    @Test
+    fun `should fail when username is empty`() {
+        val result = testSubject.execute("")
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidateUsername.ValidateUsernameError.EmptyUsername::class)
+    }
+
+    @Test
+    fun `should fail when username is blank`() {
+        val result = testSubject.execute(" ")
+
+        assertThat(result).isInstanceOf(ValidationResult.Failure::class)
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf(ValidateUsername.ValidateUsernameError.EmptyUsername::class)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/testing/EventStateTestUtil.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/testing/EventStateTestUtil.kt
new file mode 100644
index 0000000000000000000000000000000000000000..df39fb006cecd787465e5f1f620ae3d895cf58eb
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/testing/EventStateTestUtil.kt
@@ -0,0 +1,35 @@
+package app.k9mail.feature.account.setup.testing
+
+import app.cash.turbine.testIn
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+import assertk.assertions.assertThatAndTurbinesConsumed
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.CoroutineScope
+
+internal suspend fun <STATE, EVENT, EFFECT> eventStateTest(
+    viewModel: UnidirectionalViewModel<STATE, EVENT, EFFECT>,
+    initialState: STATE,
+    event: EVENT,
+    expectedState: STATE,
+    coroutineScope: CoroutineScope,
+) {
+    val stateTurbine = viewModel.state.testIn(coroutineScope)
+    val effectTurbine = viewModel.effect.testIn(coroutineScope)
+    val turbines = listOf(stateTurbine, effectTurbine)
+
+    assertThatAndTurbinesConsumed(
+        actual = stateTurbine.awaitItem(),
+        turbines = turbines,
+    ) {
+        isEqualTo(initialState)
+    }
+
+    viewModel.event(event)
+
+    assertThatAndTurbinesConsumed(
+        actual = stateTurbine.awaitItem(),
+        turbines = turbines,
+    ) {
+        isEqualTo(expectedState)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupScreenKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupScreenKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..389db795e7af551c99b492bc6134b842c864811c
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupScreenKtTest.kt
@@ -0,0 +1,96 @@
+package app.k9mail.feature.account.setup.ui
+
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import app.k9mail.core.ui.compose.testing.onNodeWithTag
+import app.k9mail.core.ui.compose.testing.setContent
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Effect
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.SetupStep
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.State
+import app.k9mail.feature.account.setup.ui.autodiscovery.FakeAccountAutoDiscoveryViewModel
+import app.k9mail.feature.account.setup.ui.incoming.FakeAccountIncomingConfigViewModel
+import app.k9mail.feature.account.setup.ui.options.FakeAccountOptionsViewModel
+import app.k9mail.feature.account.setup.ui.outgoing.FakeAccountOutgoingConfigViewModel
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class AccountSetupScreenKtTest : ComposeTest() {
+
+    @Test
+    fun `should display correct screen for every setup step`() = runTest {
+        val viewModel = FakeAccountSetupViewModel()
+        val autoDiscoveryViewModel = FakeAccountAutoDiscoveryViewModel()
+        val incomingViewModel = FakeAccountIncomingConfigViewModel()
+        val outgoingViewModel = FakeAccountOutgoingConfigViewModel()
+        val optionsViewModel = FakeAccountOptionsViewModel()
+
+        setContent {
+            ThunderbirdTheme {
+                AccountSetupScreen(
+                    onFinish = { },
+                    onBack = { },
+                    viewModel = viewModel,
+                    autoDiscoveryViewModel = autoDiscoveryViewModel,
+                    incomingViewModel = incomingViewModel,
+                    outgoingViewModel = outgoingViewModel,
+                    optionsViewModel = optionsViewModel,
+                )
+            }
+        }
+
+        for (step in SetupStep.values()) {
+            viewModel.state { it.copy(setupStep = step) }
+            onNodeWithTag(getTagForStep(step)).assertExists()
+        }
+    }
+
+    @Test
+    fun `should delegate navigation effects`() = runTest {
+        val initialState = State()
+        val viewModel = FakeAccountSetupViewModel(initialState)
+        val autoDiscoveryViewModel = FakeAccountAutoDiscoveryViewModel()
+        val incomingViewModel = FakeAccountIncomingConfigViewModel()
+        val outgoingViewModel = FakeAccountOutgoingConfigViewModel()
+        val optionsViewModel = FakeAccountOptionsViewModel()
+        var onFinishCounter = 0
+        var onBackCounter = 0
+
+        setContent {
+            ThunderbirdTheme {
+                AccountSetupScreen(
+                    onFinish = { onFinishCounter++ },
+                    onBack = { onBackCounter++ },
+                    viewModel = viewModel,
+                    autoDiscoveryViewModel = autoDiscoveryViewModel,
+                    incomingViewModel = incomingViewModel,
+                    outgoingViewModel = outgoingViewModel,
+                    optionsViewModel = optionsViewModel,
+                )
+            }
+        }
+
+        assertThat(onFinishCounter).isEqualTo(0)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateNext)
+
+        assertThat(onFinishCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateBack)
+
+        assertThat(onFinishCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(1)
+    }
+
+    private fun getTagForStep(step: SetupStep): String = when (step) {
+        SetupStep.AUTO_CONFIG -> "AccountAutoDiscoveryContent"
+        SetupStep.INCOMING_CONFIG -> "AccountIncomingConfigContent"
+        SetupStep.OUTGOING_CONFIG -> "AccountOutgoingConfigContent"
+        SetupStep.OPTIONS -> "AccountOptionsContent"
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupStateTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupStateTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c1763c34c6166c417d271719d73bac2b75299457
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupStateTest.kt
@@ -0,0 +1,20 @@
+package app.k9mail.feature.account.setup.ui
+
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.State
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.prop
+import org.junit.Test
+
+class AccountSetupStateTest {
+
+    @Test
+    fun `should set default values`() {
+        val state = State()
+
+        assertThat(state).all {
+            prop(State::setupStep).isEqualTo(AccountSetupContract.SetupStep.AUTO_CONFIG)
+        }
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupViewModelTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupViewModelTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e245e1ca0ca9606e7e3a1807316b54ee8f5e9304
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupViewModelTest.kt
@@ -0,0 +1,127 @@
+package app.k9mail.feature.account.setup.ui
+
+import app.cash.turbine.testIn
+import app.k9mail.core.ui.compose.testing.MainDispatcherRule
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Effect.NavigateBack
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Effect.NavigateNext
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.SetupStep
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.State
+import assertk.assertions.assertThatAndTurbinesConsumed
+import assertk.assertions.isEqualTo
+import assertk.assertions.prop
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class AccountSetupViewModelTest {
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    @Test
+    fun `should forward step state on next event`() = runTest {
+        val viewModel = AccountSetupViewModel()
+        val stateTurbine = viewModel.state.testIn(backgroundScope)
+        val effectTurbine = viewModel.effect.testIn(backgroundScope)
+        val turbines = listOf(stateTurbine, effectTurbine)
+
+        // Initial state
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.AUTO_CONFIG)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnNext)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.INCOMING_CONFIG)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnNext)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.OUTGOING_CONFIG)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnNext)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.OPTIONS)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnNext)
+
+        assertThatAndTurbinesConsumed(
+            actual = effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(NavigateNext)
+        }
+    }
+
+    @Test
+    fun `should rewind step state on back event`() = runTest {
+        val initialState = State(setupStep = SetupStep.OPTIONS)
+        val viewModel = AccountSetupViewModel(initialState)
+        val stateTurbine = viewModel.state.testIn(backgroundScope)
+        val effectTurbine = viewModel.effect.testIn(backgroundScope)
+        val turbines = listOf(stateTurbine, effectTurbine)
+
+        // Initial state
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.OPTIONS)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnBack)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.OUTGOING_CONFIG)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnBack)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.INCOMING_CONFIG)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnBack)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.AUTO_CONFIG)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnBack)
+
+        assertThatAndTurbinesConsumed(
+            actual = effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(NavigateBack)
+        }
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/FakeAccountSetupViewModel.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/FakeAccountSetupViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2f5ebf1451fefeda2dea83f5f074aacc4f3ce5e1
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/FakeAccountSetupViewModel.kt
@@ -0,0 +1,25 @@
+package app.k9mail.feature.account.setup.ui
+
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Effect
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Event
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.State
+
+internal class FakeAccountSetupViewModel(
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), AccountSetupContract.ViewModel {
+
+    val events = mutableListOf<Event>()
+
+    fun state(update: (State) -> (State)) {
+        updateState { update(it) }
+    }
+
+    override fun event(event: Event) {
+        events.add(event)
+    }
+
+    fun effect(effect: Effect) {
+        emitEffect(effect)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryScreenKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryScreenKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2d51edc9fa185d414753317e787374d8ee4b19df
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryScreenKtTest.kt
@@ -0,0 +1,45 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import app.k9mail.core.ui.compose.testing.setContent
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Effect
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class AccountAutoDiscoveryScreenKtTest : ComposeTest() {
+
+    @Test
+    fun `should delegate navigation effects`() = runTest {
+        val initialState = State()
+        val viewModel = FakeAccountAutoDiscoveryViewModel(initialState)
+        var onNextCounter = 0
+        var onBackCounter = 0
+
+        setContent {
+            ThunderbirdTheme {
+                AccountAutoDiscoveryScreen(
+                    onNext = { onNextCounter++ },
+                    onBack = { onBackCounter++ },
+                    viewModel = viewModel,
+                )
+            }
+        }
+
+        assertThat(onNextCounter).isEqualTo(0)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateNext)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateBack)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(1)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryStateTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryStateTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fee85038cd369f422181fdf81559323116151ccb
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryStateTest.kt
@@ -0,0 +1,29 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import app.k9mail.feature.account.setup.domain.input.BooleanInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.ConfigStep
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class AccountAutoDiscoveryStateTest {
+
+    @Test
+    fun `should set default values`() {
+        val state = State()
+
+        assertThat(state).isEqualTo(
+            State(
+                configStep = ConfigStep.EMAIL_ADDRESS,
+                emailAddress = StringInputField(),
+                password = StringInputField(),
+                autoDiscoverySettings = null,
+                configurationApproved = BooleanInputField(),
+                error = null,
+                isLoading = false,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryViewModelTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryViewModelTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fc4290b1498f3bbd63947d35c6edeff99e994972
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryViewModelTest.kt
@@ -0,0 +1,476 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import app.cash.turbine.testIn
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.testing.MainDispatcherRule
+import app.k9mail.feature.account.setup.domain.entity.AutoDiscoverySettingsFixture
+import app.k9mail.feature.account.setup.domain.input.BooleanInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.testing.eventStateTest
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.ConfigStep
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Effect
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Error
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Event
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.State
+import assertk.assertThat
+import assertk.assertions.assertThatAndTurbinesConsumed
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class AccountAutoDiscoveryViewModelTest {
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    private val testSubject = AccountAutoDiscoveryViewModel(
+        validator = FakeAccountAutoDiscoveryValidator(),
+        getAutoDiscovery = {
+            delay(50)
+            AutoDiscoveryResult.NoUsableSettingsFound
+        },
+    )
+
+    @Test
+    fun `should reset state when EmailAddressChanged event is received`() = runTest {
+        val initialState = State(
+            configStep = ConfigStep.PASSWORD,
+            emailAddress = StringInputField(value = "email"),
+            password = StringInputField(value = "password"),
+        )
+        testSubject.initState(initialState)
+
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = initialState,
+            event = Event.EmailAddressChanged("email"),
+            expectedState = State(
+                configStep = ConfigStep.EMAIL_ADDRESS,
+                emailAddress = StringInputField(value = "email"),
+                password = StringInputField(),
+            ),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when PasswordChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.PasswordChanged("password"),
+            expectedState = State(
+                password = StringInputField(value = "password"),
+            ),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when ConfigurationApprovalChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.ConfigurationApprovalChanged(true),
+            expectedState = State(
+                configurationApproved = BooleanInputField(value = true),
+            ),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state to password when OnNextClicked event is received, input valid and discovery loaded`() =
+        runTest {
+            val autoDiscoverySettings = AutoDiscoverySettingsFixture.settings
+            val initialState = State(
+                configStep = ConfigStep.EMAIL_ADDRESS,
+                emailAddress = StringInputField(value = "email"),
+            )
+            val viewModel = AccountAutoDiscoveryViewModel(
+                validator = FakeAccountAutoDiscoveryValidator(),
+                getAutoDiscovery = {
+                    delay(50)
+                    autoDiscoverySettings
+                },
+                initialState = initialState,
+            )
+            val stateTurbine = viewModel.state.testIn(backgroundScope)
+            val effectTurbine = viewModel.effect.testIn(backgroundScope)
+            val turbines = listOf(stateTurbine, effectTurbine)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(initialState)
+            }
+
+            viewModel.event(Event.OnNextClicked)
+
+            val validatedState = initialState.copy(
+                emailAddress = StringInputField(
+                    value = "email",
+                    error = null,
+                    isValid = true,
+                ),
+            )
+            assertThat(stateTurbine.awaitItem()).isEqualTo(validatedState)
+
+            val loadingState = validatedState.copy(
+                isLoading = true,
+            )
+            assertThat(stateTurbine.awaitItem()).isEqualTo(loadingState)
+
+            val successState = validatedState.copy(
+                autoDiscoverySettings = autoDiscoverySettings,
+                configStep = ConfigStep.PASSWORD,
+                isLoading = false,
+            )
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(successState)
+            }
+        }
+
+    @Test
+    fun `should not change state when OnNextClicked event is received, input valid but discovery failed`() =
+        runTest {
+            val initialState = State(
+                configStep = ConfigStep.EMAIL_ADDRESS,
+                emailAddress = StringInputField(value = "email"),
+            )
+            val discoveryError = Exception("discovery error")
+            val viewModel = AccountAutoDiscoveryViewModel(
+                validator = FakeAccountAutoDiscoveryValidator(),
+                getAutoDiscovery = {
+                    delay(50)
+                    AutoDiscoveryResult.UnexpectedException(discoveryError)
+                },
+                initialState = initialState,
+            )
+            val stateTurbine = viewModel.state.testIn(backgroundScope)
+            val effectTurbine = viewModel.effect.testIn(backgroundScope)
+            val turbines = listOf(stateTurbine, effectTurbine)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(initialState)
+            }
+
+            viewModel.event(Event.OnNextClicked)
+
+            val validatedState = initialState.copy(
+                emailAddress = StringInputField(
+                    value = "email",
+                    error = null,
+                    isValid = true,
+                ),
+            )
+            assertThat(stateTurbine.awaitItem()).isEqualTo(validatedState)
+
+            val loadingState = validatedState.copy(
+                isLoading = true,
+            )
+            assertThat(stateTurbine.awaitItem()).isEqualTo(loadingState)
+
+            val failureState = validatedState.copy(
+                isLoading = false,
+                error = AccountAutoDiscoveryContract.Error.UnknownError,
+            )
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(failureState)
+            }
+        }
+
+    @Test
+    fun `should reset error state and change to password step when OnNextClicked event received when having error`() =
+        runTest {
+            val initialState = State(
+                configStep = ConfigStep.EMAIL_ADDRESS,
+                emailAddress = StringInputField(
+                    value = "email",
+                    isValid = true,
+                ),
+                error = Error.UnknownError,
+            )
+            testSubject.initState(initialState)
+
+            eventStateTest(
+                viewModel = testSubject,
+                initialState = initialState,
+                event = Event.OnNextClicked,
+                expectedState = State(
+                    configStep = ConfigStep.PASSWORD,
+                    emailAddress = StringInputField(
+                        value = "email",
+                        isValid = true,
+                    ),
+                    error = null,
+                ),
+                coroutineScope = backgroundScope,
+            )
+        }
+
+    @Test
+    fun `should not change config step to password when OnNextClicked event is received and input invalid`() = runTest {
+        val initialState = State(
+            configStep = ConfigStep.EMAIL_ADDRESS,
+            emailAddress = StringInputField(value = "invalid email"),
+        )
+        val viewModel = AccountAutoDiscoveryViewModel(
+            validator = FakeAccountAutoDiscoveryValidator(
+                emailAddressAnswer = ValidationResult.Failure(TestError),
+            ),
+            getAutoDiscovery = { AutoDiscoveryResult.NoUsableSettingsFound },
+            initialState = initialState,
+        )
+
+        eventStateTest(
+            viewModel = viewModel,
+            initialState = initialState,
+            event = Event.OnNextClicked,
+            expectedState = State(
+                configStep = ConfigStep.EMAIL_ADDRESS,
+                emailAddress = StringInputField(
+                    value = "invalid email",
+                    error = TestError,
+                    isValid = false,
+                ),
+            ),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should emit NavigateNext when OnNextClicked received in password step with valid input`() =
+        runTest {
+            val initialState = State(
+                configStep = ConfigStep.PASSWORD,
+                emailAddress = StringInputField(value = "email"),
+                password = StringInputField(value = "password"),
+            )
+            testSubject.initState(initialState)
+            val stateTurbine = testSubject.state.testIn(backgroundScope)
+            val effectTurbine = testSubject.effect.testIn(backgroundScope)
+            val turbines = listOf(stateTurbine, effectTurbine)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(initialState)
+            }
+
+            testSubject.event(Event.OnNextClicked)
+
+            assertThat(stateTurbine.awaitItem()).isEqualTo(
+                State(
+                    configStep = ConfigStep.PASSWORD,
+                    emailAddress = StringInputField(
+                        value = "email",
+                        error = null,
+                        isValid = true,
+                    ),
+                    password = StringInputField(
+                        value = "password",
+                        error = null,
+                        isValid = true,
+                    ),
+                    configurationApproved = BooleanInputField(
+                        value = null,
+                        error = null,
+                        isValid = true,
+                    ),
+                ),
+            )
+
+            assertThatAndTurbinesConsumed(
+                actual = effectTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(Effect.NavigateNext)
+            }
+        }
+
+    @Test
+    fun `should not emit NavigateNext when OnNextClicked received in password step with invalid input`() =
+        runTest {
+            val initialState = State(
+                configStep = ConfigStep.PASSWORD,
+                emailAddress = StringInputField(value = "email"),
+                password = StringInputField(value = "password"),
+            )
+            val viewModel = AccountAutoDiscoveryViewModel(
+                validator = FakeAccountAutoDiscoveryValidator(
+                    passwordAnswer = ValidationResult.Failure(TestError),
+                ),
+                getAutoDiscovery = { AutoDiscoveryResult.NoUsableSettingsFound },
+                initialState = initialState,
+            )
+            val stateTurbine = viewModel.state.testIn(backgroundScope)
+            val effectTurbine = viewModel.effect.testIn(backgroundScope)
+            val turbines = listOf(stateTurbine, effectTurbine)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(initialState)
+            }
+
+            viewModel.event(Event.OnNextClicked)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(
+                    State(
+                        configStep = ConfigStep.PASSWORD,
+                        emailAddress = StringInputField(
+                            value = "email",
+                            error = null,
+                            isValid = true,
+                        ),
+                        password = StringInputField(
+                            value = "password",
+                            error = TestError,
+                            isValid = false,
+                        ),
+                        configurationApproved = BooleanInputField(
+                            value = null,
+                            error = null,
+                            isValid = true,
+                        ),
+                    ),
+                )
+            }
+        }
+
+    @Test
+    fun `should emit NavigateBack effect when OnBackClicked event is received`() = runTest {
+        val viewModel = testSubject
+        val stateTurbine = viewModel.state.testIn(backgroundScope)
+        val effectTurbine = viewModel.effect.testIn(backgroundScope)
+        val turbines = listOf(stateTurbine, effectTurbine)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(State())
+        }
+
+        viewModel.event(Event.OnBackClicked)
+
+        assertThatAndTurbinesConsumed(
+            actual = effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateBack)
+        }
+    }
+
+    @Test
+    fun `should change config step to email address when OnBackClicked event is received in password config step`() =
+        runTest {
+            val initialState = State(
+                configStep = ConfigStep.PASSWORD,
+                emailAddress = StringInputField(value = "email"),
+                password = StringInputField(value = "password"),
+            )
+            val viewModel = testSubject
+            viewModel.initState(initialState)
+            val stateTurbine = viewModel.state.testIn(backgroundScope)
+            val effectTurbine = viewModel.effect.testIn(backgroundScope)
+            val turbines = listOf(stateTurbine, effectTurbine)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(initialState)
+            }
+
+            viewModel.event(Event.OnBackClicked)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(
+                    State(
+                        configStep = ConfigStep.EMAIL_ADDRESS,
+                        emailAddress = StringInputField(value = "email"),
+                    ),
+                )
+            }
+        }
+
+    @Test
+    fun `should reset error state when OnBackClicked event received when having error and in email address step`() =
+        runTest {
+            val initialState = State(
+                configStep = ConfigStep.EMAIL_ADDRESS,
+                emailAddress = StringInputField(
+                    value = "email",
+                    isValid = true,
+                ),
+                error = Error.UnknownError,
+            )
+            testSubject.initState(initialState)
+
+            eventStateTest(
+                viewModel = testSubject,
+                initialState = initialState,
+                event = Event.OnBackClicked,
+                expectedState = State(
+                    configStep = ConfigStep.EMAIL_ADDRESS,
+                    emailAddress = StringInputField(
+                        value = "email",
+                        isValid = true,
+                    ),
+                    error = null,
+                ),
+                coroutineScope = backgroundScope,
+            )
+        }
+
+    @Test
+    fun `should emit NavigateNext effect when OnEditConfigurationClicked event is received`() = runTest {
+        val viewModel = testSubject
+        val stateTurbine = viewModel.state.testIn(backgroundScope)
+        val effectTurbine = viewModel.effect.testIn(backgroundScope)
+        val turbines = listOf(stateTurbine, effectTurbine)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(State())
+        }
+
+        viewModel.event(Event.OnEditConfigurationClicked)
+
+        assertThatAndTurbinesConsumed(
+            actual = effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateNext)
+        }
+    }
+
+    private object TestError : ValidationError
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/FakeAccountAutoDiscoveryValidator.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/FakeAccountAutoDiscoveryValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..57237f562faa9b382fb65d434f9450954f1b44a5
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/FakeAccountAutoDiscoveryValidator.kt
@@ -0,0 +1,16 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+
+class FakeAccountAutoDiscoveryValidator(
+    private val emailAddressAnswer: ValidationResult = ValidationResult.Success,
+    private val passwordAnswer: ValidationResult = ValidationResult.Success,
+    private val configurationApprovalAnswer: ValidationResult = ValidationResult.Success,
+) : AccountAutoDiscoveryContract.Validator {
+    override fun validateEmailAddress(emailAddress: String): ValidationResult = emailAddressAnswer
+    override fun validatePassword(password: String): ValidationResult = passwordAnswer
+    override fun validateConfigurationApproval(
+        isApproved: Boolean?,
+        isAutoDiscoveryTrusted: Boolean?,
+    ): ValidationResult = configurationApprovalAnswer
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/FakeAccountAutoDiscoveryViewModel.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/FakeAccountAutoDiscoveryViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8e4a94f100a944fc9f7876b9f75ba305f2f38357
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/FakeAccountAutoDiscoveryViewModel.kt
@@ -0,0 +1,26 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Effect
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Event
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.State
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.ViewModel
+
+class FakeAccountAutoDiscoveryViewModel(
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), ViewModel {
+
+    val events = mutableListOf<Event>()
+
+    override fun initState(state: State) {
+        updateState { state }
+    }
+
+    override fun event(event: Event) {
+        events.add(event)
+    }
+
+    fun effect(effect: Effect) {
+        emitEffect(effect)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigScreenKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigScreenKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d00af186972d529d640c6ed33902d36309f2f0b5
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigScreenKtTest.kt
@@ -0,0 +1,44 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import app.k9mail.core.ui.compose.testing.setContent
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class AccountIncomingConfigScreenKtTest : ComposeTest() {
+
+    @Test
+    fun `should delegate navigation effects`() = runTest {
+        val initialState = State()
+        val viewModel = FakeAccountIncomingConfigViewModel(initialState)
+        var onNextCounter = 0
+        var onBackCounter = 0
+
+        setContent {
+            AccountIncomingConfigScreen(
+                onNext = { onNextCounter++ },
+                onBack = { onBackCounter++ },
+                viewModel = viewModel,
+            )
+        }
+
+        assertThat(onNextCounter).isEqualTo(0)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateNext)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateBack)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(1)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigStateTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigStateTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..228b594b4d2929295d280043d698ba5708f8bd24
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigStateTest.kt
@@ -0,0 +1,33 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.IncomingProtocolType
+import app.k9mail.feature.account.setup.domain.entity.toImapDefaultPort
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class AccountIncomingConfigStateTest {
+
+    @Test
+    fun `should set default values`() {
+        val state = State()
+
+        assertThat(state).isEqualTo(
+            State(
+                protocolType = IncomingProtocolType.IMAP,
+                server = StringInputField(),
+                security = ConnectionSecurity.DEFAULT,
+                port = NumberInputField(value = ConnectionSecurity.DEFAULT.toImapDefaultPort()),
+                username = StringInputField(),
+                password = StringInputField(),
+                clientCertificate = "",
+                imapAutodetectNamespaceEnabled = true,
+                useCompression = true,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigViewModelTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigViewModelTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..86e55c38907501bc856e0963ba3c306304ace399
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigViewModelTest.kt
@@ -0,0 +1,256 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import androidx.lifecycle.viewmodel.compose.viewModel
+import app.cash.turbine.testIn
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.testing.MainDispatcherRule
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.IncomingProtocolType
+import app.k9mail.feature.account.setup.domain.entity.toImapDefaultPort
+import app.k9mail.feature.account.setup.domain.entity.toPop3DefaultPort
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.testing.eventStateTest
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.State
+import assertk.assertThat
+import assertk.assertions.assertThatAndTurbinesConsumed
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class AccountIncomingConfigViewModelTest {
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    private val testSubject = AccountIncomingConfigViewModel(
+        validator = FakeAccountIncomingConfigValidator(),
+    )
+
+    @Test
+    fun `should change protocol, security and port when ProtocolTypeChanged event is received`() = runTest {
+        val initialState = State(
+            security = ConnectionSecurity.StartTLS,
+            port = NumberInputField(value = ConnectionSecurity.StartTLS.toImapDefaultPort()),
+        )
+        testSubject.initState(initialState)
+
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = initialState,
+            event = Event.ProtocolTypeChanged(IncomingProtocolType.POP3),
+            expectedState = State(
+                protocolType = IncomingProtocolType.POP3,
+                security = ConnectionSecurity.TLS,
+                port = NumberInputField(value = ConnectionSecurity.TLS.toPop3DefaultPort()),
+            ),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when ServerChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.ServerChanged("server"),
+            expectedState = State(server = StringInputField(value = "server")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change security and port when SecurityChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.SecurityChanged(ConnectionSecurity.StartTLS),
+            expectedState = State(
+                security = ConnectionSecurity.StartTLS,
+                port = NumberInputField(value = ConnectionSecurity.StartTLS.toImapDefaultPort()),
+            ),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when PortChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.PortChanged(456L),
+            expectedState = State(port = NumberInputField(value = 456L)),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when UsernameChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.UsernameChanged("username"),
+            expectedState = State(username = StringInputField(value = "username")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when PasswordChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.PasswordChanged("password"),
+            expectedState = State(password = StringInputField(value = "password")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when ClientCertificateChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.ClientCertificateChanged("clientCertificate"),
+            expectedState = State(clientCertificate = "clientCertificate"),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when ImapAutoDetectNamespaceChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(imapAutodetectNamespaceEnabled = true),
+            event = Event.ImapAutoDetectNamespaceChanged(false),
+            expectedState = State(imapAutodetectNamespaceEnabled = false),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when ImapPrefixChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.ImapPrefixChanged("imapPrefix"),
+            expectedState = State(imapPrefix = StringInputField(value = "imapPrefix")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when UseCompressionChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(useCompression = true),
+            event = Event.UseCompressionChanged(false),
+            expectedState = State(useCompression = false),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state and emit NavigateNext effect when OnNextClicked event is received and input is valid`() =
+        runTest {
+            val viewModel = testSubject
+            val stateTurbine = viewModel.state.testIn(backgroundScope)
+            val effectTurbine = viewModel.effect.testIn(backgroundScope)
+            val turbines = listOf(stateTurbine, effectTurbine)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(State())
+            }
+
+            viewModel.event(Event.OnNextClicked)
+
+            assertThat(stateTurbine.awaitItem()).isEqualTo(
+                State(
+                    server = StringInputField(value = "", isValid = true),
+                    port = NumberInputField(value = 993L, isValid = true),
+                    username = StringInputField(value = "", isValid = true),
+                    password = StringInputField(value = "", isValid = true),
+                    imapPrefix = StringInputField(value = "", isValid = true),
+                ),
+            )
+
+            assertThatAndTurbinesConsumed(
+                actual = effectTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(Effect.NavigateNext)
+            }
+        }
+
+    @Test
+    fun `should change state and not emit NavigateNext effect when OnNextClicked event received and input invalid`() =
+        runTest {
+            val viewModel = AccountIncomingConfigViewModel(
+                validator = FakeAccountIncomingConfigValidator(
+                    serverAnswer = ValidationResult.Failure(TestError),
+                ),
+            )
+            val stateTurbine = viewModel.state.testIn(backgroundScope)
+            val effectTurbine = viewModel.effect.testIn(backgroundScope)
+            val turbines = listOf(stateTurbine, effectTurbine)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(State())
+            }
+
+            viewModel.event(Event.OnNextClicked)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(
+                    State(
+                        server = StringInputField(value = "", error = TestError, isValid = false),
+                        port = NumberInputField(value = 993L, isValid = true),
+                        username = StringInputField(value = "", isValid = true),
+                        password = StringInputField(value = "", isValid = true),
+                        imapPrefix = StringInputField(value = "", isValid = true),
+                    ),
+                )
+            }
+        }
+
+    @Test
+    fun `should emit NavigateBack effect when OnBackClicked event received`() = runTest {
+        val viewModel = testSubject
+        val stateTurbine = viewModel.state.testIn(backgroundScope)
+        val effectTurbine = viewModel.effect.testIn(backgroundScope)
+        val turbines = listOf(stateTurbine, effectTurbine)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(State())
+        }
+
+        viewModel.event(Event.OnBackClicked)
+
+        assertThatAndTurbinesConsumed(
+            actual = effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateBack)
+        }
+    }
+
+    private object TestError : ValidationError
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/FakeAccountIncomingConfigValidator.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/FakeAccountIncomingConfigValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9835314489ba7e8fef0ac8ba8135be09e8503714
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/FakeAccountIncomingConfigValidator.kt
@@ -0,0 +1,17 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+
+class FakeAccountIncomingConfigValidator(
+    private val serverAnswer: ValidationResult = ValidationResult.Success,
+    private val portAnswer: ValidationResult = ValidationResult.Success,
+    private val usernameAnswer: ValidationResult = ValidationResult.Success,
+    private val passwordAnswer: ValidationResult = ValidationResult.Success,
+    private val imapPrefixAnswer: ValidationResult = ValidationResult.Success,
+) : AccountIncomingConfigContract.Validator {
+    override fun validateServer(server: String): ValidationResult = serverAnswer
+    override fun validatePort(port: Long?): ValidationResult = portAnswer
+    override fun validateUsername(username: String): ValidationResult = usernameAnswer
+    override fun validatePassword(password: String): ValidationResult = passwordAnswer
+    override fun validateImapPrefix(imapPrefix: String): ValidationResult = imapPrefixAnswer
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/FakeAccountIncomingConfigViewModel.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/FakeAccountIncomingConfigViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..05c35e2d7ff2ee3654e5c675f3d352311c47eb6b
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/FakeAccountIncomingConfigViewModel.kt
@@ -0,0 +1,26 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.State
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.ViewModel
+
+class FakeAccountIncomingConfigViewModel(
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), ViewModel {
+
+    val events = mutableListOf<Event>()
+
+    override fun initState(state: State) {
+        updateState { state }
+    }
+
+    override fun event(event: Event) {
+        events.add(event)
+    }
+
+    fun effect(effect: Effect) {
+        emitEffect(effect)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsScreenKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsScreenKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e804873612261ccb6cff3ffb3def781e53a6e494
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsScreenKtTest.kt
@@ -0,0 +1,45 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import app.k9mail.core.ui.compose.testing.setContent
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Effect
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class AccountOptionsScreenKtTest : ComposeTest() {
+
+    @Test
+    fun `should delegate navigation effects`() = runTest {
+        val initialState = State()
+        val viewModel = FakeAccountOptionsViewModel(initialState)
+        var onNextCounter = 0
+        var onBackCounter = 0
+
+        setContent {
+            ThunderbirdTheme {
+                AccountOptionsScreen(
+                    onNext = { onNextCounter++ },
+                    onBack = { onBackCounter++ },
+                    viewModel = viewModel,
+                )
+            }
+        }
+
+        assertThat(onNextCounter).isEqualTo(0)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateNext)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateBack)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(1)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStateTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStateTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..eeb7ec44e4eebc88fd771a5f70211badba0ad895
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStateTest.kt
@@ -0,0 +1,28 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.k9mail.feature.account.setup.domain.entity.EmailCheckFrequency
+import app.k9mail.feature.account.setup.domain.entity.EmailDisplayCount
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class AccountOptionsStateTest {
+
+    @Test
+    fun `should set default values`() {
+        val state = State()
+
+        assertThat(state).isEqualTo(
+            State(
+                accountName = StringInputField(),
+                displayName = StringInputField(),
+                emailSignature = StringInputField(),
+                checkFrequency = EmailCheckFrequency.DEFAULT,
+                messageDisplayCount = EmailDisplayCount.DEFAULT,
+                showNotification = false,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsViewModelTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsViewModelTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..61ea3b9bd5dc0be8ebda518fb96e16f378ecd5c5
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsViewModelTest.kt
@@ -0,0 +1,191 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.cash.turbine.testIn
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.testing.MainDispatcherRule
+import app.k9mail.feature.account.setup.domain.entity.EmailCheckFrequency
+import app.k9mail.feature.account.setup.domain.entity.EmailDisplayCount
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.testing.eventStateTest
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Effect
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.State
+import assertk.assertThat
+import assertk.assertions.assertThatAndTurbinesConsumed
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class AccountOptionsViewModelTest {
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    private val testSubject = AccountOptionsViewModel(
+        validator = FakeAccountOptionsValidator(),
+    )
+
+    @Test
+    fun `should change state when OnAccountNameChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.OnAccountNameChanged("accountName"),
+            expectedState = State(accountName = StringInputField(value = "accountName")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when OnDisplayNameChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.OnDisplayNameChanged("displayName"),
+            expectedState = State(displayName = StringInputField(value = "displayName")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when OnEmailSignatureChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.OnEmailSignatureChanged("emailSignature"),
+            expectedState = State(emailSignature = StringInputField(value = "emailSignature")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when OnCheckFrequencyChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.OnCheckFrequencyChanged(EmailCheckFrequency.EVERY_12_HOURS),
+            expectedState = State(checkFrequency = EmailCheckFrequency.EVERY_12_HOURS),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when OnMessageDisplayCountChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.OnMessageDisplayCountChanged(EmailDisplayCount.MESSAGES_1000),
+            expectedState = State(messageDisplayCount = EmailDisplayCount.MESSAGES_1000),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when OnShowNotificationChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.OnShowNotificationChanged(true),
+            expectedState = State(showNotification = true),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state and emit NavigateNext effect when OnNextClicked event received and input valid`() =
+        runTest {
+            val viewModel = testSubject
+            val stateTurbine = viewModel.state.testIn(backgroundScope)
+            val effectTurbine = viewModel.effect.testIn(backgroundScope)
+            val turbines = listOf(stateTurbine, effectTurbine)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(State())
+            }
+
+            viewModel.event(Event.OnNextClicked)
+
+            assertThat(stateTurbine.awaitItem()).isEqualTo(
+                State(
+                    accountName = StringInputField(value = "", isValid = true),
+                    displayName = StringInputField(value = "", isValid = true),
+                    emailSignature = StringInputField(value = "", isValid = true),
+                ),
+            )
+
+            assertThatAndTurbinesConsumed(
+                actual = effectTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(Effect.NavigateNext)
+            }
+        }
+
+    @Test
+    fun `should change state and not emit effect when OnNextClicked event received and input invalid`() =
+        runTest {
+            val viewModel = AccountOptionsViewModel(
+                validator = FakeAccountOptionsValidator(
+                    accountNameAnswer = ValidationResult.Failure(TestError),
+                ),
+            )
+            val stateTurbine = viewModel.state.testIn(backgroundScope)
+            val effectTurbine = viewModel.effect.testIn(backgroundScope)
+            val turbines = listOf(stateTurbine, effectTurbine)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(State())
+            }
+
+            viewModel.event(Event.OnNextClicked)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(
+                    State(
+                        accountName = StringInputField(value = "", error = TestError, isValid = false),
+                        displayName = StringInputField(value = "", isValid = true),
+                        emailSignature = StringInputField(value = "", isValid = true),
+                    ),
+                )
+            }
+        }
+
+    @Test
+    fun `should emit NavigateBack effect when OnBackClicked event received`() = runTest {
+        val viewModel = testSubject
+        val stateTurbine = viewModel.state.testIn(backgroundScope)
+        val effectTurbine = viewModel.effect.testIn(backgroundScope)
+        val turbines = listOf(stateTurbine, effectTurbine)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(State())
+        }
+
+        viewModel.event(Event.OnBackClicked)
+
+        assertThatAndTurbinesConsumed(
+            actual = effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateBack)
+        }
+    }
+
+    private object TestError : ValidationError
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/FakeAccountOptionsValidator.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/FakeAccountOptionsValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..bd65543c2dacaf7843ae19a7ea81a72744ecebde
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/FakeAccountOptionsValidator.kt
@@ -0,0 +1,14 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Validator
+
+internal class FakeAccountOptionsValidator(
+    private val accountNameAnswer: ValidationResult = ValidationResult.Success,
+    private val displayNameAnswer: ValidationResult = ValidationResult.Success,
+    private val emailSignatureAnswer: ValidationResult = ValidationResult.Success,
+) : Validator {
+    override fun validateAccountName(accountName: String): ValidationResult = accountNameAnswer
+    override fun validateDisplayName(displayName: String): ValidationResult = displayNameAnswer
+    override fun validateEmailSignature(emailSignature: String): ValidationResult = emailSignatureAnswer
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/FakeAccountOptionsViewModel.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/FakeAccountOptionsViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..99d1249e7bfd51f1f0585920812e202d3c4586cf
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/FakeAccountOptionsViewModel.kt
@@ -0,0 +1,26 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Effect
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.State
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.ViewModel
+
+class FakeAccountOptionsViewModel(
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), ViewModel {
+
+    val events = mutableListOf<Event>()
+
+    override fun initState(state: State) {
+        updateState { state }
+    }
+
+    override fun event(event: Event) {
+        events.add(event)
+    }
+
+    fun effect(effect: Effect) {
+        emitEffect(effect)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigScreenKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigScreenKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0c0d7c18d2115ec13d0d473c76b1968524f00667
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigScreenKtTest.kt
@@ -0,0 +1,44 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import app.k9mail.core.ui.compose.testing.setContent
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class AccountOutgoingConfigScreenKtTest : ComposeTest() {
+
+    @Test
+    fun `should delegate navigation effects`() = runTest {
+        val initialState = State()
+        val viewModel = FakeAccountOutgoingConfigViewModel(initialState)
+        var onNextCounter = 0
+        var onBackCounter = 0
+
+        setContent {
+            AccountOutgoingConfigScreen(
+                onNext = { onNextCounter++ },
+                onBack = { onBackCounter++ },
+                viewModel = viewModel,
+            )
+        }
+
+        assertThat(onNextCounter).isEqualTo(0)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateNext)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateBack)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(1)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigStateTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigStateTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e811af4ebd050d2e5c7f4daa8dca0b407ed8d226
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigStateTest.kt
@@ -0,0 +1,31 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.toSmtpDefaultPort
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class AccountOutgoingConfigStateTest {
+
+    @Test
+    fun `should set default values`() {
+        val state = State()
+
+        assertThat(state).isEqualTo(
+            State(
+                server = StringInputField(),
+                security = ConnectionSecurity.DEFAULT,
+                port = NumberInputField(value = ConnectionSecurity.DEFAULT.toSmtpDefaultPort()),
+                username = StringInputField(),
+                password = StringInputField(),
+                clientCertificate = "",
+                imapAutodetectNamespaceEnabled = true,
+                useCompression = true,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigViewModelTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigViewModelTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..861e5bb7d96f63453687eef36f34ccf19070bdf5
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigViewModelTest.kt
@@ -0,0 +1,219 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.cash.turbine.testIn
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.testing.MainDispatcherRule
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.toSmtpDefaultPort
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.testing.eventStateTest
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.State
+import assertk.assertThat
+import assertk.assertions.assertThatAndTurbinesConsumed
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class AccountOutgoingConfigViewModelTest {
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    private val testSubject = AccountOutgoingConfigViewModel(
+        validator = FakeAccountOutgoingConfigValidator(),
+    )
+
+    @Test
+    fun `should change state when ServerChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.ServerChanged("server"),
+            expectedState = State(server = StringInputField(value = "server")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change security and port when SecurityChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.SecurityChanged(ConnectionSecurity.StartTLS),
+            expectedState = State(
+                security = ConnectionSecurity.StartTLS,
+                port = NumberInputField(value = ConnectionSecurity.StartTLS.toSmtpDefaultPort()),
+            ),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when PortChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.PortChanged(456L),
+            expectedState = State(port = NumberInputField(value = 456L)),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when UsernameChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.UsernameChanged("username"),
+            expectedState = State(username = StringInputField(value = "username")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when PasswordChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.PasswordChanged("password"),
+            expectedState = State(password = StringInputField(value = "password")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when ClientCertificateChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.ClientCertificateChanged("clientCertificate"),
+            expectedState = State(clientCertificate = "clientCertificate"),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when ImapAutoDetectNamespaceChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(imapAutodetectNamespaceEnabled = true),
+            event = Event.ImapAutoDetectNamespaceChanged(false),
+            expectedState = State(imapAutodetectNamespaceEnabled = false),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when UseCompressionChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(useCompression = true),
+            event = Event.UseCompressionChanged(false),
+            expectedState = State(useCompression = false),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state and emit NavigateNext effect when OnNextClicked event is received and input is valid`() =
+        runTest {
+            val viewModel = testSubject
+            val stateTurbine = viewModel.state.testIn(backgroundScope)
+            val effectTurbine = viewModel.effect.testIn(backgroundScope)
+            val turbines = listOf(stateTurbine, effectTurbine)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(State())
+            }
+
+            viewModel.event(Event.OnNextClicked)
+
+            assertThat(stateTurbine.awaitItem()).isEqualTo(
+                State(
+                    server = StringInputField(value = "", isValid = true),
+                    port = NumberInputField(value = 465L, isValid = true),
+                    username = StringInputField(value = "", isValid = true),
+                    password = StringInputField(value = "", isValid = true),
+                ),
+            )
+
+            assertThatAndTurbinesConsumed(
+                actual = effectTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(Effect.NavigateNext)
+            }
+        }
+
+    @Test
+    fun `should change state and not emit NavigateNext effect when OnNextClicked event received and input invalid`() =
+        runTest {
+            val viewModel = AccountOutgoingConfigViewModel(
+                validator = FakeAccountOutgoingConfigValidator(
+                    serverAnswer = ValidationResult.Failure(TestError),
+                ),
+            )
+            val stateTurbine = viewModel.state.testIn(backgroundScope)
+            val effectTurbine = viewModel.effect.testIn(backgroundScope)
+            val turbines = listOf(stateTurbine, effectTurbine)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(State())
+            }
+
+            viewModel.event(Event.OnNextClicked)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(
+                    State(
+                        server = StringInputField(value = "", error = TestError, isValid = false),
+                        port = NumberInputField(value = 465L, isValid = true),
+                        username = StringInputField(value = "", isValid = true),
+                        password = StringInputField(value = "", isValid = true),
+                    ),
+                )
+            }
+        }
+
+    @Test
+    fun `should emit NavigateBack effect when OnBackClicked event received`() = runTest {
+        val viewModel = testSubject
+        val stateTurbine = viewModel.state.testIn(backgroundScope)
+        val effectTurbine = viewModel.effect.testIn(backgroundScope)
+        val turbines = listOf(stateTurbine, effectTurbine)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(State())
+        }
+
+        viewModel.event(Event.OnBackClicked)
+
+        assertThatAndTurbinesConsumed(
+            actual = effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateBack)
+        }
+    }
+
+    private object TestError : ValidationError
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/FakeAccountOutgoingConfigValidator.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/FakeAccountOutgoingConfigValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5c342e99592cbac10b0d96443e83043e5a4a0119
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/FakeAccountOutgoingConfigValidator.kt
@@ -0,0 +1,15 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+
+class FakeAccountOutgoingConfigValidator(
+    private val serverAnswer: ValidationResult = ValidationResult.Success,
+    private val portAnswer: ValidationResult = ValidationResult.Success,
+    private val usernameAnswer: ValidationResult = ValidationResult.Success,
+    private val passwordAnswer: ValidationResult = ValidationResult.Success,
+) : AccountOutgoingConfigContract.Validator {
+    override fun validateServer(server: String): ValidationResult = serverAnswer
+    override fun validatePort(port: Long?): ValidationResult = portAnswer
+    override fun validateUsername(username: String): ValidationResult = usernameAnswer
+    override fun validatePassword(password: String): ValidationResult = passwordAnswer
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/FakeAccountOutgoingConfigViewModel.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/FakeAccountOutgoingConfigViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1437a974c91ba4f604377bddf26d702f44f31d17
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/FakeAccountOutgoingConfigViewModel.kt
@@ -0,0 +1,26 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.State
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.ViewModel
+
+class FakeAccountOutgoingConfigViewModel(
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), ViewModel {
+
+    val events = mutableListOf<Event>()
+
+    override fun initState(state: State) {
+        updateState { state }
+    }
+
+    override fun event(event: Event) {
+        events.add(event)
+    }
+
+    fun effect(effect: Effect) {
+        emitEffect(effect)
+    }
+}
diff --git a/feature/autodiscovery/api/build.gradle.kts b/feature/autodiscovery/api/build.gradle.kts
index 2aa9cf93c5a9d68133963fbb1cecaeeb510cacba..350629b443f54587fa127fe32e746d65219d03f5 100644
--- a/feature/autodiscovery/api/build.gradle.kts
+++ b/feature/autodiscovery/api/build.gradle.kts
@@ -5,4 +5,5 @@ plugins {
 
 dependencies {
     api(projects.mail.common)
+    api(projects.core.common)
 }
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AuthenticationType.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AuthenticationType.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8b070af213a9fa361ddc772137ec4b2977910990
--- /dev/null
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AuthenticationType.kt
@@ -0,0 +1,13 @@
+package app.k9mail.autodiscovery.api
+
+/**
+ * The authentication types supported when using the [AutoDiscovery] mechanism.
+ *
+ * Note: Currently we support the same set of values in [ImapServerSettings] and [SmtpServerSettings]. As soon as this
+ * changes, this type should be replaced with `ImapAuthenticationType` and `SmtpAuthenticationType`.
+ */
+enum class AuthenticationType {
+    PasswordCleartext,
+    PasswordEncrypted,
+    OAuth2,
+}
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscovery.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscovery.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5f4c43fe5d384387f840d8fcc296962c6ec0cb95
--- /dev/null
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscovery.kt
@@ -0,0 +1,13 @@
+package app.k9mail.autodiscovery.api
+
+import app.k9mail.core.common.mail.EmailAddress
+
+/**
+ * Provides a mechanism to find mail server settings for a given email address.
+ */
+interface AutoDiscovery {
+    /**
+     * Returns a list of [AutoDiscoveryRunnable]s that perform the actual mail server settings discovery.
+     */
+    fun initDiscovery(email: EmailAddress): List<AutoDiscoveryRunnable>
+}
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryResult.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..515dc8292a0f5e8744c3ff9327c55e7a19898150
--- /dev/null
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryResult.kt
@@ -0,0 +1,56 @@
+package app.k9mail.autodiscovery.api
+
+import java.io.IOException
+
+/**
+ * Results of a mail server settings lookup.
+ */
+sealed interface AutoDiscoveryResult {
+    /**
+     * Mail server settings found during the lookup.
+     */
+    data class Settings(
+        val incomingServerSettings: IncomingServerSettings,
+        val outgoingServerSettings: OutgoingServerSettings,
+
+        /**
+         * Indicates whether the mail server settings lookup was using only trusted channels.
+         *
+         * `true` if the settings lookup was only using trusted channels, e.g. lookup via HTTPS where the server
+         * presented a trusted certificate. `false´ otherwise.
+         *
+         * IMPORTANT: When this value is `false`, the settings should be presented to the user and only be used after
+         * the user has given consent.
+         */
+        val isTrusted: Boolean,
+    ) : AutoDiscoveryResult
+
+    /**
+     * No usable mail server settings were found.
+     */
+    object NoUsableSettingsFound : AutoDiscoveryResult
+
+    /**
+     * A network error occurred while looking for mail server settings.
+     */
+    data class NetworkError(val exception: IOException) : AutoDiscoveryResult
+
+    /**
+     * Encountered an unexpected exception when looking up mail server settings.
+     */
+    data class UnexpectedException(val exception: Exception) : AutoDiscoveryResult
+}
+
+/**
+ * Incoming mail server settings.
+ *
+ * Implementations contain protocol-specific properties.
+ */
+interface IncomingServerSettings
+
+/**
+ * Outgoing mail server settings.
+ *
+ * Implementations contain protocol-specific properties.
+ */
+interface OutgoingServerSettings
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryRunnable.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryRunnable.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b7b592c07af42ef9f79b2793154201cdaac03ca8
--- /dev/null
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryRunnable.kt
@@ -0,0 +1,10 @@
+package app.k9mail.autodiscovery.api
+
+/**
+ * Performs a mail server settings lookup.
+ *
+ * This is an abstraction that allows us to run multiple lookups in parallel.
+ */
+fun interface AutoDiscoveryRunnable {
+    suspend fun run(): AutoDiscoveryResult
+}
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryService.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryService.kt
new file mode 100644
index 0000000000000000000000000000000000000000..70283c61d66c58d8dbc4ecbc6fc7737afc12c9b3
--- /dev/null
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryService.kt
@@ -0,0 +1,10 @@
+package app.k9mail.autodiscovery.api
+
+import app.k9mail.core.common.mail.EmailAddress
+
+/**
+ * Tries to find mail server settings for a given email address.
+ */
+interface AutoDiscoveryService {
+    suspend fun discover(email: EmailAddress): AutoDiscoveryResult
+}
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ConnectionSecurity.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ConnectionSecurity.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ffe299a79fe08ba6f994fe732daa5f58b42a4b0d
--- /dev/null
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ConnectionSecurity.kt
@@ -0,0 +1,9 @@
+package app.k9mail.autodiscovery.api
+
+/**
+ * The connection security methods supported when using the [AutoDiscovery] mechanism.
+ */
+enum class ConnectionSecurity {
+    StartTLS,
+    TLS,
+}
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ConnectionSettingsDiscovery.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ConnectionSettingsDiscovery.kt
index f74362bf6c11c525257415fd38b187553c16c9d4..dc2e40fc8c6cd13d02f536ec1585d71a5aa4a3bc 100644
--- a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ConnectionSettingsDiscovery.kt
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ConnectionSettingsDiscovery.kt
@@ -3,6 +3,7 @@ package app.k9mail.autodiscovery.api
 import com.fsck.k9.mail.AuthType
 import com.fsck.k9.mail.ConnectionSecurity
 
+@Deprecated("New code should use app.k9mail.autodiscovery.api.AutoDiscovery")
 interface ConnectionSettingsDiscovery {
     fun discover(email: String): DiscoveryResults?
 }
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ImapServerSettings.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ImapServerSettings.kt
new file mode 100644
index 0000000000000000000000000000000000000000..05bf0cf8ea93657f60da24d305d63d8d586c13fd
--- /dev/null
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ImapServerSettings.kt
@@ -0,0 +1,12 @@
+package app.k9mail.autodiscovery.api
+
+import app.k9mail.core.common.net.Hostname
+import app.k9mail.core.common.net.Port
+
+data class ImapServerSettings(
+    val hostname: Hostname,
+    val port: Port,
+    val connectionSecurity: ConnectionSecurity,
+    val authenticationType: AuthenticationType,
+    val username: String,
+) : IncomingServerSettings
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/SmtpServerSettings.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/SmtpServerSettings.kt
new file mode 100644
index 0000000000000000000000000000000000000000..cf93e13d8783f16d280b7d13cd8bf289a00ad0ba
--- /dev/null
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/SmtpServerSettings.kt
@@ -0,0 +1,12 @@
+package app.k9mail.autodiscovery.api
+
+import app.k9mail.core.common.net.Hostname
+import app.k9mail.core.common.net.Port
+
+data class SmtpServerSettings(
+    val hostname: Hostname,
+    val port: Port,
+    val connectionSecurity: ConnectionSecurity,
+    val authenticationType: AuthenticationType,
+    val username: String,
+) : OutgoingServerSettings
diff --git a/feature/autodiscovery/autoconfig/build.gradle.kts b/feature/autodiscovery/autoconfig/build.gradle.kts
index cebc3c662d874290c582073b58b73ced9d3bd829..7a2ff5fe1a3f55e1fab551a5cd3485596c6b9b9b 100644
--- a/feature/autodiscovery/autoconfig/build.gradle.kts
+++ b/feature/autodiscovery/autoconfig/build.gradle.kts
@@ -5,10 +5,14 @@ plugins {
 
 dependencies {
     api(projects.feature.autodiscovery.api)
+    api(libs.okhttp)
 
+    implementation(libs.kotlinx.coroutines.core)
+    implementation(libs.minidns.hla)
     compileOnly(libs.xmlpull)
-    implementation(libs.okhttp)
 
+    testImplementation(libs.kotlinx.coroutines.test)
     testImplementation(libs.kxml2)
+    testImplementation(libs.jsoup)
     testImplementation(libs.okhttp.mockwebserver)
 }
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigDiscovery.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigDiscovery.kt
index e6a3d53e02c13cca0edc8ce69e0a31fc88572fd2..61427957a8f9ed847cda55bf57f732519b47fba0 100644
--- a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigDiscovery.kt
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigDiscovery.kt
@@ -1,28 +1,49 @@
 package app.k9mail.autodiscovery.autoconfig
 
-import app.k9mail.autodiscovery.api.ConnectionSettingsDiscovery
-import app.k9mail.autodiscovery.api.DiscoveryResults
+import app.k9mail.autodiscovery.api.AutoDiscovery
+import app.k9mail.autodiscovery.api.AutoDiscoveryRunnable
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toDomain
+import okhttp3.OkHttpClient
 
-class AutoconfigDiscovery(
+class AutoconfigDiscovery internal constructor(
     private val urlProvider: AutoconfigUrlProvider,
-    private val fetcher: AutoconfigFetcher,
-    private val parser: AutoconfigParser,
-) : ConnectionSettingsDiscovery {
-
-    override fun discover(email: String): DiscoveryResults? {
-        val autoconfigUrls = urlProvider.getAutoconfigUrls(email)
-
-        return autoconfigUrls
-            .asSequence()
-            .mapNotNull { autoconfigUrl ->
-                fetcher.fetchAutoconfigFile(autoconfigUrl)?.use { inputStream ->
-                    parser.parseSettings(inputStream, email)
-                }
-            }
-            .firstOrNull { result ->
-                result.incoming.isNotEmpty() || result.outgoing.isNotEmpty()
+    private val autoconfigFetcher: AutoconfigFetcher,
+) : AutoDiscovery {
+
+    override fun initDiscovery(email: EmailAddress): List<AutoDiscoveryRunnable> {
+        val domain = email.domain.toDomain()
+
+        val autoconfigUrls = urlProvider.getAutoconfigUrls(domain, email)
+
+        return autoconfigUrls.map { autoconfigUrl ->
+            AutoDiscoveryRunnable {
+                autoconfigFetcher.fetchAutoconfig(autoconfigUrl, email)
             }
+        }
     }
+}
+
+fun createProviderAutoconfigDiscovery(
+    okHttpClient: OkHttpClient,
+    config: AutoconfigUrlConfig,
+): AutoconfigDiscovery {
+    val urlProvider = ProviderAutoconfigUrlProvider(config)
+    return createAutoconfigDiscovery(okHttpClient, urlProvider)
+}
+
+fun createIspDbAutoconfigDiscovery(okHttpClient: OkHttpClient): AutoconfigDiscovery {
+    val urlProvider = IspDbAutoconfigUrlProvider()
+    return createAutoconfigDiscovery(okHttpClient, urlProvider)
+}
 
-    override fun toString(): String = "Thunderbird autoconfig"
+private fun createAutoconfigDiscovery(
+    okHttpClient: OkHttpClient,
+    urlProvider: AutoconfigUrlProvider,
+): AutoconfigDiscovery {
+    val autoconfigFetcher = RealAutoconfigFetcher(
+        fetcher = OkHttpFetcher(okHttpClient),
+        parser = SuspendableAutoconfigParser(RealAutoconfigParser()),
+    )
+    return AutoconfigDiscovery(urlProvider, autoconfigFetcher)
 }
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigFetcher.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigFetcher.kt
index 4a510c709346d98a671187a70f2ed1cabb3148fb..6db8f6b9d0827c95d8c2d1022d6adcb35a8261c4 100644
--- a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigFetcher.kt
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigFetcher.kt
@@ -1,28 +1,12 @@
 package app.k9mail.autodiscovery.autoconfig
 
-import com.fsck.k9.logging.Timber
-import java.io.IOException
-import java.io.InputStream
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.core.common.mail.EmailAddress
 import okhttp3.HttpUrl
-import okhttp3.OkHttpClient
-import okhttp3.Request
 
-class AutoconfigFetcher(private val okHttpClient: OkHttpClient) {
-
-    fun fetchAutoconfigFile(url: HttpUrl): InputStream? {
-        return try {
-            val request = Request.Builder().url(url).build()
-
-            val response = okHttpClient.newCall(request).execute()
-
-            if (response.isSuccessful) {
-                response.body?.byteStream()
-            } else {
-                null
-            }
-        } catch (e: IOException) {
-            Timber.d(e, "Error fetching URL: %s", url)
-            null
-        }
-    }
+/**
+ * Fetches and parses Autoconfig settings.
+ */
+internal interface AutoconfigFetcher {
+    suspend fun fetchAutoconfig(autoconfigUrl: HttpUrl, email: EmailAddress): AutoDiscoveryResult
 }
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParser.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParser.kt
index c57bca062d176d73e574eaf3798cf059dfedbc37..51079585914eb0988d73e699f13d251b22371594 100644
--- a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParser.kt
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParser.kt
@@ -1,102 +1,13 @@
 package app.k9mail.autodiscovery.autoconfig
 
-import app.k9mail.autodiscovery.api.DiscoveredServerSettings
-import app.k9mail.autodiscovery.api.DiscoveryResults
-import com.fsck.k9.mail.AuthType
-import com.fsck.k9.mail.ConnectionSecurity
-import java.io.IOException
+import app.k9mail.core.common.mail.EmailAddress
 import java.io.InputStream
-import java.io.InputStreamReader
-import org.xmlpull.v1.XmlPullParser
-import org.xmlpull.v1.XmlPullParserException
-import org.xmlpull.v1.XmlPullParserFactory
 
 /**
- * Parser for Thunderbird's
- * [Autoconfig file format](https://wiki.mozilla.org/Thunderbird:Autoconfiguration:ConfigFileFormat)
+ * Parser for Thunderbird's Autoconfig file format.
+ *
+ * See [https://github.com/thundernest/autoconfig](https://github.com/thundernest/autoconfig)
  */
-class AutoconfigParser {
-    fun parseSettings(stream: InputStream, email: String): DiscoveryResults? {
-        val factory = XmlPullParserFactory.newInstance()
-        val xpp = factory.newPullParser()
-
-        xpp.setInput(InputStreamReader(stream))
-
-        val incomingServers = mutableListOf<DiscoveredServerSettings>()
-        val outgoingServers = mutableListOf<DiscoveredServerSettings>()
-        var eventType = xpp.eventType
-        while (eventType != XmlPullParser.END_DOCUMENT) {
-            if (eventType == XmlPullParser.START_TAG) {
-                when (xpp.name) {
-                    "incomingServer" -> {
-                        incomingServers += parseServer(xpp, "incomingServer", email)
-                    }
-                    "outgoingServer" -> {
-                        outgoingServers += parseServer(xpp, "outgoingServer", email)
-                    }
-                }
-            }
-            eventType = xpp.next()
-        }
-        return DiscoveryResults(incomingServers, outgoingServers)
-    }
-
-    private fun parseServer(xpp: XmlPullParser, nodeName: String, email: String): DiscoveredServerSettings {
-        val type = xpp.getAttributeValue(null, "type")
-        var host: String? = null
-        var username: String? = null
-        var port: Int? = null
-        var authType: AuthType? = null
-        var connectionSecurity: ConnectionSecurity? = null
-
-        var eventType = xpp.eventType
-        while (!(eventType == XmlPullParser.END_TAG && nodeName == xpp.name)) {
-            if (eventType == XmlPullParser.START_TAG) {
-                when (xpp.name) {
-                    "hostname" -> {
-                        host = getText(xpp)
-                    }
-                    "port" -> {
-                        port = getText(xpp).toInt()
-                    }
-                    "username" -> {
-                        username = getText(xpp).replace("%EMAILADDRESS%", email)
-                    }
-                    "authentication" -> {
-                        if (authType == null) authType = parseAuthType(getText(xpp))
-                    }
-                    "socketType" -> {
-                        connectionSecurity = parseSocketType(getText(xpp))
-                    }
-                }
-            }
-            eventType = xpp.next()
-        }
-
-        return DiscoveredServerSettings(type, host!!, port!!, connectionSecurity!!, authType, username)
-    }
-
-    private fun parseAuthType(authentication: String): AuthType? {
-        return when (authentication) {
-            "password-cleartext" -> AuthType.PLAIN
-            "TLS-client-cert" -> AuthType.EXTERNAL
-            "secure" -> AuthType.CRAM_MD5
-            else -> null
-        }
-    }
-
-    private fun parseSocketType(socketType: String): ConnectionSecurity? {
-        return when (socketType) {
-            "plain" -> ConnectionSecurity.NONE
-            "SSL" -> ConnectionSecurity.SSL_TLS_REQUIRED
-            "STARTTLS" -> ConnectionSecurity.STARTTLS_REQUIRED
-            else -> null
-        }
-    }
-
-    @Throws(XmlPullParserException::class, IOException::class)
-    private fun getText(xpp: XmlPullParser): String {
-        val eventType = xpp.next()
-        return if (eventType != XmlPullParser.TEXT) "" else xpp.text
-    }
+internal interface AutoconfigParser {
+    fun parseSettings(inputStream: InputStream, email: EmailAddress): AutoconfigParserResult
 }
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParserException.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParserException.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0009c6bcf95a194d54a209337f2c5b7d1c03a057
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParserException.kt
@@ -0,0 +1,3 @@
+package app.k9mail.autodiscovery.autoconfig
+
+class AutoconfigParserException(message: String, cause: Throwable? = null) : RuntimeException(message, cause)
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParserResult.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParserResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d82caefecc5b320545b6161dd006b916c4f9a9fe
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParserResult.kt
@@ -0,0 +1,22 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.autodiscovery.api.IncomingServerSettings
+import app.k9mail.autodiscovery.api.OutgoingServerSettings
+
+/**
+ * Result type for [AutoconfigParser].
+ */
+internal sealed interface AutoconfigParserResult {
+    /**
+     * Server settings extracted from the Autoconfig XML.
+     */
+    data class Settings(
+        val incomingServerSettings: IncomingServerSettings,
+        val outgoingServerSettings: OutgoingServerSettings,
+    ) : AutoconfigParserResult
+
+    /**
+     * Server settings couldn't be extracted.
+     */
+    data class ParserError(val error: AutoconfigParserException) : AutoconfigParserResult
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigUrlProvider.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigUrlProvider.kt
index 94b3451ad333b6cf0d54422141a638a9d1c185a9..63ddafa094ecc305b803911b360a13520d0eeb5f 100644
--- a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigUrlProvider.kt
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigUrlProvider.kt
@@ -1,7 +1,9 @@
 package app.k9mail.autodiscovery.autoconfig
 
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.net.Domain
 import okhttp3.HttpUrl
 
-interface AutoconfigUrlProvider {
-    fun getAutoconfigUrls(email: String): List<HttpUrl>
+internal interface AutoconfigUrlProvider {
+    fun getAutoconfigUrls(domain: Domain, email: EmailAddress? = null): List<HttpUrl>
 }
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/BaseDomainExtractor.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/BaseDomainExtractor.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ac1f632036e7b6ac3f8500869419c9c43f2c5194
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/BaseDomainExtractor.kt
@@ -0,0 +1,12 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+
+/**
+ * Extract the base domain from a host name.
+ *
+ * An implementation needs to respect the [Public Suffix List](https://publicsuffix.org/).
+ */
+internal interface BaseDomainExtractor {
+    fun extractBaseDomain(domain: Domain): Domain
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/HttpFetchResult.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/HttpFetchResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c793225513db413e4d8e384345720e2f0035d0f3
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/HttpFetchResult.kt
@@ -0,0 +1,26 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import java.io.InputStream
+
+/**
+ * Result type for [HttpFetcher].
+ */
+internal sealed interface HttpFetchResult {
+    /**
+     * The HTTP request returned a success response.
+     *
+     * @param inputStream Contains the response body.
+     * @param isTrusted `true` iff all associated requests were using HTTPS with a trusted certificate.
+     */
+    data class SuccessResponse(
+        val inputStream: InputStream,
+        val isTrusted: Boolean,
+    ) : HttpFetchResult
+
+    /**
+     * The server returned an error response.
+     *
+     * @param code The HTTP status code.
+     */
+    data class ErrorResponse(val code: Int) : HttpFetchResult
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/HttpFetcher.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/HttpFetcher.kt
new file mode 100644
index 0000000000000000000000000000000000000000..66cd98c3c50efe84f3fb018336ac61ac7b79beae
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/HttpFetcher.kt
@@ -0,0 +1,7 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import okhttp3.HttpUrl
+
+internal interface HttpFetcher {
+    suspend fun fetch(url: HttpUrl): HttpFetchResult
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/IspDbAutoconfigUrlProvider.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/IspDbAutoconfigUrlProvider.kt
index e5ce650ce19bf5a41d7678b1c19fabd50426ef27..3217e31fa7a3789551baeeff46728df53d29bd38 100644
--- a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/IspDbAutoconfigUrlProvider.kt
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/IspDbAutoconfigUrlProvider.kt
@@ -1,22 +1,20 @@
 package app.k9mail.autodiscovery.autoconfig
 
-import com.fsck.k9.helper.EmailHelper
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.net.Domain
 import okhttp3.HttpUrl
 import okhttp3.HttpUrl.Companion.toHttpUrl
 
-class IspDbAutoconfigUrlProvider : AutoconfigUrlProvider {
-    override fun getAutoconfigUrls(email: String): List<HttpUrl> {
-        val domain = EmailHelper.getDomainFromEmailAddress(email)
-        requireNotNull(domain) { "Couldn't extract domain from email address: $email" }
-
+internal class IspDbAutoconfigUrlProvider : AutoconfigUrlProvider {
+    override fun getAutoconfigUrls(domain: Domain, email: EmailAddress?): List<HttpUrl> {
         return listOf(createIspDbUrl(domain))
     }
 
-    private fun createIspDbUrl(domain: String): HttpUrl {
+    private fun createIspDbUrl(domain: Domain): HttpUrl {
         // https://autoconfig.thunderbird.net/v1.1/{domain}
         return "https://autoconfig.thunderbird.net/v1.1/".toHttpUrl()
             .newBuilder()
-            .addPathSegment(domain)
+            .addPathSegment(domain.value)
             .build()
     }
 }
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MiniDnsMxResolver.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MiniDnsMxResolver.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a76c8ca1fa7abd3d6c15e1f1e07cef92be925737
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MiniDnsMxResolver.kt
@@ -0,0 +1,21 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+import app.k9mail.core.common.net.toDomain
+import org.minidns.hla.ResolverApi
+import org.minidns.record.MX
+
+internal class MiniDnsMxResolver : MxResolver {
+    override fun lookup(domain: Domain): MxLookupResult {
+        val result = ResolverApi.INSTANCE.resolve(domain.value, MX::class.java)
+
+        val mxNames = result.answersOrEmptySet
+            .sortedBy { it.priority }
+            .map { it.target.toString().toDomain() }
+
+        return MxLookupResult(
+            mxNames = mxNames,
+            isTrusted = result.isAuthenticData,
+        )
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupAutoconfigDiscovery.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupAutoconfigDiscovery.kt
new file mode 100644
index 0000000000000000000000000000000000000000..55521c6ee1c7230f80bc4fd0d197436ef34a4113
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupAutoconfigDiscovery.kt
@@ -0,0 +1,97 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.autodiscovery.api.AutoDiscovery
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.NoUsableSettingsFound
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.Settings
+import app.k9mail.autodiscovery.api.AutoDiscoveryRunnable
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toDomain
+import app.k9mail.core.common.net.Domain
+import com.fsck.k9.logging.Timber
+import java.io.IOException
+import okhttp3.OkHttpClient
+
+class MxLookupAutoconfigDiscovery internal constructor(
+    private val mxResolver: SuspendableMxResolver,
+    private val baseDomainExtractor: BaseDomainExtractor,
+    private val subDomainExtractor: SubDomainExtractor,
+    private val urlProvider: AutoconfigUrlProvider,
+    private val autoconfigFetcher: AutoconfigFetcher,
+) : AutoDiscovery {
+
+    override fun initDiscovery(email: EmailAddress): List<AutoDiscoveryRunnable> {
+        return listOf(
+            AutoDiscoveryRunnable {
+                mxLookupAutoconfig(email)
+            },
+        )
+    }
+
+    @Suppress("ReturnCount")
+    private suspend fun mxLookupAutoconfig(email: EmailAddress): AutoDiscoveryResult {
+        val domain = email.domain.toDomain()
+
+        val mxLookupResult = mxLookup(domain) ?: return NoUsableSettingsFound
+        val mxHostName = mxLookupResult.mxNames.first()
+
+        val mxBaseDomain = getMxBaseDomain(mxHostName)
+        if (mxBaseDomain == domain) {
+            // Exit early to match Thunderbird's behavior.
+            return NoUsableSettingsFound
+        }
+
+        // In addition to just the base domain, also check the MX hostname without the first label to differentiate
+        // between Outlook.com/Hotmail and Office365 business domains.
+        val mxSubDomain = getNextSubDomain(mxHostName)?.takeIf { it != mxBaseDomain }
+
+        var latestResult: AutoDiscoveryResult = NoUsableSettingsFound
+        for (domainToCheck in listOfNotNull(mxSubDomain, mxBaseDomain)) {
+            for (autoconfigUrl in urlProvider.getAutoconfigUrls(domainToCheck)) {
+                val discoveryResult = autoconfigFetcher.fetchAutoconfig(autoconfigUrl, email)
+                if (discoveryResult is Settings) {
+                    return discoveryResult.copy(
+                        isTrusted = mxLookupResult.isTrusted && discoveryResult.isTrusted,
+                    )
+                }
+
+                latestResult = discoveryResult
+            }
+        }
+
+        return latestResult
+    }
+
+    private suspend fun mxLookup(domain: Domain): MxLookupResult? {
+        // Only return the most preferred entry to match Thunderbird's behavior.
+        return try {
+            mxResolver.lookup(domain).takeIf { it.mxNames.isNotEmpty() }
+        } catch (e: IOException) {
+            Timber.d(e, "Failed to get MX record for domain: %s", domain.value)
+            null
+        }
+    }
+
+    private fun getMxBaseDomain(mxHostName: Domain): Domain {
+        return baseDomainExtractor.extractBaseDomain(mxHostName)
+    }
+
+    private fun getNextSubDomain(domain: Domain): Domain? {
+        return subDomainExtractor.extractSubDomain(domain)
+    }
+}
+
+fun createMxLookupAutoconfigDiscovery(okHttpClient: OkHttpClient): MxLookupAutoconfigDiscovery {
+    val baseDomainExtractor = OkHttpBaseDomainExtractor()
+    val autoconfigFetcher = RealAutoconfigFetcher(
+        fetcher = OkHttpFetcher(okHttpClient),
+        parser = SuspendableAutoconfigParser(RealAutoconfigParser()),
+    )
+    return MxLookupAutoconfigDiscovery(
+        mxResolver = SuspendableMxResolver(MiniDnsMxResolver()),
+        baseDomainExtractor = baseDomainExtractor,
+        subDomainExtractor = RealSubDomainExtractor(baseDomainExtractor),
+        urlProvider = IspDbAutoconfigUrlProvider(),
+        autoconfigFetcher = autoconfigFetcher,
+    )
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupResult.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..772668907ac88bb93d1e9c3068da77723fe28d0f
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupResult.kt
@@ -0,0 +1,14 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+
+/**
+ * Result for [MxResolver].
+ *
+ * @param mxNames The hostnames from the MX records.
+ * @param isTrusted `true` iff the results were properly signed (DNSSEC) or were retrieved using a secure channel.
+ */
+data class MxLookupResult(
+    val mxNames: List<Domain>,
+    val isTrusted: Boolean,
+)
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxResolver.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxResolver.kt
new file mode 100644
index 0000000000000000000000000000000000000000..921017b83117bacd307a716984c336a5f9df64e4
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxResolver.kt
@@ -0,0 +1,10 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+
+/**
+ * Look up MX records for a domain.
+ */
+internal interface MxResolver {
+    fun lookup(domain: Domain): MxLookupResult
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpBaseDomainExtractor.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpBaseDomainExtractor.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9bd89e49b61b8a3bc6b10ca834fcc5932814c8ae
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpBaseDomainExtractor.kt
@@ -0,0 +1,18 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+import app.k9mail.core.common.net.toDomain
+import okhttp3.HttpUrl
+
+internal class OkHttpBaseDomainExtractor : BaseDomainExtractor {
+    override fun extractBaseDomain(domain: Domain): Domain {
+        return domain.value.toHttpUrlOrNull().topPrivateDomain()?.toDomain() ?: domain
+    }
+
+    private fun String.toHttpUrlOrNull(): HttpUrl {
+        return HttpUrl.Builder()
+            .scheme("https")
+            .host(this)
+            .build()
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpFetcher.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpFetcher.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1526b8b90424276f8d10234745b70e13bbd7e115
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpFetcher.kt
@@ -0,0 +1,63 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import java.io.IOException
+import kotlin.coroutines.resume
+import kotlinx.coroutines.suspendCancellableCoroutine
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.HttpUrl
+import okhttp3.OkHttpClient
+import okhttp3.Request.Builder
+import okhttp3.Response
+
+internal class OkHttpFetcher(
+    private val okHttpClient: OkHttpClient,
+) : HttpFetcher {
+
+    override suspend fun fetch(url: HttpUrl): HttpFetchResult {
+        return suspendCancellableCoroutine { cancellableContinuation ->
+            val request = Builder()
+                .url(url)
+                .build()
+
+            val call = okHttpClient.newCall(request)
+
+            cancellableContinuation.invokeOnCancellation {
+                call.cancel()
+            }
+
+            val responseCallback = object : Callback {
+                override fun onFailure(call: Call, e: IOException) {
+                    cancellableContinuation.cancel(e)
+                }
+
+                override fun onResponse(call: Call, response: Response) {
+                    if (response.isSuccessful) {
+                        val result = HttpFetchResult.SuccessResponse(
+                            inputStream = response.body!!.byteStream(),
+                            isTrusted = response.isTrusted(),
+                        )
+                        cancellableContinuation.resume(result)
+                    } else {
+                        // We don't care about the body of error responses.
+                        response.close()
+
+                        val result = HttpFetchResult.ErrorResponse(response.code)
+                        cancellableContinuation.resume(result)
+                    }
+                }
+            }
+
+            call.enqueue(responseCallback)
+        }
+    }
+
+    private tailrec fun Response.isTrusted(): Boolean {
+        val priorResponse = priorResponse
+        return when {
+            !request.isHttps -> false
+            priorResponse == null -> true
+            else -> priorResponse.isTrusted()
+        }
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/ProviderAutoconfigUrlProvider.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/ProviderAutoconfigUrlProvider.kt
index 1f4be940cbda10b007c8dde191db951320d90dd3..664f4b351eee1c9b1b26738cf962cab887df88d4 100644
--- a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/ProviderAutoconfigUrlProvider.kt
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/ProviderAutoconfigUrlProvider.kt
@@ -1,13 +1,11 @@
 package app.k9mail.autodiscovery.autoconfig
 
-import com.fsck.k9.helper.EmailHelper
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.net.Domain
 import okhttp3.HttpUrl
 
-class ProviderAutoconfigUrlProvider(private val config: AutoconfigUrlConfig) : AutoconfigUrlProvider {
-    override fun getAutoconfigUrls(email: String): List<HttpUrl> {
-        val domain = EmailHelper.getDomainFromEmailAddress(email)
-        requireNotNull(domain) { "Couldn't extract domain from email address: $email" }
-
+internal class ProviderAutoconfigUrlProvider(private val config: AutoconfigUrlConfig) : AutoconfigUrlProvider {
+    override fun getAutoconfigUrls(domain: Domain, email: EmailAddress?): List<HttpUrl> {
         return buildList {
             add(createProviderUrl(domain, email, useHttps = true))
             add(createDomainUrl(domain, email, useHttps = true))
@@ -19,31 +17,31 @@ class ProviderAutoconfigUrlProvider(private val config: AutoconfigUrlConfig) : A
         }
     }
 
-    private fun createProviderUrl(domain: String, email: String, useHttps: Boolean): HttpUrl {
+    private fun createProviderUrl(domain: Domain, email: EmailAddress?, useHttps: Boolean): HttpUrl {
         // https://autoconfig.{domain}/mail/config-v1.1.xml?emailaddress={email}
         // http://autoconfig.{domain}/mail/config-v1.1.xml?emailaddress={email}
         return HttpUrl.Builder()
             .scheme(if (useHttps) "https" else "http")
-            .host("autoconfig.$domain")
+            .host("autoconfig.${domain.value}")
             .addEncodedPathSegments("mail/config-v1.1.xml")
             .apply {
-                if (config.includeEmailAddress) {
-                    addQueryParameter("emailaddress", email)
+                if (email != null && config.includeEmailAddress) {
+                    addQueryParameter("emailaddress", email.address)
                 }
             }
             .build()
     }
 
-    private fun createDomainUrl(domain: String, email: String, useHttps: Boolean): HttpUrl {
+    private fun createDomainUrl(domain: Domain, email: EmailAddress?, useHttps: Boolean): HttpUrl {
         // https://{domain}/.well-known/autoconfig/mail/config-v1.1.xml?emailaddress={email}
         // http://{domain}/.well-known/autoconfig/mail/config-v1.1.xml?emailaddress={email}
         return HttpUrl.Builder()
             .scheme(if (useHttps) "https" else "http")
-            .host(domain)
+            .host(domain.value)
             .addEncodedPathSegments(".well-known/autoconfig/mail/config-v1.1.xml")
             .apply {
-                if (config.includeEmailAddress) {
-                    addQueryParameter("emailaddress", email)
+                if (email != null && config.includeEmailAddress) {
+                    addQueryParameter("emailaddress", email.address)
                 }
             }
             .build()
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigFetcher.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigFetcher.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0dd0e7ddd4d170ee9974b7e9be3c345e97a73da4
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigFetcher.kt
@@ -0,0 +1,55 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.autoconfig.AutoconfigParserResult.ParserError
+import app.k9mail.autodiscovery.autoconfig.AutoconfigParserResult.Settings
+import app.k9mail.autodiscovery.autoconfig.HttpFetchResult.ErrorResponse
+import app.k9mail.autodiscovery.autoconfig.HttpFetchResult.SuccessResponse
+import app.k9mail.core.common.mail.EmailAddress
+import com.fsck.k9.logging.Timber
+import java.io.IOException
+import okhttp3.HttpUrl
+
+internal class RealAutoconfigFetcher(
+    private val fetcher: HttpFetcher,
+    private val parser: SuspendableAutoconfigParser,
+) : AutoconfigFetcher {
+    override suspend fun fetchAutoconfig(autoconfigUrl: HttpUrl, email: EmailAddress): AutoDiscoveryResult {
+        return try {
+            when (val fetchResult = fetcher.fetch(autoconfigUrl)) {
+                is SuccessResponse -> {
+                    parseSettings(fetchResult, email, autoconfigUrl)
+                }
+                is ErrorResponse -> AutoDiscoveryResult.NoUsableSettingsFound
+            }
+        } catch (e: IOException) {
+            Timber.d(e, "Error fetching Autoconfig from URL: %s", autoconfigUrl)
+            AutoDiscoveryResult.NetworkError(e)
+        }
+    }
+
+    private suspend fun parseSettings(
+        fetchResult: SuccessResponse,
+        email: EmailAddress,
+        autoconfigUrl: HttpUrl,
+    ): AutoDiscoveryResult {
+        return try {
+            fetchResult.inputStream.use { inputStream ->
+                return when (val parserResult = parser.parseSettings(inputStream, email)) {
+                    is Settings -> {
+                        AutoDiscoveryResult.Settings(
+                            incomingServerSettings = parserResult.incomingServerSettings,
+                            outgoingServerSettings = parserResult.outgoingServerSettings,
+                            isTrusted = fetchResult.isTrusted,
+                        )
+                    }
+
+                    is ParserError -> AutoDiscoveryResult.NoUsableSettingsFound
+                }
+            }
+        } catch (e: AutoconfigParserException) {
+            Timber.d(e, "Failed to parse config from URL: %s", autoconfigUrl)
+            AutoDiscoveryResult.NoUsableSettingsFound
+        }
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigParser.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigParser.kt
new file mode 100644
index 0000000000000000000000000000000000000000..047c0af125f0dfd57d9895fa3a3dc0f77b851615
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigParser.kt
@@ -0,0 +1,313 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.autodiscovery.api.AuthenticationType
+import app.k9mail.autodiscovery.api.AuthenticationType.OAuth2
+import app.k9mail.autodiscovery.api.AuthenticationType.PasswordCleartext
+import app.k9mail.autodiscovery.api.AuthenticationType.PasswordEncrypted
+import app.k9mail.autodiscovery.api.ConnectionSecurity
+import app.k9mail.autodiscovery.api.ConnectionSecurity.StartTLS
+import app.k9mail.autodiscovery.api.ConnectionSecurity.TLS
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.IncomingServerSettings
+import app.k9mail.autodiscovery.api.OutgoingServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.net.HostNameUtils
+import app.k9mail.core.common.net.Hostname
+import app.k9mail.core.common.net.Port
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+import com.fsck.k9.logging.Timber
+import java.io.InputStream
+import java.io.InputStreamReader
+import org.xmlpull.v1.XmlPullParser
+import org.xmlpull.v1.XmlPullParserException
+import org.xmlpull.v1.XmlPullParserFactory
+
+private typealias ServerSettingsFactory<T> = (
+    hostname: Hostname,
+    port: Port,
+    connectionSecurity: ConnectionSecurity,
+    authenticationType: AuthenticationType,
+    username: String,
+) -> T
+
+internal class RealAutoconfigParser : AutoconfigParser {
+    override fun parseSettings(inputStream: InputStream, email: EmailAddress): AutoconfigParserResult {
+        return try {
+            ClientConfigParser(inputStream, email).parse()
+        } catch (e: XmlPullParserException) {
+            AutoconfigParserResult.ParserError(error = AutoconfigParserException("Error parsing Autoconfig XML", e))
+        } catch (e: AutoconfigParserException) {
+            AutoconfigParserResult.ParserError(e)
+        }
+    }
+}
+
+@Suppress("TooManyFunctions")
+private class ClientConfigParser(
+    private val inputStream: InputStream,
+    private val email: EmailAddress,
+) {
+    private val localPart = email.localPart
+    private val domain = email.domain.normalized
+
+    private val pullParser: XmlPullParser = XmlPullParserFactory.newInstance().newPullParser().apply {
+        setInput(InputStreamReader(inputStream))
+    }
+
+    fun parse(): AutoconfigParserResult {
+        var result: AutoconfigParserResult? = null
+        do {
+            val eventType = pullParser.next()
+
+            if (eventType == XmlPullParser.START_TAG) {
+                when (pullParser.name) {
+                    "clientConfig" -> {
+                        result = parseClientConfig()
+                    }
+                    else -> skipElement()
+                }
+            }
+        } while (eventType != XmlPullParser.END_DOCUMENT)
+
+        if (result == null) {
+            parserError("Missing 'clientConfig' element")
+        }
+
+        return result
+    }
+
+    private fun parseClientConfig(): AutoconfigParserResult {
+        var result: AutoconfigParserResult? = null
+
+        readElement { eventType ->
+            if (eventType == XmlPullParser.START_TAG) {
+                when (pullParser.name) {
+                    "emailProvider" -> {
+                        result = parseEmailProvider()
+                    }
+                    else -> skipElement()
+                }
+            }
+        }
+
+        return result ?: parserError("Missing 'emailProvider' element")
+    }
+
+    private fun parseEmailProvider(): AutoconfigParserResult {
+        var domainFound = false
+        var incomingServerSettings: IncomingServerSettings? = null
+        var outgoingServerSettings: OutgoingServerSettings? = null
+
+        // The 'id' attribute is required (but not really used) by Thunderbird desktop.
+        val emailProviderId = pullParser.getAttributeValue(null, "id")
+        if (emailProviderId == null) {
+            parserError("Missing 'emailProvider.id' attribute")
+        } else if (!emailProviderId.isValidHostname()) {
+            parserError("Invalid 'emailProvider.id' attribute")
+        }
+
+        readElement { eventType ->
+            if (eventType == XmlPullParser.START_TAG) {
+                when (pullParser.name) {
+                    "domain" -> {
+                        val domain = readText()
+                        if (domain.isValidHostname()) {
+                            domainFound = true
+                        }
+                    }
+                    "incomingServer" -> {
+                        val serverSettings = parseServer("imap", ::createImapServerSettings)
+                        if (incomingServerSettings == null) {
+                            incomingServerSettings = serverSettings
+                        }
+                    }
+                    "outgoingServer" -> {
+                        val serverSettings = parseServer("smtp", ::createSmtpServerSettings)
+                        if (outgoingServerSettings == null) {
+                            outgoingServerSettings = serverSettings
+                        }
+                    }
+                    else -> {
+                        skipElement()
+                    }
+                }
+            }
+        }
+
+        // Thunderbird desktop requires at least one valid 'domain' element.
+        if (!domainFound) {
+            parserError("Valid 'domain' element required")
+        }
+
+        return AutoconfigParserResult.Settings(
+            incomingServerSettings = incomingServerSettings ?: parserError("Missing 'incomingServer' element"),
+            outgoingServerSettings = outgoingServerSettings ?: parserError("Missing 'outgoingServer' element"),
+        )
+    }
+
+    private fun <T> parseServer(
+        protocolType: String,
+        createServerSettings: ServerSettingsFactory<T>,
+    ): T? {
+        val type = pullParser.getAttributeValue(null, "type")
+        if (type != protocolType) {
+            Timber.d("Unsupported '%s[type]' value: '%s'", pullParser.name, type)
+            skipElement()
+            return null
+        }
+
+        var hostname: String? = null
+        var port: Int? = null
+        var userName: String? = null
+        var authenticationType: AuthenticationType? = null
+        var connectionSecurity: ConnectionSecurity? = null
+
+        readElement { eventType ->
+            if (eventType == XmlPullParser.START_TAG) {
+                when (pullParser.name) {
+                    "hostname" -> hostname = readHostname()
+                    "port" -> port = readPort()
+                    "username" -> userName = readUsername()
+                    "authentication" -> authenticationType = readAuthentication(authenticationType)
+                    "socketType" -> connectionSecurity = readSocketType()
+                }
+            }
+        }
+
+        val finalHostname = hostname ?: parserError("Missing 'hostname' element")
+        val finalPort = port ?: parserError("Missing 'port' element")
+        val finalUserName = userName ?: parserError("Missing 'username' element")
+        val finalAuthenticationType = authenticationType ?: parserError("No usable 'authentication' element found")
+        val finalConnectionSecurity = connectionSecurity ?: parserError("Missing 'socketType' element")
+
+        return createServerSettings(
+            finalHostname.toHostname(),
+            finalPort.toPort(),
+            finalConnectionSecurity,
+            finalAuthenticationType,
+            finalUserName,
+        )
+    }
+
+    private fun readHostname(): String {
+        val hostNameText = readText()
+        val hostName = hostNameText.replaceVariables()
+        return hostName.takeIf { it.isValidHostname() }
+            ?: parserError("Invalid 'hostname' value: '$hostNameText'")
+    }
+
+    private fun readPort(): Int {
+        val portText = readText()
+        return portText.toIntOrNull()?.takeIf { it.isValidPort() }
+            ?: parserError("Invalid 'port' value: '$portText'")
+    }
+
+    private fun readUsername(): String = readText().replaceVariables()
+
+    private fun readAuthentication(authenticationType: AuthenticationType?): AuthenticationType? {
+        return authenticationType ?: readText().toAuthenticationType()
+    }
+
+    private fun readSocketType() = readText().toConnectionSecurity()
+
+    private fun String.toAuthenticationType(): AuthenticationType? {
+        return when (this) {
+            "OAuth2" -> OAuth2
+            "password-cleartext" -> PasswordCleartext
+            "password-encrypted" -> PasswordEncrypted
+            else -> {
+                Timber.d("Ignoring unknown 'authentication' value '$this'")
+                null
+            }
+        }
+    }
+
+    private fun String.toConnectionSecurity(): ConnectionSecurity {
+        return when (this) {
+            "SSL" -> TLS
+            "STARTTLS" -> StartTLS
+            else -> parserError("Unknown 'socketType' value: '$this'")
+        }
+    }
+
+    private fun readElement(block: (Int) -> Unit) {
+        require(pullParser.eventType == XmlPullParser.START_TAG)
+
+        val tagName = pullParser.name
+        val depth = pullParser.depth
+        while (true) {
+            when (val eventType = pullParser.next()) {
+                XmlPullParser.END_DOCUMENT -> {
+                    parserError("End of document reached while reading element '$tagName'")
+                }
+                XmlPullParser.END_TAG -> {
+                    if (pullParser.name == tagName && pullParser.depth == depth) return
+                }
+                else -> {
+                    block(eventType)
+                }
+            }
+        }
+    }
+
+    private fun readText(): String {
+        var text = ""
+        readElement { eventType ->
+            when (eventType) {
+                XmlPullParser.TEXT -> {
+                    text = pullParser.text
+                }
+                else -> {
+                    parserError("Expected text, but got ${XmlPullParser.TYPES[eventType]}")
+                }
+            }
+        }
+
+        return text
+    }
+
+    private fun skipElement() {
+        Timber.d("Skipping element '%s'", pullParser.name)
+        readElement { /* Do nothing */ }
+    }
+
+    private fun parserError(message: String): Nothing {
+        throw AutoconfigParserException(message)
+    }
+
+    private fun String.isValidHostname(): Boolean {
+        val cleanUpHostName = HostNameUtils.cleanUpHostName(this)
+        return HostNameUtils.isLegalHostNameOrIP(cleanUpHostName) != null
+    }
+
+    @Suppress("MagicNumber")
+    private fun Int.isValidPort() = this in 0..65535
+
+    private fun String.replaceVariables(): String {
+        return replace("%EMAILDOMAIN%", domain)
+            .replace("%EMAILLOCALPART%", localPart)
+            .replace("%EMAILADDRESS%", email.address)
+    }
+
+    private fun createImapServerSettings(
+        hostname: Hostname,
+        port: Port,
+        connectionSecurity: ConnectionSecurity,
+        authenticationType: AuthenticationType,
+        username: String,
+    ): ImapServerSettings {
+        return ImapServerSettings(hostname, port, connectionSecurity, authenticationType, username)
+    }
+
+    private fun createSmtpServerSettings(
+        hostname: Hostname,
+        port: Port,
+        connectionSecurity: ConnectionSecurity,
+        authenticationType: AuthenticationType,
+        username: String,
+    ): SmtpServerSettings {
+        return SmtpServerSettings(hostname, port, connectionSecurity, authenticationType, username)
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealSubDomainExtractor.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealSubDomainExtractor.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1ba2f4200e7f768f9baab1870e8465f1ded05d26
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealSubDomainExtractor.kt
@@ -0,0 +1,26 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+import app.k9mail.core.common.net.toDomain
+
+internal class RealSubDomainExtractor(private val baseDomainExtractor: BaseDomainExtractor) : SubDomainExtractor {
+    @Suppress("ReturnCount")
+    override fun extractSubDomain(domain: Domain): Domain? {
+        val baseDomain = baseDomainExtractor.extractBaseDomain(domain)
+        if (baseDomain == domain) {
+            // The domain doesn't have a sub domain.
+            return null
+        }
+
+        val baseDomainString = baseDomain.value
+        val domainPrefix = domain.value.removeSuffix(".$baseDomainString")
+        val index = domainPrefix.indexOf('.')
+        if (index == -1) {
+            // The prefix is the sub domain. When we remove it only the base domain remains.
+            return baseDomain
+        }
+
+        val prefixWithoutFirstLabel = domainPrefix.substring(index + 1)
+        return "$prefixWithoutFirstLabel.$baseDomainString".toDomain()
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SubDomainExtractor.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SubDomainExtractor.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0935b772413449df5d668994403e5fb0ce615af5
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SubDomainExtractor.kt
@@ -0,0 +1,12 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+
+/**
+ * Extract the sub domain from a host name.
+ *
+ * An implementation needs to respect the [Public Suffix List](https://publicsuffix.org/).
+ */
+internal interface SubDomainExtractor {
+    fun extractSubDomain(domain: Domain): Domain?
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SuspendableAutoconfigParser.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SuspendableAutoconfigParser.kt
new file mode 100644
index 0000000000000000000000000000000000000000..bd523482dc8a94c04f71653dcbbd41284857fe25
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SuspendableAutoconfigParser.kt
@@ -0,0 +1,14 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.mail.EmailAddress
+import java.io.InputStream
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runInterruptible
+
+internal class SuspendableAutoconfigParser(private val autoconfigParser: AutoconfigParser) {
+    suspend fun parseSettings(inputStream: InputStream, email: EmailAddress): AutoconfigParserResult {
+        return runInterruptible(Dispatchers.IO) {
+            autoconfigParser.parseSettings(inputStream, email)
+        }
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SuspendableMxResolver.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SuspendableMxResolver.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a620deea899f7ed1bb9c514b0afdf8a6f7034670
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SuspendableMxResolver.kt
@@ -0,0 +1,13 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runInterruptible
+
+internal class SuspendableMxResolver(private val mxResolver: MxResolver) {
+    suspend fun lookup(domain: Domain): MxLookupResult {
+        return runInterruptible(Dispatchers.IO) {
+            mxResolver.lookup(domain)
+        }
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigDiscoveryTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigDiscoveryTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d077ce2e3bb250a66dc1e0b14383c32cf3f1037b
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigDiscoveryTest.kt
@@ -0,0 +1,69 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.autodiscovery.autoconfig.MockAutoconfigFetcher.Companion.RESULT_ONE
+import app.k9mail.autodiscovery.autoconfig.MockAutoconfigFetcher.Companion.RESULT_TWO
+import app.k9mail.core.common.mail.toUserEmailAddress
+import app.k9mail.core.common.net.toDomain
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.extracting
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import kotlin.test.Test
+import kotlinx.coroutines.test.runTest
+import okhttp3.HttpUrl.Companion.toHttpUrl
+
+private val IRRELEVANT_EMAIL_ADDRESS = "irrelevant@domain.example".toUserEmailAddress()
+
+class AutoconfigDiscoveryTest {
+    private val urlProvider = MockAutoconfigUrlProvider()
+    private val autoconfigFetcher = MockAutoconfigFetcher()
+    private val discovery = AutoconfigDiscovery(urlProvider, autoconfigFetcher)
+
+    @Test
+    fun `AutoconfigFetcher and AutoconfigParser should only be called when AutoDiscoveryRunnable is run`() = runTest {
+        val emailAddress = "user@domain.example".toUserEmailAddress()
+        val autoconfigUrl = "https://autoconfig.domain.invalid/mail/config-v1.1.xml".toHttpUrl()
+        urlProvider.addResult(listOf(autoconfigUrl))
+        autoconfigFetcher.addResult(RESULT_ONE)
+
+        val autoDiscoveryRunnables = discovery.initDiscovery(emailAddress)
+
+        assertThat(autoDiscoveryRunnables).hasSize(1)
+        assertThat(urlProvider.callArguments).containsExactly("domain.example".toDomain() to emailAddress)
+        assertThat(autoconfigFetcher.callCount).isEqualTo(0)
+
+        val discoveryResult = autoDiscoveryRunnables.first().run()
+
+        assertThat(autoconfigFetcher.callArguments).containsExactly(autoconfigUrl to emailAddress)
+        assertThat(discoveryResult).isEqualTo(RESULT_ONE)
+    }
+
+    @Test
+    fun `Two Autoconfig URLs should return two AutoDiscoveryRunnables`() = runTest {
+        val urlOne = "https://autoconfig.domain1.invalid/mail/config-v1.1.xml".toHttpUrl()
+        val urlTwo = "https://autoconfig.domain2.invalid/mail/config-v1.1.xml".toHttpUrl()
+
+        urlProvider.addResult(listOf(urlOne, urlTwo))
+        autoconfigFetcher.apply {
+            addResult(RESULT_ONE)
+            addResult(RESULT_TWO)
+        }
+
+        val autoDiscoveryRunnables = discovery.initDiscovery(IRRELEVANT_EMAIL_ADDRESS)
+
+        assertThat(autoDiscoveryRunnables).hasSize(2)
+
+        val discoveryResultOne = autoDiscoveryRunnables[0].run()
+
+        assertThat(autoconfigFetcher.callArguments).extracting { it.first }.containsExactly(urlOne)
+        assertThat(discoveryResultOne).isEqualTo(RESULT_ONE)
+
+        autoconfigFetcher.callArguments.clear()
+
+        val discoveryResultTwo = autoDiscoveryRunnables[1].run()
+
+        assertThat(autoconfigFetcher.callArguments).extracting { it.first }.containsExactly(urlTwo)
+        assertThat(discoveryResultTwo).isEqualTo(RESULT_TWO)
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/IspDbAutoconfigUrlProviderTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/IspDbAutoconfigUrlProviderTest.kt
index 2bbb3f3899c80caee1f62eece4163509e187b2aa..2b6613ffcd58c6902540c0ee233ba4d7449ecfed 100644
--- a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/IspDbAutoconfigUrlProviderTest.kt
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/IspDbAutoconfigUrlProviderTest.kt
@@ -1,7 +1,9 @@
 package app.k9mail.autodiscovery.autoconfig
 
+import app.k9mail.core.common.net.toDomain
 import assertk.assertThat
 import assertk.assertions.containsExactly
+import assertk.assertions.extracting
 import org.junit.Test
 
 class IspDbAutoconfigUrlProviderTest {
@@ -9,9 +11,11 @@ class IspDbAutoconfigUrlProviderTest {
 
     @Test
     fun `getAutoconfigUrls with ASCII email address`() {
-        val autoconfigUrls = urlProvider.getAutoconfigUrls("test@domain.example")
+        val domain = "domain.example".toDomain()
 
-        assertThat(autoconfigUrls.map { it.toString() }).containsExactly(
+        val autoconfigUrls = urlProvider.getAutoconfigUrls(domain)
+
+        assertThat(autoconfigUrls).extracting { it.toString() }.containsExactly(
             "https://autoconfig.thunderbird.net/v1.1/domain.example",
         )
     }
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MiniDnsMxResolverTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MiniDnsMxResolverTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1389217a17cb721f0909bf1b5c62b1beef815de0
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MiniDnsMxResolverTest.kt
@@ -0,0 +1,34 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.toDomain
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.containsExactlyInAnyOrder
+import assertk.assertions.extracting
+import assertk.assertions.index
+import assertk.assertions.isEqualTo
+import kotlin.test.Ignore
+import kotlin.test.Test
+
+class MiniDnsMxResolverTest {
+    private val resolver = MiniDnsMxResolver()
+
+    @Test
+    @Ignore("Requires internet")
+    fun `MX lookup for known domain`() {
+        val domain = "thunderbird.net".toDomain()
+
+        val result = resolver.lookup(domain)
+
+        assertThat(result.mxNames).extracting { it.value }.all {
+            index(0).isEqualTo("aspmx.l.google.com")
+            containsExactlyInAnyOrder(
+                "aspmx.l.google.com",
+                "alt1.aspmx.l.google.com",
+                "alt2.aspmx.l.google.com",
+                "alt4.aspmx.l.google.com",
+                "alt3.aspmx.l.google.com",
+            )
+        }
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockAutoconfigFetcher.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockAutoconfigFetcher.kt
new file mode 100644
index 0000000000000000000000000000000000000000..aa8e5ac91cb27b07331713463a9cbb65d3563714
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockAutoconfigFetcher.kt
@@ -0,0 +1,72 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.autodiscovery.api.AuthenticationType.PasswordCleartext
+import app.k9mail.autodiscovery.api.AuthenticationType.PasswordEncrypted
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.ConnectionSecurity.StartTLS
+import app.k9mail.autodiscovery.api.ConnectionSecurity.TLS
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+import okhttp3.HttpUrl
+
+internal class MockAutoconfigFetcher : AutoconfigFetcher {
+    val callArguments = mutableListOf<Pair<HttpUrl, EmailAddress>>()
+
+    val callCount: Int
+        get() = callArguments.size
+
+    private val results = mutableListOf<AutoDiscoveryResult>()
+
+    fun addResult(discoveryResult: AutoDiscoveryResult) {
+        results.add(discoveryResult)
+    }
+
+    override suspend fun fetchAutoconfig(autoconfigUrl: HttpUrl, email: EmailAddress): AutoDiscoveryResult {
+        callArguments.add(autoconfigUrl to email)
+
+        check(results.isNotEmpty()) {
+            "MockAutoconfigFetcher.fetchAutoconfig($autoconfigUrl) called but no result provided"
+        }
+        return results.removeAt(0)
+    }
+
+    companion object {
+        val RESULT_ONE = AutoDiscoveryResult.Settings(
+            incomingServerSettings = ImapServerSettings(
+                hostname = "imap.domain.example".toHostname(),
+                port = 993.toPort(),
+                connectionSecurity = TLS,
+                authenticationType = PasswordCleartext,
+                username = "irrelevant@domain.example",
+            ),
+            outgoingServerSettings = SmtpServerSettings(
+                hostname = "smtp.domain.example".toHostname(),
+                port = 465.toPort(),
+                connectionSecurity = TLS,
+                authenticationType = PasswordCleartext,
+                username = "irrelevant@domain.example",
+            ),
+            isTrusted = true,
+        )
+        val RESULT_TWO = AutoDiscoveryResult.Settings(
+            incomingServerSettings = ImapServerSettings(
+                hostname = "imap.company.example".toHostname(),
+                port = 143.toPort(),
+                connectionSecurity = StartTLS,
+                authenticationType = PasswordEncrypted,
+                username = "irrelevant@company.example",
+            ),
+            outgoingServerSettings = SmtpServerSettings(
+                hostname = "smtp.company.example".toHostname(),
+                port = 587.toPort(),
+                connectionSecurity = StartTLS,
+                authenticationType = PasswordEncrypted,
+                username = "irrelevant@company.example",
+            ),
+            isTrusted = true,
+        )
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockAutoconfigUrlProvider.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockAutoconfigUrlProvider.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d3a4d1c279ae516de9468730c42673b59c75062a
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockAutoconfigUrlProvider.kt
@@ -0,0 +1,25 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.net.Domain
+import okhttp3.HttpUrl
+
+internal class MockAutoconfigUrlProvider : AutoconfigUrlProvider {
+    val callArguments = mutableListOf<Pair<Domain, EmailAddress?>>()
+
+    val callCount: Int
+        get() = callArguments.size
+
+    private val results = mutableListOf<List<HttpUrl>>()
+
+    fun addResult(urls: List<HttpUrl>) {
+        results.add(urls)
+    }
+
+    override fun getAutoconfigUrls(domain: Domain, email: EmailAddress?): List<HttpUrl> {
+        callArguments.add(domain to email)
+
+        check(results.isNotEmpty()) { "getAutoconfigUrls($domain, $email) called but no result provided" }
+        return results.removeAt(0)
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockMxResolver.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockMxResolver.kt
new file mode 100644
index 0000000000000000000000000000000000000000..60285566260185c6a9bbbd0ee03bc8ff66401b44
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockMxResolver.kt
@@ -0,0 +1,27 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+
+class MockMxResolver : MxResolver {
+    val callArguments = mutableListOf<Domain>()
+
+    val callCount: Int
+        get() = callArguments.size
+
+    private val results = mutableListOf<MxLookupResult>()
+
+    fun addResult(domain: Domain, isTrusted: Boolean = true) {
+        results.add(MxLookupResult(mxNames = listOf(domain), isTrusted = isTrusted))
+    }
+
+    fun addResult(domains: List<Domain>) {
+        results.add(MxLookupResult(mxNames = domains, isTrusted = true))
+    }
+
+    override fun lookup(domain: Domain): MxLookupResult {
+        callArguments.add(domain)
+
+        check(results.isNotEmpty()) { "lookup($domain) called but no result provided" }
+        return results.removeAt(0)
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupAutoconfigDiscoveryTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupAutoconfigDiscoveryTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0e12e3c0824a73a4b7c0efb37988639517d2b3ac
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupAutoconfigDiscoveryTest.kt
@@ -0,0 +1,128 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.NoUsableSettingsFound
+import app.k9mail.autodiscovery.autoconfig.MockAutoconfigFetcher.Companion.RESULT_ONE
+import app.k9mail.core.common.mail.toUserEmailAddress
+import app.k9mail.core.common.net.toDomain
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.extracting
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import kotlin.test.Test
+import kotlinx.coroutines.test.runTest
+import okhttp3.HttpUrl.Companion.toHttpUrl
+
+class MxLookupAutoconfigDiscoveryTest {
+    private val mxResolver = MockMxResolver()
+    private val baseDomainExtractor = OkHttpBaseDomainExtractor()
+    private val urlProvider = MockAutoconfigUrlProvider()
+    private val autoconfigFetcher = MockAutoconfigFetcher()
+    private val discovery = MxLookupAutoconfigDiscovery(
+        mxResolver = SuspendableMxResolver(mxResolver),
+        baseDomainExtractor = baseDomainExtractor,
+        subDomainExtractor = RealSubDomainExtractor(baseDomainExtractor),
+        urlProvider = urlProvider,
+        autoconfigFetcher = autoconfigFetcher,
+    )
+
+    @Test
+    fun `AutoconfigUrlProvider should be called with MX base domain`() = runTest {
+        val emailAddress = "user@company.example".toUserEmailAddress()
+        mxResolver.addResult("mx.emailprovider.example".toDomain())
+        urlProvider.addResult(listOf("https://ispdb.invalid/emailprovider.example".toHttpUrl()))
+        autoconfigFetcher.addResult(RESULT_ONE)
+
+        val autoDiscoveryRunnables = discovery.initDiscovery(emailAddress)
+
+        assertThat(autoDiscoveryRunnables).hasSize(1)
+        assertThat(mxResolver.callCount).isEqualTo(0)
+        assertThat(autoconfigFetcher.callCount).isEqualTo(0)
+
+        val discoveryResult = autoDiscoveryRunnables.first().run()
+
+        assertThat(mxResolver.callArguments).containsExactly("company.example".toDomain())
+        assertThat(urlProvider.callArguments).extracting { it.first }
+            .containsExactly("emailprovider.example".toDomain())
+        assertThat(autoconfigFetcher.callCount).isEqualTo(1)
+        assertThat(discoveryResult).isEqualTo(RESULT_ONE)
+    }
+
+    @Test
+    fun `AutoconfigUrlProvider should be called with MX base domain and subdomain`() = runTest {
+        val emailAddress = "user@company.example".toUserEmailAddress()
+        mxResolver.addResult("mx.something.emailprovider.example".toDomain())
+        urlProvider.apply {
+            addResult(listOf("https://ispdb.invalid/something.emailprovider.example".toHttpUrl()))
+            addResult(listOf("https://ispdb.invalid/emailprovider.example".toHttpUrl()))
+        }
+        autoconfigFetcher.apply {
+            addResult(NoUsableSettingsFound)
+            addResult(NoUsableSettingsFound)
+        }
+
+        val autoDiscoveryRunnables = discovery.initDiscovery(emailAddress)
+        val discoveryResult = autoDiscoveryRunnables.first().run()
+
+        assertThat(urlProvider.callArguments).extracting { it.first }.containsExactly(
+            "something.emailprovider.example".toDomain(),
+            "emailprovider.example".toDomain(),
+        )
+        assertThat(autoconfigFetcher.callCount).isEqualTo(2)
+        assertThat(discoveryResult).isEqualTo(NoUsableSettingsFound)
+    }
+
+    @Test
+    fun `skip Autoconfig lookup when MX lookup does not return a result`() = runTest {
+        val emailAddress = "user@company.example".toUserEmailAddress()
+        mxResolver.addResult(emptyList())
+
+        val autoDiscoveryRunnables = discovery.initDiscovery(emailAddress)
+        val discoveryResult = autoDiscoveryRunnables.first().run()
+
+        assertThat(mxResolver.callCount).isEqualTo(1)
+        assertThat(urlProvider.callCount).isEqualTo(0)
+        assertThat(autoconfigFetcher.callCount).isEqualTo(0)
+        assertThat(discoveryResult).isEqualTo(NoUsableSettingsFound)
+    }
+
+    @Test
+    fun `skip Autoconfig lookup when base domain of MX record is email domain`() = runTest {
+        val emailAddress = "user@company.example".toUserEmailAddress()
+        mxResolver.addResult("mx.company.example".toDomain())
+
+        val autoDiscoveryRunnables = discovery.initDiscovery(emailAddress)
+        val discoveryResult = autoDiscoveryRunnables.first().run()
+
+        assertThat(mxResolver.callCount).isEqualTo(1)
+        assertThat(urlProvider.callCount).isEqualTo(0)
+        assertThat(autoconfigFetcher.callCount).isEqualTo(0)
+        assertThat(discoveryResult).isEqualTo(NoUsableSettingsFound)
+    }
+
+    @Test
+    fun `isTrusted should be false when MxLookupResult_isTrusted is false`() = runTest {
+        val emailAddress = "user@company.example".toUserEmailAddress()
+        mxResolver.addResult("mx.emailprovider.example".toDomain(), isTrusted = false)
+        urlProvider.addResult(listOf("https://ispdb.invalid/emailprovider.example".toHttpUrl()))
+        autoconfigFetcher.addResult(RESULT_ONE.copy(isTrusted = true))
+
+        val autoDiscoveryRunnables = discovery.initDiscovery(emailAddress)
+        val discoveryResult = autoDiscoveryRunnables.first().run()
+
+        assertThat(discoveryResult).isEqualTo(RESULT_ONE.copy(isTrusted = false))
+    }
+
+    @Test
+    fun `isTrusted should be false when AutoDiscoveryResult_isTrusted from AutoconfigFetcher is false`() = runTest {
+        val emailAddress = "user@company.example".toUserEmailAddress()
+        mxResolver.addResult("mx.emailprovider.example".toDomain(), isTrusted = true)
+        urlProvider.addResult(listOf("https://ispdb.invalid/emailprovider.example".toHttpUrl()))
+        autoconfigFetcher.addResult(RESULT_ONE.copy(isTrusted = false))
+
+        val autoDiscoveryRunnables = discovery.initDiscovery(emailAddress)
+        val discoveryResult = autoDiscoveryRunnables.first().run()
+
+        assertThat(discoveryResult).isEqualTo(RESULT_ONE.copy(isTrusted = false))
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpBaseDomainExtractorTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpBaseDomainExtractorTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1b75bb2d6f36f6c71925c11267ddba78c2552f58
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpBaseDomainExtractorTest.kt
@@ -0,0 +1,46 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.toDomain
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class OkHttpBaseDomainExtractorTest {
+    private val baseDomainExtractor = OkHttpBaseDomainExtractor()
+
+    @Test
+    fun `basic domain`() {
+        val domain = "domain.example".toDomain()
+
+        val result = baseDomainExtractor.extractBaseDomain(domain)
+
+        assertThat(result).isEqualTo(domain)
+    }
+
+    @Test
+    fun `basic subdomain`() {
+        val domain = "subdomain.domain.example".toDomain()
+
+        val result = baseDomainExtractor.extractBaseDomain(domain)
+
+        assertThat(result).isEqualTo("domain.example".toDomain())
+    }
+
+    @Test
+    fun `domain with public suffix`() {
+        val domain = "example.co.uk".toDomain()
+
+        val result = baseDomainExtractor.extractBaseDomain(domain)
+
+        assertThat(result).isEqualTo(domain)
+    }
+
+    @Test
+    fun `subdomain with public suffix`() {
+        val domain = "subdomain.example.co.uk".toDomain()
+
+        val result = baseDomainExtractor.extractBaseDomain(domain)
+
+        assertThat(result).isEqualTo("example.co.uk".toDomain())
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigFetcherTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpFetcherTest.kt
similarity index 50%
rename from feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigFetcherTest.kt
rename to feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpFetcherTest.kt
index 9e713f4f305cce97a157ebbe059a5d3b7a18f174..a5a20fe8ec61881ec63b30a4949c43a6e67a9fdd 100644
--- a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigFetcherTest.kt
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpFetcherTest.kt
@@ -1,30 +1,34 @@
 package app.k9mail.autodiscovery.autoconfig
 
+import assertk.all
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.isEqualTo
-import assertk.assertions.isNull
-import kotlin.test.assertNotNull
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import java.net.UnknownHostException
+import kotlinx.coroutines.test.runTest
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.OkHttpClient
 import okhttp3.mockwebserver.MockResponse
 import okhttp3.mockwebserver.MockWebServer
 import org.junit.Test
 
-class AutoconfigFetcherTest {
-    private val fetcher = AutoconfigFetcher(OkHttpClient.Builder().build())
+class OkHttpFetcherTest {
+    private val fetcher = OkHttpFetcher(OkHttpClient.Builder().build())
 
     @Test
-    fun shouldHandleNonexistentUrl() {
+    fun shouldHandleNonexistentUrl() = runTest {
         val nonExistentUrl =
             "https://autoconfig.domain.invalid/mail/config-v1.1.xml?emailaddress=test%40domain.example".toHttpUrl()
 
-        val inputStream = fetcher.fetchAutoconfigFile(nonExistentUrl)
-
-        assertThat(inputStream).isNull()
+        assertFailure {
+            fetcher.fetch(nonExistentUrl)
+        }.isInstanceOf<UnknownHostException>()
     }
 
     @Test
-    fun shouldHandleEmptyResponse() {
+    fun shouldHandleEmptyResponse() = runTest {
         val server = MockWebServer().apply {
             this.enqueue(
                 MockResponse()
@@ -35,10 +39,10 @@ class AutoconfigFetcherTest {
         }
         val url = server.url("/empty/")
 
-        val inputStream = fetcher.fetchAutoconfigFile(url)
+        val result = fetcher.fetch(url)
 
-        assertNotNull(inputStream) { inputStream ->
-            assertThat(inputStream.available()).isEqualTo(0)
+        assertThat(result).isInstanceOf<HttpFetchResult.SuccessResponse>().all {
+            prop(HttpFetchResult.SuccessResponse::inputStream).transform { it.available() }.isEqualTo(0)
         }
     }
 }
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/ProviderAutoconfigUrlProviderTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/ProviderAutoconfigUrlProviderTest.kt
index 18607eca9c5f4c46b3522afd31a5cd417e806f3d..2a2250dfd1f0c82ecbfa52332e1928469393b175 100644
--- a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/ProviderAutoconfigUrlProviderTest.kt
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/ProviderAutoconfigUrlProviderTest.kt
@@ -1,16 +1,22 @@
 package app.k9mail.autodiscovery.autoconfig
 
+import app.k9mail.core.common.mail.toUserEmailAddress
+import app.k9mail.core.common.net.toDomain
 import assertk.assertThat
 import assertk.assertions.containsExactly
 import org.junit.Test
 
 class ProviderAutoconfigUrlProviderTest {
+    private val domain = "domain.example".toDomain()
+    private val email = "test@domain.example".toUserEmailAddress()
+
     @Test
     fun `getAutoconfigUrls with http allowed and email address included`() {
         val urlProvider = ProviderAutoconfigUrlProvider(
             AutoconfigUrlConfig(httpsOnly = false, includeEmailAddress = true),
         )
-        val autoconfigUrls = urlProvider.getAutoconfigUrls("test@domain.example")
+
+        val autoconfigUrls = urlProvider.getAutoconfigUrls(domain, email)
 
         assertThat(autoconfigUrls.map { it.toString() }).containsExactly(
             "https://autoconfig.domain.example/mail/config-v1.1.xml?emailaddress=test%40domain.example",
@@ -25,7 +31,8 @@ class ProviderAutoconfigUrlProviderTest {
         val urlProvider = ProviderAutoconfigUrlProvider(
             AutoconfigUrlConfig(httpsOnly = true, includeEmailAddress = true),
         )
-        val autoconfigUrls = urlProvider.getAutoconfigUrls("test@domain.example")
+
+        val autoconfigUrls = urlProvider.getAutoconfigUrls(domain, email)
 
         assertThat(autoconfigUrls.map { it.toString() }).containsExactly(
             "https://autoconfig.domain.example/mail/config-v1.1.xml?emailaddress=test%40domain.example",
@@ -38,7 +45,8 @@ class ProviderAutoconfigUrlProviderTest {
         val urlProvider = ProviderAutoconfigUrlProvider(
             AutoconfigUrlConfig(httpsOnly = true, includeEmailAddress = false),
         )
-        val autoconfigUrls = urlProvider.getAutoconfigUrls("test@domain.example")
+
+        val autoconfigUrls = urlProvider.getAutoconfigUrls(domain, email)
 
         assertThat(autoconfigUrls.map { it.toString() }).containsExactly(
             "https://autoconfig.domain.example/mail/config-v1.1.xml",
@@ -51,7 +59,24 @@ class ProviderAutoconfigUrlProviderTest {
         val urlProvider = ProviderAutoconfigUrlProvider(
             AutoconfigUrlConfig(httpsOnly = false, includeEmailAddress = false),
         )
-        val autoconfigUrls = urlProvider.getAutoconfigUrls("test@domain.example")
+
+        val autoconfigUrls = urlProvider.getAutoconfigUrls(domain, email)
+
+        assertThat(autoconfigUrls.map { it.toString() }).containsExactly(
+            "https://autoconfig.domain.example/mail/config-v1.1.xml",
+            "https://domain.example/.well-known/autoconfig/mail/config-v1.1.xml",
+            "http://autoconfig.domain.example/mail/config-v1.1.xml",
+            "http://domain.example/.well-known/autoconfig/mail/config-v1.1.xml",
+        )
+    }
+
+    @Test
+    fun `getAutoconfigUrls with http allowed and email address included, but none provided`() {
+        val urlProvider = ProviderAutoconfigUrlProvider(
+            AutoconfigUrlConfig(httpsOnly = false, includeEmailAddress = true),
+        )
+
+        val autoconfigUrls = urlProvider.getAutoconfigUrls(domain)
 
         assertThat(autoconfigUrls.map { it.toString() }).containsExactly(
             "https://autoconfig.domain.example/mail/config-v1.1.xml",
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigParserTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigParserTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..31448eebac7228bd45248f17240e3d03d46496b0
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigParserTest.kt
@@ -0,0 +1,558 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.autodiscovery.api.AuthenticationType.OAuth2
+import app.k9mail.autodiscovery.api.AuthenticationType.PasswordCleartext
+import app.k9mail.autodiscovery.api.ConnectionSecurity.StartTLS
+import app.k9mail.autodiscovery.api.ConnectionSecurity.TLS
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.autodiscovery.autoconfig.AutoconfigParserResult.ParserError
+import app.k9mail.autodiscovery.autoconfig.AutoconfigParserResult.Settings
+import app.k9mail.core.common.mail.toUserEmailAddress
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+import assertk.assertThat
+import assertk.assertions.hasMessage
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.isNotNull
+import assertk.assertions.prop
+import java.io.InputStream
+import org.intellij.lang.annotations.Language
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Document
+import org.jsoup.nodes.Element
+import org.jsoup.parser.Parser
+import org.junit.Test
+
+private const val PRINT_MODIFIED_XML = false
+
+class RealAutoconfigParserTest {
+    private val parser = RealAutoconfigParser()
+
+    @Language("XML")
+    private val minimalConfig =
+        """
+        <?xml version="1.0" encoding="UTF-8"?>
+        <clientConfig version="1.1">
+          <emailProvider id="domain.example">
+            <domain>domain.example</domain>
+            <incomingServer type="imap">
+              <hostname>imap.domain.example</hostname>
+              <port>993</port>
+              <socketType>SSL</socketType>
+              <authentication>password-cleartext</authentication>
+              <username>%EMAILADDRESS%</username>
+            </incomingServer>
+            <outgoingServer type="smtp">
+              <hostname>smtp.domain.example</hostname>
+              <port>587</port>
+              <socketType>STARTTLS</socketType>
+              <authentication>password-cleartext</authentication>
+              <username>%EMAILADDRESS%</username>
+            </outgoingServer>
+          </emailProvider>
+        </clientConfig>
+        """.trimIndent()
+
+    private val irrelevantEmailAddress = "irrelevant@domain.example".toUserEmailAddress()
+
+    @Test
+    fun `minimal data`() {
+        val inputStream = minimalConfig.byteInputStream()
+
+        val result = parser.parseSettings(inputStream, email = "user@domain.example".toUserEmailAddress())
+
+        assertThat(result).isNotNull().isEqualTo(
+            Settings(
+                ImapServerSettings(
+                    hostname = "imap.domain.example".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = TLS,
+                    authenticationType = PasswordCleartext,
+                    username = "user@domain.example",
+                ),
+                SmtpServerSettings(
+                    hostname = "smtp.domain.example".toHostname(),
+                    port = 587.toPort(),
+                    connectionSecurity = StartTLS,
+                    authenticationType = PasswordCleartext,
+                    username = "user@domain.example",
+                ),
+            ),
+        )
+    }
+
+    @Test
+    fun `real-world data`() {
+        val inputStream = javaClass.getResourceAsStream("/2022-11-19-googlemail.com.xml")!!
+
+        val result = parser.parseSettings(inputStream, email = "test@gmail.com".toUserEmailAddress())
+
+        assertThat(result).isNotNull().isEqualTo(
+            Settings(
+                ImapServerSettings(
+                    hostname = "imap.gmail.com".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = TLS,
+                    authenticationType = OAuth2,
+                    username = "test@gmail.com",
+                ),
+                SmtpServerSettings(
+                    hostname = "smtp.gmail.com".toHostname(),
+                    port = 465.toPort(),
+                    connectionSecurity = TLS,
+                    authenticationType = OAuth2,
+                    username = "test@gmail.com",
+                ),
+            ),
+        )
+    }
+
+    @Test
+    fun `replace variables`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > hostname").text("%EMAILLOCALPART%.domain.example")
+            element("outgoingServer > hostname").text("%EMAILLOCALPART%.outgoing.domain.example")
+            element("outgoingServer > username").text("%EMAILDOMAIN%")
+        }
+
+        val result = parser.parseSettings(inputStream, email = "user@domain.example".toUserEmailAddress())
+
+        assertThat(result).isNotNull().isEqualTo(
+            Settings(
+                ImapServerSettings(
+                    hostname = "user.domain.example".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = TLS,
+                    authenticationType = PasswordCleartext,
+                    username = "user@domain.example",
+                ),
+                SmtpServerSettings(
+                    hostname = "user.outgoing.domain.example".toHostname(),
+                    port = 587.toPort(),
+                    connectionSecurity = StartTLS,
+                    authenticationType = PasswordCleartext,
+                    username = "domain.example",
+                ),
+            ),
+        )
+    }
+
+    @Test
+    fun `data with comments`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > hostname").prepend("<!-- comment -->")
+            element("incomingServer > port").prepend("<!-- comment -->")
+            element("incomingServer > socketType").prepend("<!-- comment -->")
+            element("incomingServer > authentication").prepend("<!-- comment -->")
+            element("incomingServer > username").prepend("<!-- comment -->")
+        }
+
+        val result = parser.parseSettings(inputStream, email = "user@domain.example".toUserEmailAddress())
+
+        assertThat(result).isInstanceOf<Settings>()
+            .prop(Settings::incomingServerSettings).isEqualTo(
+                ImapServerSettings(
+                    hostname = "imap.domain.example".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = TLS,
+                    authenticationType = PasswordCleartext,
+                    username = "user@domain.example",
+                ),
+            )
+    }
+
+    @Test
+    fun `ignore unsupported 'incomingServer' type`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer").insertBefore("""<incomingServer type="smtp"/>""")
+        }
+
+        val result = parser.parseSettings(inputStream, email = "user@domain.example".toUserEmailAddress())
+
+        assertThat(result).isInstanceOf<Settings>()
+            .prop(Settings::incomingServerSettings).isEqualTo(
+                ImapServerSettings(
+                    hostname = "imap.domain.example".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = TLS,
+                    authenticationType = PasswordCleartext,
+                    username = "user@domain.example",
+                ),
+            )
+    }
+
+    @Test
+    fun `ignore unsupported 'outgoingServer' type`() {
+        val inputStream = minimalConfig.withModifications {
+            element("outgoingServer").insertBefore("""<outgoingServer type="imap"/>""")
+        }
+
+        val result = parser.parseSettings(inputStream, email = "user@domain.example".toUserEmailAddress())
+
+        assertThat(result).isInstanceOf<Settings>()
+            .prop(Settings::outgoingServerSettings).isEqualTo(
+                SmtpServerSettings(
+                    hostname = "smtp.domain.example".toHostname(),
+                    port = 587.toPort(),
+                    connectionSecurity = StartTLS,
+                    authenticationType = PasswordCleartext,
+                    username = "user@domain.example",
+                ),
+            )
+    }
+
+    @Test
+    fun `empty authentication element should be ignored`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > authentication").insertBefore("<authentication></authentication>")
+        }
+
+        val result = parser.parseSettings(inputStream, email = "user@domain.example".toUserEmailAddress())
+
+        assertThat(result).isInstanceOf<Settings>()
+            .prop(Settings::incomingServerSettings).isEqualTo(
+                ImapServerSettings(
+                    hostname = "imap.domain.example".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = TLS,
+                    authenticationType = PasswordCleartext,
+                    username = "user@domain.example",
+                ),
+            )
+    }
+
+    @Test
+    fun `config with missing 'emailProvider id' attribute should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("emailProvider").removeAttr("id")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'emailProvider.id' attribute")
+    }
+
+    @Test
+    fun `config with invalid 'emailProvider id' attribute should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("emailProvider").attr("id", "-23")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Invalid 'emailProvider.id' attribute")
+    }
+
+    @Test
+    fun `config with missing domain element should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("emailProvider > domain").remove()
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Valid 'domain' element required")
+    }
+
+    @Test
+    fun `config with only invalid domain elements should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("emailProvider > domain").text("-invalid")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Valid 'domain' element required")
+    }
+
+    @Test
+    fun `config with missing 'incomingServer' element should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer").remove()
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'incomingServer' element")
+    }
+
+    @Test
+    fun `config with missing 'outgoingServer' element should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("outgoingServer").remove()
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'outgoingServer' element")
+    }
+
+    @Test
+    fun `incomingServer with missing hostname should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > hostname").remove()
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'hostname' element")
+    }
+
+    @Test
+    fun `incomingServer with invalid hostname should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > hostname").text("in valid")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Invalid 'hostname' value: 'in valid'")
+    }
+
+    @Test
+    fun `incomingServer with missing port should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > port").remove()
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'port' element")
+    }
+
+    @Test
+    fun `incomingServer with missing socketType should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > socketType").remove()
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'socketType' element")
+    }
+
+    @Test
+    fun `incomingServer with missing authentication should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > authentication").remove()
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("No usable 'authentication' element found")
+    }
+
+    @Test
+    fun `incomingServer with missing username should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > username").remove()
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'username' element")
+    }
+
+    @Test
+    fun `incomingServer with invalid port should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > port").text("invalid")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Invalid 'port' value: 'invalid'")
+    }
+
+    @Test
+    fun `incomingServer with out of range port number should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > port").text("100000")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Invalid 'port' value: '100000'")
+    }
+
+    @Test
+    fun `incomingServer with unknown socketType should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > socketType").text("TLS")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Unknown 'socketType' value: 'TLS'")
+    }
+
+    @Test
+    fun `element found when expecting text should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > hostname").html("imap.domain.example<element/>")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Expected text, but got START_TAG")
+    }
+
+    @Test
+    fun `ignore 'incomingServer' and 'outgoingServer' inside wrong element`() {
+        val inputStream = minimalConfig.withModifications {
+            element("emailProvider").tagName("madeUpTag")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'emailProvider' element")
+    }
+
+    @Test
+    fun `ignore 'incomingServer' inside unsupported 'incomingServer' element`() {
+        val inputStream = minimalConfig.withModifications {
+            val incomingServer = element("incomingServer")
+            val incomingServerXml = incomingServer.outerHtml()
+            incomingServer.attr("type", "unsupported")
+            incomingServer.html(incomingServerXml)
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'incomingServer' element")
+    }
+
+    @Test
+    fun `ignore 'outgoingServer' inside unsupported 'outgoingServer' element`() {
+        val inputStream = minimalConfig.withModifications {
+            val outgoingServer = element("outgoingServer")
+            val outgoingServerXml = outgoingServer.outerHtml()
+            outgoingServer.attr("type", "unsupported")
+            outgoingServer.html(outgoingServerXml)
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'outgoingServer' element")
+    }
+
+    @Test
+    fun `non XML data should throw`() {
+        val inputStream = "invalid".byteInputStream()
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Error parsing Autoconfig XML")
+    }
+
+    @Test
+    fun `wrong root element should throw`() {
+        @Language("XML")
+        val inputStream =
+            """
+            <?xml version="1.0" encoding="UTF-8"?>
+            <serverConfig></serverConfig>
+            """.trimIndent().byteInputStream()
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'clientConfig' element")
+    }
+
+    @Test
+    fun `syntactically incorrect XML should throw`() {
+        @Language("XML")
+        val inputStream =
+            """
+            <?xml version="1.0" encoding="UTF-8"?>
+            <clientConfig version="1.1">
+              <emailProvider id="domain.example">
+                <incomingServer type="imap">
+                  <hostname>imap.domain.example</hostname>
+                  <port>993</port>
+                  <socketType>SSL</socketType>
+                  <authentication>password-cleartext</authentication>
+                  <username>%EMAILADDRESS%</username>
+                </incomingServer>
+                <outgoingServer type="smtp">
+                  <hostname>smtp.domain.example</hostname>
+                  <port>465</port>
+                  <socketType>SSL</socketType>
+                  <authentication>password-cleartext</authentication>
+                  <username>%EMAILADDRESS%</username>
+                </outgoingServer>
+              <!-- Missing </emailProvider> -->
+            </clientConfig>
+            """.trimIndent().byteInputStream()
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Error parsing Autoconfig XML")
+    }
+
+    @Test
+    fun `incomplete XML should throw`() {
+        @Language("XML")
+        val inputStream =
+            """
+            <?xml version="1.0"?>
+            <clientConfig version="1.1">
+              <emailProvider id="domain.example">
+            """.trimIndent().byteInputStream()
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("End of document reached while reading element 'emailProvider'")
+    }
+
+    private fun String.withModifications(block: Document.() -> Unit): InputStream {
+        return Jsoup.parse(this, "", Parser.xmlParser())
+            .apply(block)
+            .toString()
+            .also {
+                if (PRINT_MODIFIED_XML) {
+                    println(it)
+                }
+            }
+            .byteInputStream()
+    }
+
+    private fun Document.element(query: String): Element {
+        return select(query).first() ?: error("Couldn't find element using '$query'")
+    }
+
+    private fun Element.insertBefore(xml: String) {
+        val index = siblingIndex()
+        parent()!!.apply {
+            append(xml)
+            val newElement = lastElementChild()!!
+            newElement.remove()
+            insertChildren(index, newElement)
+        }
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/RealSubDomainExtractorTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/RealSubDomainExtractorTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f7e65137aa496b36fc8bb7159c9af83a8261ff54
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/RealSubDomainExtractorTest.kt
@@ -0,0 +1,95 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+import app.k9mail.core.common.net.toDomain
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNull
+import kotlin.test.Test
+
+class RealSubDomainExtractorTest {
+    private val testBaseDomainExtractor = TestBaseDomainExtractor(baseDomain = "domain.example")
+    private val baseSubDomainExtractor = RealSubDomainExtractor(testBaseDomainExtractor)
+
+    @Test
+    fun `input has one more label than the base domain`() {
+        val domain = "subdomain.domain.example".toDomain()
+
+        val result = baseSubDomainExtractor.extractSubDomain(domain)
+
+        assertThat(result).isEqualTo("domain.example".toDomain())
+    }
+
+    @Test
+    fun `input has two more labels than the base domain`() {
+        val domain = "more.subdomain.domain.example".toDomain()
+
+        val result = baseSubDomainExtractor.extractSubDomain(domain)
+
+        assertThat(result).isEqualTo("subdomain.domain.example".toDomain())
+    }
+
+    @Test
+    fun `input has three more labels than the base domain`() {
+        val domain = "three.two.one.domain.example".toDomain()
+
+        val result = baseSubDomainExtractor.extractSubDomain(domain)
+
+        assertThat(result).isEqualTo("two.one.domain.example".toDomain())
+    }
+
+    @Test
+    fun `no sub domain available`() {
+        val domain = "domain.example".toDomain()
+
+        val result = baseSubDomainExtractor.extractSubDomain(domain)
+
+        assertThat(result).isNull()
+    }
+
+    @Test
+    fun `input has one more label than the base domain with public suffix`() {
+        val domain = "subdomain.example.co.uk".toDomain()
+        testBaseDomainExtractor.baseDomain = "example.co.uk"
+
+        val result = baseSubDomainExtractor.extractSubDomain(domain)
+
+        assertThat(result).isEqualTo("example.co.uk".toDomain())
+    }
+
+    @Test
+    fun `input has two more labels than the base domain with public suffix`() {
+        val domain = "more.subdomain.example.co.uk".toDomain()
+        testBaseDomainExtractor.baseDomain = "example.co.uk"
+
+        val result = baseSubDomainExtractor.extractSubDomain(domain)
+
+        assertThat(result).isEqualTo("subdomain.example.co.uk".toDomain())
+    }
+
+    @Test
+    fun `input has three more labels than the base domain with public suffix`() {
+        val domain = "three.two.one.example.co.uk".toDomain()
+        testBaseDomainExtractor.baseDomain = "example.co.uk"
+
+        val result = baseSubDomainExtractor.extractSubDomain(domain)
+
+        assertThat(result).isEqualTo("two.one.example.co.uk".toDomain())
+    }
+
+    @Test
+    fun `no sub domain available with public suffix`() {
+        val domain = "example.co.uk".toDomain()
+        testBaseDomainExtractor.baseDomain = "example.co.uk"
+
+        val result = baseSubDomainExtractor.extractSubDomain(domain)
+
+        assertThat(result).isNull()
+    }
+}
+
+private class TestBaseDomainExtractor(var baseDomain: String) : BaseDomainExtractor {
+    override fun extractBaseDomain(domain: Domain): Domain {
+        return Domain(baseDomain)
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/ThunderbirdAutoconfigTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/ThunderbirdAutoconfigTest.kt
deleted file mode 100644
index cbd2114207e4b5cb3192644dcf2d0b367632cd02..0000000000000000000000000000000000000000
--- a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/ThunderbirdAutoconfigTest.kt
+++ /dev/null
@@ -1,174 +0,0 @@
-package app.k9mail.autodiscovery.autoconfig
-
-import app.k9mail.autodiscovery.api.DiscoveredServerSettings
-import app.k9mail.autodiscovery.api.DiscoveryResults
-import assertk.assertThat
-import assertk.assertions.isEqualTo
-import assertk.assertions.isNotNull
-import com.fsck.k9.mail.AuthType
-import com.fsck.k9.mail.ConnectionSecurity
-import org.junit.Test
-
-class ThunderbirdAutoconfigTest {
-    private val parser = AutoconfigParser()
-
-    @Test
-    fun settingsExtract() {
-        val input =
-            """
-            <?xml version="1.0"?>
-            <clientConfig version="1.1">
-                <emailProvider id="metacode.biz">
-                    <domain>metacode.biz</domain>
-    
-                    <incomingServer type="imap">
-                        <hostname>imap.googlemail.com</hostname>
-                        <port>993</port>
-                        <socketType>SSL</socketType>
-                        <username>%EMAILADDRESS%</username>
-                        <authentication>OAuth2</authentication>
-                        <authentication>password-cleartext</authentication>
-                    </incomingServer>
-    
-                    <outgoingServer type="smtp">
-                        <hostname>smtp.googlemail.com</hostname>
-                        <port>465</port>
-                        <socketType>SSL</socketType>
-                        <username>%EMAILADDRESS%</username>
-                        <authentication>OAuth2</authentication>
-                        <authentication>password-cleartext</authentication>
-                        <addThisServer>true</addThisServer>
-                    </outgoingServer>
-                </emailProvider>
-            </clientConfig>
-            """.trimIndent().byteInputStream()
-
-        val connectionSettings = parser.parseSettings(input, "test@metacode.biz")
-
-        assertThat(connectionSettings).isNotNull()
-        assertThat(connectionSettings!!.incoming).isNotNull()
-        assertThat(connectionSettings.outgoing).isNotNull()
-        with(connectionSettings.incoming.first()) {
-            assertThat(host).isEqualTo("imap.googlemail.com")
-            assertThat(port).isEqualTo(993)
-            assertThat(username).isEqualTo("test@metacode.biz")
-        }
-        with(connectionSettings.outgoing.first()) {
-            assertThat(host).isEqualTo("smtp.googlemail.com")
-            assertThat(port).isEqualTo(465)
-            assertThat(username).isEqualTo("test@metacode.biz")
-        }
-    }
-
-    @Test
-    fun multipleServers() {
-        val input =
-            """
-            <?xml version="1.0"?>
-            <clientConfig version="1.1">
-                <emailProvider id="metacode.biz">
-                    <domain>metacode.biz</domain>
-    
-                    <incomingServer type="imap">
-                        <hostname>imap.googlemail.com</hostname>
-                        <port>993</port>
-                        <socketType>SSL</socketType>
-                        <username>%EMAILADDRESS%</username>
-                        <authentication>OAuth2</authentication>
-                        <authentication>password-cleartext</authentication>
-                    </incomingServer>
-    
-                    <outgoingServer type="smtp">
-                        <hostname>first</hostname>
-                        <port>465</port>
-                        <socketType>SSL</socketType>
-                        <username>%EMAILADDRESS%</username>
-                        <authentication>OAuth2</authentication>
-                        <authentication>password-cleartext</authentication>
-                        <addThisServer>true</addThisServer>
-                    </outgoingServer>
-    
-                    <outgoingServer type="smtp">
-                        <hostname>second</hostname>
-                        <port>465</port>
-                        <socketType>SSL</socketType>
-                        <username>%EMAILADDRESS%</username>
-                        <authentication>OAuth2</authentication>
-                        <authentication>password-cleartext</authentication>
-                        <addThisServer>true</addThisServer>
-                    </outgoingServer>
-                </emailProvider>
-            </clientConfig>
-            """.trimIndent().byteInputStream()
-
-        val discoveryResults = parser.parseSettings(input, "test@metacode.biz")
-
-        assertThat(discoveryResults).isNotNull()
-        assertThat(discoveryResults!!.outgoing).isNotNull()
-        with(discoveryResults.outgoing[0]) {
-            assertThat(host).isEqualTo("first")
-            assertThat(port).isEqualTo(465)
-            assertThat(username).isEqualTo("test@metacode.biz")
-        }
-        with(discoveryResults.outgoing[1]) {
-            assertThat(host).isEqualTo("second")
-            assertThat(port).isEqualTo(465)
-            assertThat(username).isEqualTo("test@metacode.biz")
-        }
-    }
-
-    @Test
-    fun invalidResponse() {
-        val input =
-            """
-            <?xml version="1.0"?>
-                <clientConfig version="1.1">
-                    <emailProvider id="metacode.biz">
-                        <domain>metacode.biz</domain>
-            """.trimIndent().byteInputStream()
-
-        val connectionSettings = parser.parseSettings(input, "test@metacode.biz")
-
-        assertThat(connectionSettings).isEqualTo(DiscoveryResults(listOf(), listOf()))
-    }
-
-    @Test
-    fun incompleteConfiguration() {
-        val input =
-            """
-            <?xml version="1.0"?>
-            <clientConfig version="1.1">
-                <emailProvider id="metacode.biz">
-                    <domain>metacode.biz</domain>
-    
-                    <incomingServer type="imap">
-                        <hostname>imap.googlemail.com</hostname>
-                        <port>993</port>
-                        <socketType>SSL</socketType>
-                        <username>%EMAILADDRESS%</username>
-                        <authentication>OAuth2</authentication>
-                        <authentication>password-cleartext</authentication>
-                    </incomingServer>
-                </emailProvider>
-            </clientConfig>
-            """.trimIndent().byteInputStream()
-
-        val connectionSettings = parser.parseSettings(input, "test@metacode.biz")
-
-        assertThat(connectionSettings).isEqualTo(
-            DiscoveryResults(
-                listOf(
-                    DiscoveredServerSettings(
-                        protocol = "imap",
-                        host = "imap.googlemail.com",
-                        port = 993,
-                        security = ConnectionSecurity.SSL_TLS_REQUIRED,
-                        authType = AuthType.PLAIN,
-                        username = "test@metacode.biz",
-                    ),
-                ),
-                listOf(),
-            ),
-        )
-    }
-}
diff --git a/feature/autodiscovery/autoconfig/src/test/resources/2022-11-19-googlemail.com.xml b/feature/autodiscovery/autoconfig/src/test/resources/2022-11-19-googlemail.com.xml
new file mode 100644
index 0000000000000000000000000000000000000000..e0e7c383ad2e7b157c8b4ba51f71cdcc30459ee5
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/resources/2022-11-19-googlemail.com.xml
@@ -0,0 +1,79 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<clientConfig version="1.1">
+  <emailProvider id="googlemail.com">
+    <domain>gmail.com</domain>
+    <domain>googlemail.com</domain>
+    <!-- MX, for Google Apps -->
+    <domain>google.com</domain>
+    <!-- HACK. Only add ISPs with 100000+ users here -->
+    <domain>jazztel.es</domain>
+
+    <displayName>Google Mail</displayName>
+    <displayShortName>GMail</displayShortName>
+
+    <incomingServer type="imap">
+      <hostname>imap.gmail.com</hostname>
+      <port>993</port>
+      <socketType>SSL</socketType>
+      <username>%EMAILADDRESS%</username>
+      <authentication>OAuth2</authentication>
+      <authentication>password-cleartext</authentication>
+    </incomingServer>
+    <incomingServer type="pop3">
+      <hostname>pop.gmail.com</hostname>
+      <port>995</port>
+      <socketType>SSL</socketType>
+      <username>%EMAILADDRESS%</username>
+      <authentication>OAuth2</authentication>
+      <authentication>password-cleartext</authentication>
+      <pop3>
+        <leaveMessagesOnServer>true</leaveMessagesOnServer>
+      </pop3>
+    </incomingServer>
+    <outgoingServer type="smtp">
+      <hostname>smtp.gmail.com</hostname>
+      <port>465</port>
+      <socketType>SSL</socketType>
+      <username>%EMAILADDRESS%</username>
+      <authentication>OAuth2</authentication>
+      <authentication>password-cleartext</authentication>
+    </outgoingServer>
+
+    <documentation url="http://mail.google.com/support/bin/answer.py?answer=13273">
+      <descr>How to enable IMAP/POP3 in GMail</descr>
+    </documentation>
+    <documentation url="http://mail.google.com/support/bin/topic.py?topic=12806">
+      <descr>How to configure email clients for IMAP</descr>
+    </documentation>
+    <documentation url="http://mail.google.com/support/bin/topic.py?topic=12805">
+      <descr>How to configure email clients for POP3</descr>
+    </documentation>
+    <documentation url="http://mail.google.com/support/bin/answer.py?answer=86399">
+      <descr>How to configure TB 2.0 for POP3</descr>
+    </documentation>
+  </emailProvider>
+
+  <oAuth2>
+    <issuer>accounts.google.com</issuer>
+    <!-- https://developers.google.com/identity/protocols/oauth2/scopes -->
+    <scope>https://mail.google.com/ https://www.googleapis.com/auth/contacts https://www.googleapis.com/auth/calendar https://www.googleapis.com/auth/carddav</scope>
+    <authURL>https://accounts.google.com/o/oauth2/auth</authURL>
+    <tokenURL>https://www.googleapis.com/oauth2/v3/token</tokenURL>
+  </oAuth2>
+
+  <enable visiturl="https://mail.google.com/mail/?ui=2&amp;shva=1#settings/fwdandpop">
+    <instruction>You need to enable IMAP access</instruction>
+  </enable>
+
+  <webMail>
+    <loginPage url="https://accounts.google.com/ServiceLogin?service=mail&amp;continue=http://mail.google.com/mail/" />
+    <loginPageInfo
+      url="https://accounts.google.com/ServiceLogin?service=mail&amp;continue=http://mail.google.com/mail/">
+      <username>%EMAILADDRESS%</username>
+      <usernameField id="Email" />
+      <passwordField id="Passwd" />
+      <loginButton id="signIn" />
+    </loginPageInfo>
+  </webMail>
+
+</clientConfig>
diff --git a/feature/autodiscovery/service/build.gradle.kts b/feature/autodiscovery/service/build.gradle.kts
new file mode 100644
index 0000000000000000000000000000000000000000..a7a4f7c0673ab0ae9756ffd4e45540499396f4d6
--- /dev/null
+++ b/feature/autodiscovery/service/build.gradle.kts
@@ -0,0 +1,13 @@
+plugins {
+    id(ThunderbirdPlugins.Library.jvm)
+    alias(libs.plugins.android.lint)
+}
+
+dependencies {
+    api(projects.feature.autodiscovery.autoconfig)
+
+    implementation(libs.kotlinx.coroutines.core)
+
+    testImplementation(libs.kotlinx.coroutines.test)
+    testImplementation(libs.kxml2)
+}
diff --git a/feature/autodiscovery/service/src/main/kotlin/app/k9mail/autodiscovery/service/PriorityParallelRunner.kt b/feature/autodiscovery/service/src/main/kotlin/app/k9mail/autodiscovery/service/PriorityParallelRunner.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4e6b8225f1febc96b9833ee47fc795bf3ead6955
--- /dev/null
+++ b/feature/autodiscovery/service/src/main/kotlin/app/k9mail/autodiscovery/service/PriorityParallelRunner.kt
@@ -0,0 +1,82 @@
+package app.k9mail.autodiscovery.service
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.NetworkError
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.NoUsableSettingsFound
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.Settings
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.UnexpectedException
+import app.k9mail.autodiscovery.api.AutoDiscoveryRunnable
+import kotlin.coroutines.cancellation.CancellationException
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineStart.LAZY
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
+
+/**
+ * Runs a list of [AutoDiscoveryRunnable]s with descending priority in parallel and returns the result with the highest
+ * priority.
+ *
+ * As soon as an [AutoDiscoveryRunnable] returns a [Settings] result, runnables with a lower priority are canceled.
+ */
+internal class PriorityParallelRunner(
+    private val runnables: List<AutoDiscoveryRunnable>,
+    private val coroutineDispatcher: CoroutineDispatcher = Dispatchers.IO,
+) {
+    suspend fun run(): AutoDiscoveryResult {
+        return coroutineScope {
+            val deferredList = buildList(capacity = runnables.size) {
+                // Create coroutines in reverse order. So ones with lower priority are created first.
+                for (runnable in runnables.reversed()) {
+                    val lowerPriorityCoroutines = toList()
+
+                    val deferred = async(coroutineDispatcher, start = LAZY) {
+                        runnable.run().also { discoveryResult ->
+                            if (discoveryResult is Settings) {
+                                // We've got a positive result, so cancel all coroutines with lower priority.
+                                lowerPriorityCoroutines.cancelAll()
+                            }
+                        }
+                    }
+
+                    add(deferred)
+                }
+            }.asReversed()
+
+            for (deferred in deferredList) {
+                deferred.start()
+            }
+
+            @Suppress("SwallowedException", "TooGenericExceptionCaught")
+            val discoveryResults = deferredList.map { deferred ->
+                try {
+                    deferred.await()
+                } catch (e: CancellationException) {
+                    null
+                } catch (e: Exception) {
+                    UnexpectedException(e)
+                }
+            }
+
+            val settingsResult = discoveryResults.firstOrNull { it is Settings }
+            if (settingsResult != null) {
+                settingsResult
+            } else {
+                val networkError = discoveryResults.firstOrNull { it is NetworkError }
+                val networkErrorCount = discoveryResults.count { it is NetworkError }
+                if (networkError != null && networkErrorCount == discoveryResults.size) {
+                    networkError
+                } else {
+                    NoUsableSettingsFound
+                }
+            }
+        }
+    }
+
+    private fun List<Deferred<AutoDiscoveryResult?>>.cancelAll() {
+        for (deferred in this) {
+            deferred.cancel()
+        }
+    }
+}
diff --git a/feature/autodiscovery/service/src/main/kotlin/app/k9mail/autodiscovery/service/RealAutoDiscoveryService.kt b/feature/autodiscovery/service/src/main/kotlin/app/k9mail/autodiscovery/service/RealAutoDiscoveryService.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2e05ebeba61cdb5cd96ae15c6bbddcc14f5f39c3
--- /dev/null
+++ b/feature/autodiscovery/service/src/main/kotlin/app/k9mail/autodiscovery/service/RealAutoDiscoveryService.kt
@@ -0,0 +1,40 @@
+package app.k9mail.autodiscovery.service
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.AutoDiscoveryService
+import app.k9mail.autodiscovery.autoconfig.AutoconfigUrlConfig
+import app.k9mail.autodiscovery.autoconfig.createIspDbAutoconfigDiscovery
+import app.k9mail.autodiscovery.autoconfig.createMxLookupAutoconfigDiscovery
+import app.k9mail.autodiscovery.autoconfig.createProviderAutoconfigDiscovery
+import app.k9mail.core.common.mail.EmailAddress
+import okhttp3.OkHttpClient
+
+/**
+ * Uses Thunderbird's Autoconfig mechanism to find mail server settings for a given email address.
+ */
+class RealAutoDiscoveryService(
+    private val okHttpClient: OkHttpClient,
+) : AutoDiscoveryService {
+
+    override suspend fun discover(email: EmailAddress): AutoDiscoveryResult {
+        val config = AutoconfigUrlConfig(
+            httpsOnly = false,
+            includeEmailAddress = false,
+        )
+
+        val providerDiscovery = createProviderAutoconfigDiscovery(okHttpClient, config)
+        val ispDbDiscovery = createIspDbAutoconfigDiscovery(okHttpClient)
+        val mxDiscovery = createMxLookupAutoconfigDiscovery(okHttpClient)
+
+        val runnables = listOf(
+            providerDiscovery,
+            ispDbDiscovery,
+            mxDiscovery,
+        ).flatMap { discovery ->
+            discovery.initDiscovery(email)
+        }
+
+        val runner = PriorityParallelRunner(runnables)
+        return runner.run()
+    }
+}
diff --git a/feature/autodiscovery/service/src/test/kotlin/app/k9mail/autodiscovery/service/PriorityParallelRunnerTest.kt b/feature/autodiscovery/service/src/test/kotlin/app/k9mail/autodiscovery/service/PriorityParallelRunnerTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..08195935b00400628c983a1d2955552397311774
--- /dev/null
+++ b/feature/autodiscovery/service/src/test/kotlin/app/k9mail/autodiscovery/service/PriorityParallelRunnerTest.kt
@@ -0,0 +1,179 @@
+package app.k9mail.autodiscovery.service
+
+import app.k9mail.autodiscovery.api.AuthenticationType.PasswordCleartext
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.NoUsableSettingsFound
+import app.k9mail.autodiscovery.api.AutoDiscoveryRunnable
+import app.k9mail.autodiscovery.api.ConnectionSecurity.StartTLS
+import app.k9mail.autodiscovery.api.ConnectionSecurity.TLS
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
+import assertk.assertions.isNull
+import assertk.assertions.isTrue
+import kotlin.test.Test
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.runTest
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class PriorityParallelRunnerTest {
+    @Test
+    fun `first runnable returning a success result should cancel remaining runnables`() = runTest {
+        var runnableTwoStarted = false
+        var runnableThreeStarted = false
+        var runnableTwoCompleted = false
+        var runnableThreeCompleted = false
+        val runnableOne = AutoDiscoveryRunnable {
+            delay(100)
+            DISCOVERY_RESULT_ONE
+        }
+        val runnableTwo = AutoDiscoveryRunnable {
+            runnableTwoStarted = true
+            delay(200)
+            runnableTwoCompleted = true
+            DISCOVERY_RESULT_TWO
+        }
+        val runnableThree = AutoDiscoveryRunnable {
+            runnableThreeStarted = true
+            delay(200)
+            runnableThreeCompleted = false
+            DISCOVERY_RESULT_TWO
+        }
+        val runner = PriorityParallelRunner(
+            runnables = listOf(runnableOne, runnableTwo, runnableThree),
+            coroutineDispatcher = StandardTestDispatcher(testScheduler),
+        )
+
+        var result: AutoDiscoveryResult? = null
+        launch {
+            result = runner.run()
+        }
+
+        testScheduler.advanceTimeBy(50)
+
+        assertThat(result).isNull()
+        assertThat(runnableTwoStarted).isTrue()
+        assertThat(runnableTwoCompleted).isFalse()
+        assertThat(runnableThreeStarted).isTrue()
+        assertThat(runnableThreeCompleted).isFalse()
+
+        testScheduler.advanceUntilIdle()
+
+        assertThat(result).isEqualTo(DISCOVERY_RESULT_ONE)
+        assertThat(runnableTwoCompleted).isFalse()
+        assertThat(runnableThreeCompleted).isFalse()
+    }
+
+    @Test
+    fun `highest priority result should be used even if it takes longer to be produced`() = runTest {
+        var runnableTwoCompleted = false
+        val runnableOne = AutoDiscoveryRunnable {
+            delay(100)
+            DISCOVERY_RESULT_ONE
+        }
+        val runnableTwo = AutoDiscoveryRunnable {
+            runnableTwoCompleted = true
+            DISCOVERY_RESULT_TWO
+        }
+        val runner = PriorityParallelRunner(
+            runnables = listOf(runnableOne, runnableTwo),
+            coroutineDispatcher = StandardTestDispatcher(testScheduler),
+        )
+
+        var result: AutoDiscoveryResult? = null
+        launch {
+            result = runner.run()
+        }
+
+        testScheduler.advanceTimeBy(50)
+
+        assertThat(result).isNull()
+        assertThat(runnableTwoCompleted).isTrue()
+
+        testScheduler.advanceUntilIdle()
+
+        assertThat(result).isEqualTo(DISCOVERY_RESULT_ONE)
+    }
+
+    @Test
+    fun `wait for higher priority runnable to complete`() = runTest {
+        var runnableOneCompleted = false
+        var runnableTwoCompleted = false
+        val runnableOne = AutoDiscoveryRunnable {
+            delay(100)
+            runnableOneCompleted = true
+            NO_DISCOVERY_RESULT
+        }
+        val runnableTwo = AutoDiscoveryRunnable {
+            runnableTwoCompleted = true
+            DISCOVERY_RESULT_TWO
+        }
+        val runner = PriorityParallelRunner(
+            runnables = listOf(runnableOne, runnableTwo),
+            coroutineDispatcher = StandardTestDispatcher(testScheduler),
+        )
+
+        var result: AutoDiscoveryResult? = null
+        launch {
+            result = runner.run()
+        }
+
+        testScheduler.advanceTimeBy(50)
+
+        assertThat(result).isNull()
+        assertThat(runnableOneCompleted).isFalse()
+        assertThat(runnableTwoCompleted).isTrue()
+
+        testScheduler.advanceTimeBy(100)
+
+        assertThat(result).isEqualTo(DISCOVERY_RESULT_TWO)
+        assertThat(runnableOneCompleted).isTrue()
+    }
+
+    companion object {
+        private val NO_DISCOVERY_RESULT: AutoDiscoveryResult = NoUsableSettingsFound
+
+        private val DISCOVERY_RESULT_ONE = AutoDiscoveryResult.Settings(
+            ImapServerSettings(
+                hostname = "imap.domain.example".toHostname(),
+                port = 993.toPort(),
+                connectionSecurity = TLS,
+                authenticationType = PasswordCleartext,
+                username = "user@domain.example",
+            ),
+            SmtpServerSettings(
+                hostname = "smtp.domain.example".toHostname(),
+                port = 587.toPort(),
+                connectionSecurity = StartTLS,
+                authenticationType = PasswordCleartext,
+                username = "user@domain.example",
+            ),
+            isTrusted = true,
+        )
+
+        private val DISCOVERY_RESULT_TWO = AutoDiscoveryResult.Settings(
+            ImapServerSettings(
+                hostname = "imap.domain.example".toHostname(),
+                port = 143.toPort(),
+                connectionSecurity = StartTLS,
+                authenticationType = PasswordCleartext,
+                username = "user@domain.example",
+            ),
+            SmtpServerSettings(
+                hostname = "smtp.domain.example".toHostname(),
+                port = 465.toPort(),
+                connectionSecurity = TLS,
+                authenticationType = PasswordCleartext,
+                username = "user@domain.example",
+            ),
+            isTrusted = true,
+        )
+    }
+}
diff --git a/feature/autodiscovery/srvrecords/src/test/kotlin/app/k9mail/autodiscovery/srvrecords/SrvServiceDiscoveryTest.kt b/feature/autodiscovery/srvrecords/src/test/kotlin/app/k9mail/autodiscovery/srvrecords/SrvServiceDiscoveryTest.kt
index 8656aa59cfe619ed965ed8752435aab62d589cd8..4f14836b36bd2fa2e767189a579c6b4c47aa4348 100644
--- a/feature/autodiscovery/srvrecords/src/test/kotlin/app/k9mail/autodiscovery/srvrecords/SrvServiceDiscoveryTest.kt
+++ b/feature/autodiscovery/srvrecords/src/test/kotlin/app/k9mail/autodiscovery/srvrecords/SrvServiceDiscoveryTest.kt
@@ -1,8 +1,15 @@
 package app.k9mail.autodiscovery.srvrecords
 
 import app.k9mail.autodiscovery.api.DiscoveryResults
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.extracting
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.prop
 import com.fsck.k9.mail.ConnectionSecurity
-import org.junit.Assert.assertEquals
 import org.junit.Test
 import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.mock
@@ -16,7 +23,7 @@ class SrvServiceDiscoveryTest {
         val srvServiceDiscovery = SrvServiceDiscovery(srvResolver)
         val result = srvServiceDiscovery.discover("test@example.com")
 
-        assertEquals(DiscoveryResults(listOf(), listOf()), result)
+        assertThat(result).isEqualTo(DiscoveryResults(incoming = listOf(), outgoing = listOf()))
     }
 
     @Test
@@ -31,8 +38,10 @@ class SrvServiceDiscoveryTest {
         val srvServiceDiscovery = SrvServiceDiscovery(srvResolver)
         val result = srvServiceDiscovery.discover("test@example.com")
 
-        assertEquals(2, result!!.incoming.size)
-        assertEquals(0, result.outgoing.size)
+        assertThat(result).isNotNull().all {
+            prop(DiscoveryResults::incoming).hasSize(2)
+            prop(DiscoveryResults::outgoing).hasSize(0)
+        }
     }
 
     @Test
@@ -55,8 +64,10 @@ class SrvServiceDiscoveryTest {
         val srvServiceDiscovery = SrvServiceDiscovery(srvResolver)
         val result = srvServiceDiscovery.discover("test@example.com")
 
-        assertEquals(0, result!!.incoming.size)
-        assertEquals(2, result.outgoing.size)
+        assertThat(result).isNotNull().all {
+            prop(DiscoveryResults::incoming).hasSize(0)
+            prop(DiscoveryResults::outgoing).hasSize(2)
+        }
     }
 
     @Test
@@ -131,24 +142,20 @@ class SrvServiceDiscoveryTest {
         val srvServiceDiscovery = SrvServiceDiscovery(srvResolver)
         val result = srvServiceDiscovery.discover("test@example.com")
 
-        assertEquals(
-            listOf(
+        assertThat(result).isNotNull().all {
+            prop(DiscoveryResults::outgoing).extracting { it.host }.containsExactly(
                 "smtp3.example.com",
                 "smtp1.example.com",
                 "smtp4.example.com",
                 "smtp2.example.com",
-            ),
-            result?.outgoing?.map { it.host },
-        )
-        assertEquals(
-            listOf(
+            )
+            prop(DiscoveryResults::incoming).extracting { it.host }.containsExactly(
                 "imaps1.example.com",
                 "imap1.example.com",
                 "imaps2.example.com",
                 "imap2.example.com",
-            ),
-            result?.incoming?.map { it.host },
-        )
+            )
+        }
     }
 
     private fun newMailService(
diff --git a/feature/onboarding/src/main/kotlin/app/k9mail/feature/onboarding/navigation/OnboardingNavigation.kt b/feature/onboarding/src/main/kotlin/app/k9mail/feature/onboarding/navigation/OnboardingNavigation.kt
index 72658cb47bca8e0460ed0af44aac5353ddc349af..86a700e1bb2e056224b87a43bb75dcf9d140b140 100644
--- a/feature/onboarding/src/main/kotlin/app/k9mail/feature/onboarding/navigation/OnboardingNavigation.kt
+++ b/feature/onboarding/src/main/kotlin/app/k9mail/feature/onboarding/navigation/OnboardingNavigation.kt
@@ -14,14 +14,14 @@ fun NavController.navigateToOnboarding(
     navigate(NAVIGATION_ROUTE_ONBOARDING, navOptions)
 }
 
-fun NavGraphBuilder.onboardingScreen(
-    onStartClick: () -> Unit,
-    onImportClick: () -> Unit,
+fun NavGraphBuilder.onboardingRoute(
+    onStart: () -> Unit,
+    onImport: () -> Unit,
 ) {
     composable(route = NAVIGATION_ROUTE_ONBOARDING) {
         OnboardingScreen(
-            onStartClick = onStartClick,
-            onImportClick = onImportClick,
+            onStartClick = onStart,
+            onImportClick = onImport,
         )
     }
 }
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 2985c41408ee39b8f7117ae6076a98ec92beb328..531b1cb6b601cef7bacb14972dab957a0c17c586 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -3,50 +3,52 @@
 
 [versions]
 gradle = "8.1.1"
-androidGradlePlugin = "8.0.1"
+androidGradlePlugin = "8.0.2"
 ktlint = "0.48.2"
 
-kotlin = "1.8.20"
-kotlinxCoroutines = "1.6.4"
+kotlin = "1.8.21"
+kotlinxCoroutines = "1.7.1"
 jetbrainsAnnotations = "24.0.1"
 androidxAppCompat = "1.6.1"
-androidxActivity = "1.7.1"
+androidxActivity = "1.7.2"
 androidxRecyclerView = "1.3.0"
 androidxLifecycle = "2.6.1"
-androidxNavigation = "2.5.3"
+androidxNavigation = "2.6.0"
 androidxConstraintLayout = "2.1.4"
-androidxFragment = "1.5.6"
-androidxCore = "1.10.0"
+androidxFragment = "1.6.0"
+androidxCore = "1.10.1"
 androidxCoreSplashscreen = "1.0.1"
 androidxPreference = "1.2.0"
 androidxDrawerLayout = "1.1.1"
 androidxTransition = "1.4.1"
-androidxComposeCompiler = "1.4.6"
-androidxComposeBom = "2023.04.01"
-androidxComposeMaterial = "1.3.1"
+androidxComposeCompiler = "1.4.7"
+androidxComposeBom = "2023.05.01"
+androidxComposeMaterial = "1.4.3"
 accompanist = "0.30.1"
 fastAdapter = "5.7.0"
 preferencesFix = "1.1.0"
 timber = "5.0.1"
-koinCore = "3.4.0"
-koinAndroid = "3.4.0"
+koinCore = "3.4.2"
+koinAndroid = "3.4.2"
+koinAndroidCompose = "3.4.5"
+koinTest = "3.4.1"
 mime4j = "0.8.9"
-okhttp = "4.10.0"
+okhttp = "4.11.0"
 glide = "4.15.1"
-moshi = "1.14.0"
-datastore = "1.0.0"
+moshi = "1.15.0"
 mockito = "5.3.1"
+datastore = "1.0.0"
 
 [plugins]
-android-application = { id = "com.android.application", version = "8.0.0" }
-android-library = { id = "com.android.library", version = "8.0.0" }
-android-lint = { id = "com.android.lint", version = "8.0.0" }
-ksp = "com.google.devtools.ksp:1.8.20-1.0.11"
+android-application = { id = "com.android.application", version.ref = "androidGradlePlugin" }
+android-library = { id = "com.android.library", version.ref = "androidGradlePlugin" }
+android-lint = { id = "com.android.lint", version.ref = "androidGradlePlugin" }
+ksp = "com.google.devtools.ksp:1.8.21-1.0.11"
 kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
 kotlin-parcelize = { id = "org.jetbrains.kotlin.plugin.parcelize", version.ref = "kotlin" }
 kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
 spotless = "com.diffplug.spotless:6.14.0"
-detekt = "io.gitlab.arturbosch.detekt:1.22.0"
+detekt = "io.gitlab.arturbosch.detekt:1.23.0"
 dependency-check = "com.github.ben-manes.versions:0.46.0"
 
 [libraries]
@@ -58,6 +60,7 @@ kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-c
 kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "kotlinxCoroutines" }
 kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinxCoroutines" }
 kotlinx-datetime = "org.jetbrains.kotlinx:kotlinx-datetime:0.4.0"
+kotlinx-collections-immutable = "org.jetbrains.kotlinx:kotlinx-collections-immutable:0.3.5"
 jetbrains-annotations = { module = "org.jetbrains:annotations", version.ref = "jetbrainsAnnotations" }
 androidx-appcompat = { module = "androidx.appcompat:appcompat", version.ref = "androidxAppCompat" }
 androidx-activity = { module = "androidx.activity:activity", version.ref = "androidxActivity" }
@@ -88,6 +91,7 @@ androidx-compose-ui-tooling-preview = { module = "androidx.compose.ui:ui-tooling
 androidx-compose-ui-test-manifest = { module = "androidx.compose.ui:ui-test-manifest" }
 androidx-compose-ui-test-junit4 = { module = "androidx.compose.ui:ui-test-junit4" }
 androidx-compose-activity = { module = "androidx.activity:activity-compose", version.ref = "androidxActivity" }
+androidx-compose-lifecycle-runtime = { module = "androidx.lifecycle:lifecycle-runtime-compose", version.ref = "androidxLifecycle" }
 androidx-compose-lifecycle-viewmodel = { module = "androidx.lifecycle:lifecycle-viewmodel-compose", version.ref = "androidxLifecycle" }
 androidx-compose-material = { module = "androidx.compose.material:material", version.ref = "androidxComposeMaterial" }
 androidx-compose-material-icons-extended = { module = "androidx.compose.material:material-icons-extended", version.ref = "androidxComposeMaterial" }
@@ -96,7 +100,7 @@ androidx-test-core = "androidx.test:core:1.5.0"
 androidx-datastore = { module = "androidx.datastore:datastore-preferences", version.ref = "datastore" }
 androidx-test-ext-junit-ktx = "androidx.test.ext:junit-ktx:1.1.5"
 androidx-test-espresso-core = "androidx.test.espresso:espresso-core:3.5.1"
-android-material = "com.google.android.material:material:1.8.0"
+android-material = "com.google.android.material:material:1.9.0"
 accompanist-systemuicontroller = { module = "com.google.accompanist:accompanist-systemuicontroller", version.ref = "accompanist" }
 fastadapter = { module = "com.mikepenz:fastadapter", version.ref = "fastAdapter" }
 fastadapter-extensions-drag = { module = "com.mikepenz:fastadapter-extensions-drag", version.ref = "fastAdapter" }
@@ -113,8 +117,9 @@ gson = "com.google.code.gson:gson:2.8.9"
 timber = "com.jakewharton.timber:timber:5.0.1"
 koin-core = { module = "io.insert-koin:koin-core", version.ref = "koinCore" }
 koin-android = { module = "io.insert-koin:koin-android", version.ref = "koinAndroid" }
-koin-test = { module = "io.insert-koin:koin-test", version.ref = "koinCore" }
-koin-test-junit4 = { module = "io.insert-koin:koin-test-junit4", version.ref = "koinCore" }
+koin-androidx-compose = { module = "io.insert-koin:koin-androidx-compose", version.ref = "koinAndroidCompose" }
+koin-test = { module = "io.insert-koin:koin-test", version.ref = "koinTest" }
+koin-test-junit4 = { module = "io.insert-koin:koin-test-junit4", version.ref = "koinTest" }
 commons-io = "commons-io:commons-io:2.11.0"
 mime4j-core = { module = "org.apache.james:apache-mime4j-core", version.ref = "mime4j" }
 mime4j-dom = { module = "org.apache.james:apache-mime4j-dom", version.ref = "mime4j" }
@@ -149,14 +154,14 @@ junit = "junit:junit:4.13.2"
 robolectric = "org.robolectric:robolectric:4.9.2"
 mockito-core = { module = "org.mockito:mockito-core", version.ref = "mockito" }
 mockito-kotlin = "org.mockito.kotlin:mockito-kotlin:4.1.0"
-turbine = "app.cash.turbine:turbine:0.12.3"
+turbine = "app.cash.turbine:turbine:0.13.0"
 jdom2 = "org.jdom:jdom2:2.0.6.1"
 icu4j-charset = "com.ibm.icu:icu4j-charset:72.1"
-assertk = "com.willowtreeapps.assertk:assertk-jvm:0.25"
+assertk = "com.willowtreeapps.assertk:assertk-jvm:0.26.1"
 
 leakcanary-android = "com.squareup.leakcanary:leakcanary-android:2.9.1"
 
-detekt-plugin-compose = "io.nlopez.compose.rules:detekt:0.1.1"
+detekt-plugin-compose = "io.nlopez.compose.rules:detekt:0.1.7"
 
 [bundles]
 shared-jvm-main = [
@@ -174,10 +179,13 @@ shared-jvm-android-app = [
   "android-material",
 ]
 shared-jvm-android-compose = [
+  "kotlinx-collections-immutable",
   "androidx-compose-foundation",
   "androidx-compose-ui-tooling-preview",
+  "androidx-compose-lifecycle-runtime",
   "androidx-compose-lifecycle-viewmodel",
   "androidx-compose-navigation",
+  "koin-androidx-compose",
 ]
 shared-jvm-android-compose-debug = [
   "androidx-compose-ui-tooling",
@@ -187,12 +195,14 @@ shared-jvm-androidtest-compose = [
   "androidx-compose-ui-test-junit4",
 ]
 shared-jvm-test = [
+  "kotlin-test",
   "junit",
   "assertk",
   "mockito-core",
   "mockito-kotlin",
   "koin-test",
   "koin-test-junit4",
+  "turbine",
 ]
 shared-jvm-test-compose = [
   "robolectric",
diff --git a/mail/common/src/main/java/com/fsck/k9/mail/Address.java b/mail/common/src/main/java/com/fsck/k9/mail/Address.java
index fd272638fa22fea133a8fa0ad91291bee67afa24..8bc3eaa1d22ba000bbfbb9eefd9f9e0e6c33548c 100644
--- a/mail/common/src/main/java/com/fsck/k9/mail/Address.java
+++ b/mail/common/src/main/java/com/fsck/k9/mail/Address.java
@@ -115,7 +115,8 @@ public class Address implements Serializable {
             for (Rfc822Token token : tokens) {
                 String address = token.getAddress();
                 if (!TextUtils.isEmpty(address)) {
-                    addresses.add(new Address(token.getAddress(), token.getName(), false));
+                    String name = TextUtils.isEmpty(token.getName()) ? null : token.getName();
+                    addresses.add(new Address(token.getAddress(), name, false));
                 }
             }
         }
diff --git a/mail/common/src/main/java/com/fsck/k9/mail/filter/FixedLengthInputStream.java b/mail/common/src/main/java/com/fsck/k9/mail/filter/FixedLengthInputStream.java
deleted file mode 100644
index 9535822e0001f01929b6866ec6ede96e709b163a..0000000000000000000000000000000000000000
--- a/mail/common/src/main/java/com/fsck/k9/mail/filter/FixedLengthInputStream.java
+++ /dev/null
@@ -1,78 +0,0 @@
-
-package com.fsck.k9.mail.filter;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Locale;
-
-/**
- * A filtering InputStream that stops allowing reads after the given length has been read. This
- * is used to allow a client to read directly from an underlying protocol stream without reading
- * past where the protocol handler intended the client to read.
- */
-public class FixedLengthInputStream extends InputStream {
-    private final InputStream mIn;
-    private final int mLength;
-    private int mCount = 0;
-
-    public FixedLengthInputStream(InputStream in, int length) {
-        this.mIn = in;
-        this.mLength = length;
-    }
-
-    @Override
-    public int available() throws IOException {
-        return mLength - mCount;
-    }
-
-    @Override
-    public int read() throws IOException {
-        if (mCount >= mLength) {
-            return -1;
-        }
-
-        int d = mIn.read();
-        if (d != -1) {
-            mCount++;
-        }
-        return d;
-    }
-
-    @Override
-    public int read(byte[] b, int offset, int length) throws IOException {
-        if (mCount >= mLength) {
-            return -1;
-        }
-
-        int d = mIn.read(b, offset, Math.min(mLength - mCount, length));
-        if (d != -1) {
-            mCount += d;
-        }
-        return d;
-    }
-
-    @Override
-    public int read(byte[] b) throws IOException {
-        return read(b, 0, b.length);
-    }
-
-    @Override
-    public long skip(long n) throws IOException {
-        long d = mIn.skip(Math.min(n, available()));
-        if (d > 0) {
-            mCount += d;
-        }
-        return d;
-    }
-
-    @Override
-    public String toString() {
-        return String.format(Locale.US, "FixedLengthInputStream(in=%s, length=%d)", mIn.toString(), mLength);
-    }
-
-    public void skipRemaining() throws IOException {
-        while (available() > 0) {
-            skip(available());
-        }
-    }
-}
diff --git a/mail/common/src/main/java/com/fsck/k9/mail/filter/FixedLengthInputStream.kt b/mail/common/src/main/java/com/fsck/k9/mail/filter/FixedLengthInputStream.kt
new file mode 100644
index 0000000000000000000000000000000000000000..6c79f983b4713d22a40600e140d64075bedbbcd4
--- /dev/null
+++ b/mail/common/src/main/java/com/fsck/k9/mail/filter/FixedLengthInputStream.kt
@@ -0,0 +1,81 @@
+package com.fsck.k9.mail.filter
+
+import java.io.IOException
+import java.io.InputStream
+import java.util.Locale
+
+/**
+ * A filtering InputStream that stops allowing reads after the given length has been read. This
+ * is used to allow a client to read directly from an underlying protocol stream without reading
+ * past where the protocol handler intended the client to read.
+ */
+class FixedLengthInputStream(
+    private val inputStream: InputStream,
+    private val length: Int,
+) : InputStream() {
+    private var numberOfBytesRead = 0
+
+    // TODO: Call available() on underlying InputStream if remainingBytes() > 0
+    @Throws(IOException::class)
+    override fun available(): Int {
+        return remainingBytes()
+    }
+
+    @Throws(IOException::class)
+    override fun read(): Int {
+        if (remainingBytes() == 0) {
+            return -1
+        }
+
+        val byte = inputStream.read()
+        if (byte != -1) {
+            numberOfBytesRead++
+        }
+
+        return byte
+    }
+
+    @Throws(IOException::class)
+    override fun read(b: ByteArray, offset: Int, length: Int): Int {
+        if (remainingBytes() == 0) {
+            return -1
+        }
+
+        val byte = inputStream.read(b, offset, length.coerceAtMost(remainingBytes()))
+        if (byte != -1) {
+            numberOfBytesRead += byte
+        }
+
+        return byte
+    }
+
+    @Throws(IOException::class)
+    override fun read(b: ByteArray): Int {
+        return read(b, 0, b.size)
+    }
+
+    @Throws(IOException::class)
+    override fun skip(n: Long): Long {
+        val numberOfSkippedBytes = inputStream.skip(n.coerceAtMost(remainingBytes().toLong()))
+        if (numberOfSkippedBytes > 0) {
+            numberOfBytesRead += numberOfSkippedBytes.toInt()
+        }
+
+        return numberOfSkippedBytes
+    }
+
+    @Throws(IOException::class)
+    fun skipRemaining() {
+        while (remainingBytes() > 0) {
+            skip(remainingBytes().toLong())
+        }
+    }
+
+    private fun remainingBytes(): Int {
+        return length - numberOfBytesRead
+    }
+
+    override fun toString(): String {
+        return String.format(Locale.ROOT, "FixedLengthInputStream(in=%s, length=%d)", inputStream.toString(), length)
+    }
+}
diff --git a/mail/common/src/main/java/com/fsck/k9/sasl/OAuthBearer.kt b/mail/common/src/main/java/com/fsck/k9/sasl/OAuthBearer.kt
index 531e5b683d486ef0b64ef0635cdef952c07db523..561977fec13d790e2ef140b724f6c8b188d6e085 100644
--- a/mail/common/src/main/java/com/fsck/k9/sasl/OAuthBearer.kt
+++ b/mail/common/src/main/java/com/fsck/k9/sasl/OAuthBearer.kt
@@ -10,6 +10,6 @@ import okio.ByteString.Companion.encodeUtf8
  * See [RFC 7628](https://datatracker.ietf.org/doc/html/rfc7628).
  */
 fun buildOAuthBearerInitialClientResponse(username: String, token: String): String {
-    val saslName = username.replace(",", "=2C").replace("=", "=3D")
+    val saslName = username.replace("=", "=3D").replace(",", "=2C")
     return "n,a=$saslName,\u0001auth=Bearer $token\u0001\u0001".encodeUtf8().base64()
 }
diff --git a/mail/common/src/test/java/com/fsck/k9/mail/MimeTypeTest.kt b/mail/common/src/test/java/com/fsck/k9/mail/MimeTypeTest.kt
index 611592ccfde0be46f4933694d22e00ede4438c47..961ac403e53943cb451d5bd68b5bbc664f024757 100644
--- a/mail/common/src/test/java/com/fsck/k9/mail/MimeTypeTest.kt
+++ b/mail/common/src/test/java/com/fsck/k9/mail/MimeTypeTest.kt
@@ -1,8 +1,8 @@
 package com.fsck.k9.mail
 
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
 import assertk.assertions.isNull
@@ -69,10 +69,9 @@ class MimeTypeTest {
     }
 
     private fun assertInvalidMimeType(input: String) {
-        assertThat {
+        assertFailure {
             input.toMimeType()
-        }.isFailure()
-            .isInstanceOf(IllegalArgumentException::class)
+        }.isInstanceOf<IllegalArgumentException>()
             .message().isNotNull().startsWith("Invalid MIME type: ")
     }
 
diff --git a/mail/common/src/test/java/com/fsck/k9/mail/filter/FixedLengthInputStreamTest.java b/mail/common/src/test/java/com/fsck/k9/mail/filter/FixedLengthInputStreamTest.java
deleted file mode 100644
index b750b5dc349e652f92d58854b5f52f000e111cab..0000000000000000000000000000000000000000
--- a/mail/common/src/test/java/com/fsck/k9/mail/filter/FixedLengthInputStreamTest.java
+++ /dev/null
@@ -1,273 +0,0 @@
-package com.fsck.k9.mail.filter;
-
-
-import java.io.IOException;
-import java.io.InputStream;
-
-import okio.Buffer;
-import okio.ByteString;
-import okio.Okio;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-
-public class FixedLengthInputStreamTest {
-    @Test
-    public void readingStream_shouldReturnDataUpToLimit() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello world"), 5);
-
-        String readString = readStreamAsUtf8String(fixedLengthInputStream);
-
-        assertEquals("Hello", readString);
-    }
-
-    @Test
-    public void readingStream_shouldNotConsumeMoreThanLimitFromUnderlyingInputStream() throws Exception {
-        InputStream inputStream = inputStream("Hello world");
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream, 5);
-
-        exhaustStream(fixedLengthInputStream);
-
-        assertRemainingInputStreamEquals(" world", inputStream);
-    }
-
-    @Test
-    //TODO: Maybe this should throw. The underlying stream delivering less bytes than expected is most likely an error.
-    public void readingStream_withLimitGreaterThanNumberOfBytesInUnderlyingInputStream() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 100);
-
-        String readString = readStreamAsUtf8String(fixedLengthInputStream);
-
-        assertEquals("Hello World", readString);
-    }
-
-    @Test
-    public void read_withOverSizedByteArray_shouldReturnDataUpToLimit() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 6);
-
-        byte[] data = new byte[100];
-        int numberOfBytesRead = fixedLengthInputStream.read(data);
-
-        assertEquals(6, numberOfBytesRead);
-        assertEquals("Hello ", ByteString.of(data, 0, numberOfBytesRead).utf8());
-    }
-
-    @Test
-    public void read_withOverSizedByteArray_shouldNotConsumeMoreThanLimitFromUnderlyingStream() throws Exception {
-        InputStream inputStream = inputStream("Hello World");
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream, 6);
-
-        //noinspection ResultOfMethodCallIgnored
-        fixedLengthInputStream.read(new byte[100]);
-
-        assertRemainingInputStreamEquals("World", inputStream);
-    }
-
-    @Test
-    public void read_withByteArraySmallerThanLimit_shouldConsumeSizeOfByteArray() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 6);
-
-        byte[] data = new byte[5];
-        int numberOfBytesRead = fixedLengthInputStream.read(data);
-
-        assertEquals(5, numberOfBytesRead);
-        assertEquals("Hello", ByteString.of(data).utf8());
-    }
-
-    @Test
-    public void read_withOverSizedByteArrayInMiddleOfStream_shouldReturnDataUpToLimit() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 6);
-        consumeBytes(fixedLengthInputStream, 5);
-
-        byte[] data = new byte[10];
-        int numberOfBytesRead = fixedLengthInputStream.read(data);
-
-        assertEquals(1, numberOfBytesRead);
-        assertEquals(" ", ByteString.of(data, 0, numberOfBytesRead).utf8());
-    }
-
-    @Test
-    public void read_withOverSizedByteArrayInMiddleOfStream_shouldNotConsumeMoreThanLimitFromUnderlyingStream()
-            throws Exception {
-        InputStream inputStream = inputStream("Hello World");
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream, 6);
-        consumeBytes(fixedLengthInputStream, 5);
-
-        //noinspection ResultOfMethodCallIgnored
-        fixedLengthInputStream.read(new byte[10]);
-
-        assertRemainingInputStreamEquals("World", inputStream);
-    }
-
-    @Test
-    public void read_atStartOfStream() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Word"), 2);
-
-        int readByte = fixedLengthInputStream.read();
-
-        assertEquals('W', (char) readByte);
-    }
-
-    @Test
-    public void read_inMiddleOfStream() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Word"), 2);
-        consumeBytes(fixedLengthInputStream, 1);
-
-        int readByte = fixedLengthInputStream.read();
-
-        assertEquals('o', (char) readByte);
-    }
-
-    @Test
-    public void read_atEndOfStream_shouldReturnMinusOne() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello world"), 5);
-        exhaustStream(fixedLengthInputStream);
-
-        int readByte = fixedLengthInputStream.read();
-
-        assertEquals(-1, readByte);
-    }
-
-    @Test
-    public void readArray_atEndOfStream_shouldReturnMinusOne() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello world"), 5);
-        exhaustStream(fixedLengthInputStream);
-
-        int numberOfBytesRead = fixedLengthInputStream.read(new byte[2]);
-
-        assertEquals(-1, numberOfBytesRead);
-    }
-
-    @Test
-    public void readArrayWithOffset_atEndOfStream_shouldReturnMinusOne() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello world"), 5);
-        exhaustStream(fixedLengthInputStream);
-
-        int numberOfBytesRead = fixedLengthInputStream.read(new byte[2], 0, 2);
-
-        assertEquals(-1, numberOfBytesRead);
-    }
-
-    @Test
-    public void available_atStartOfStream() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 5);
-
-        int available = fixedLengthInputStream.available();
-
-        assertEquals(5, available);
-    }
-
-    @Test
-    public void available_afterPartialRead() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 5);
-        //noinspection ResultOfMethodCallIgnored
-        fixedLengthInputStream.read();
-
-        int available = fixedLengthInputStream.available();
-
-        assertEquals(4, available);
-    }
-
-    @Test
-    public void available_afterPartialReadArray() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 5);
-        consumeBytes(fixedLengthInputStream, 2);
-
-        int available = fixedLengthInputStream.available();
-
-        assertEquals(3, available);
-    }
-
-    @Test
-    public void available_afterStreamHasBeenExhausted() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 5);
-        exhaustStream(fixedLengthInputStream);
-
-        int available = fixedLengthInputStream.available();
-
-        assertEquals(0, available);
-    }
-
-    @Test
-    public void available_afterSkip() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 5);
-        guaranteedSkip(fixedLengthInputStream, 2);
-
-        int available = fixedLengthInputStream.available();
-
-        assertEquals(3, available);
-    }
-
-    @Test
-    public void available_afterSkipRemaining() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 5);
-        fixedLengthInputStream.skipRemaining();
-
-        int available = fixedLengthInputStream.available();
-
-        assertEquals(0, available);
-    }
-
-    @Test
-    public void skip_shouldConsumeBytes() throws IOException {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 5);
-
-        guaranteedSkip(fixedLengthInputStream, 2);
-
-        assertRemainingInputStreamEquals("llo", fixedLengthInputStream);
-    }
-
-    @Test
-    public void skipRemaining_shouldExhaustStream() throws IOException {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 5);
-
-        fixedLengthInputStream.skipRemaining();
-
-        assertInputStreamExhausted(fixedLengthInputStream);
-    }
-
-    @Test
-    public void skipRemaining_shouldNotConsumeMoreThanLimitFromUnderlyingInputStream() throws IOException {
-        InputStream inputStream = inputStream("Hello World");
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream, 6);
-
-        fixedLengthInputStream.skipRemaining();
-
-        assertRemainingInputStreamEquals("World", inputStream);
-    }
-
-
-    private String readStreamAsUtf8String(InputStream inputStream) throws IOException {
-        return Okio.buffer(Okio.source(inputStream)).readUtf8();
-    }
-
-    private void exhaustStream(InputStream inputStream) throws IOException {
-        Okio.buffer(Okio.source(inputStream)).readAll(Okio.blackhole());
-    }
-
-    private void consumeBytes(InputStream inputStream, int numberOfBytes) throws IOException {
-        int read = inputStream.read(new byte[numberOfBytes]);
-        assertEquals(numberOfBytes, read);
-    }
-
-    private void guaranteedSkip(InputStream inputStream, int numberOfBytesToSkip) throws IOException {
-        int remaining = numberOfBytesToSkip;
-        while (remaining > 0) {
-            remaining -= inputStream.skip(remaining);
-        }
-        assertEquals(0, remaining);
-    }
-
-    private void assertRemainingInputStreamEquals(String expected, InputStream inputStream) throws IOException {
-        assertEquals(expected, readStreamAsUtf8String(inputStream));
-    }
-
-    private void assertInputStreamExhausted(InputStream inputStream) throws IOException {
-        assertEquals(-1, inputStream.read());
-    }
-
-    private InputStream inputStream(String data) {
-        return new Buffer().writeUtf8(data).inputStream();
-    }
-}
diff --git a/mail/common/src/test/java/com/fsck/k9/mail/filter/FixedLengthInputStreamTest.kt b/mail/common/src/test/java/com/fsck/k9/mail/filter/FixedLengthInputStreamTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8cb17142a249edf94c5bd68b5c2343ec12a5b3dd
--- /dev/null
+++ b/mail/common/src/test/java/com/fsck/k9/mail/filter/FixedLengthInputStreamTest.kt
@@ -0,0 +1,275 @@
+package com.fsck.k9.mail.filter
+
+import assertk.Assert
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import java.io.InputStream
+import kotlin.test.Test
+import okio.blackholeSink
+import okio.buffer
+import okio.source
+
+class FixedLengthInputStreamTest {
+    @Test
+    fun `reading stream should return data up to limit`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+
+        val result = fixedLengthInputStream.readToString()
+
+        assertThat(result).isEqualTo("Hello")
+    }
+
+    @Test
+    fun `reading stream should not consume more than limit from underlying InputStream`() {
+        val inputStream = "Hello world".byteInputStream()
+        val fixedLengthInputStream = FixedLengthInputStream(inputStream, 5)
+
+        fixedLengthInputStream.exhaust()
+
+        assertThat(inputStream).readToString().isEqualTo(" world")
+    }
+
+    // TODO: Maybe this should throw. The underlying stream delivering less bytes than expected is most likely an error.
+    @Test
+    fun `reading stream with limit greater than number of bytes in underlying InputStream`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 100)
+
+        val result = fixedLengthInputStream.readToString()
+
+        assertThat(result).isEqualTo("Hello world")
+    }
+
+    @Test
+    fun `read() with oversized ByteArray should return data up to limit`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello World", length = 6)
+        val data = ByteArray(100)
+
+        val result = fixedLengthInputStream.read(data)
+
+        assertThat(result).isEqualTo(6)
+        assertThat(data).all {
+            slice(0 until 6).asString().isEqualTo("Hello ")
+            slice(6 until 100).isEqualTo(ByteArray(100 - 6))
+        }
+    }
+
+    @Test
+    fun `read() with oversized ByteArray should not consume more than limit from underlying InputStream`() {
+        val inputStream = "Hello World".byteInputStream()
+        val fixedLengthInputStream = FixedLengthInputStream(inputStream, 6)
+
+        fixedLengthInputStream.read(ByteArray(100))
+
+        assertThat(inputStream).readToString().isEqualTo("World")
+    }
+
+    @Test
+    fun `read() with ByteArray smaller than limit should consume size of ByteArray`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello World", length = 6)
+        val data = ByteArray(5)
+
+        val result = fixedLengthInputStream.read(data)
+
+        assertThat(result).isEqualTo(5)
+        assertThat(data).asString().isEqualTo("Hello")
+    }
+
+    @Test
+    fun `read() with oversized ByteArray in middle of stream should return data up to limit`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello World", length = 6)
+        fixedLengthInputStream.consumeBytes(5)
+        val data = ByteArray(10)
+
+        val result = fixedLengthInputStream.read(data)
+
+        assertThat(result).isEqualTo(1)
+        assertThat(data).all {
+            slice(0 until 1).asString().isEqualTo(" ")
+            slice(1 until 10).isEqualTo(ByteArray(10 - 1))
+        }
+    }
+
+    @Test
+    fun `read() with oversized ByteArray in middle of stream should not read more than limit from underlying stream`() {
+        val inputStream = "Hello World".byteInputStream()
+        val fixedLengthInputStream = FixedLengthInputStream(inputStream, 6)
+        fixedLengthInputStream.consumeBytes(5)
+
+        fixedLengthInputStream.read(ByteArray(10))
+
+        assertThat(inputStream).readToString().isEqualTo("World")
+    }
+
+    @Test
+    fun `read() at start of stream`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Word", length = 2)
+
+        val result = fixedLengthInputStream.read()
+
+        assertThat(result).isEqualTo('W'.code)
+    }
+
+    @Test
+    fun `read() in middle of stream`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Word", length = 2)
+        fixedLengthInputStream.consumeBytes(1)
+
+        val result = fixedLengthInputStream.read()
+
+        assertThat(result).isEqualTo('o'.code)
+    }
+
+    @Test
+    fun `read() at end of stream should return -1`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+        fixedLengthInputStream.exhaust()
+
+        val result = fixedLengthInputStream.read()
+
+        assertThat(result).isEqualTo(-1)
+    }
+
+    @Test
+    fun `read(ByteArray) at end of stream should return -1`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+        fixedLengthInputStream.exhaust()
+
+        val result = fixedLengthInputStream.read(ByteArray(2))
+
+        assertThat(result).isEqualTo(-1)
+    }
+
+    @Test
+    fun `read(ByteArray) with offset at end of stream should return -1`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+        fixedLengthInputStream.exhaust()
+
+        val result = fixedLengthInputStream.read(ByteArray(2), 0, 2)
+
+        assertThat(result).isEqualTo(-1)
+    }
+
+    @Test
+    fun `available() at start of stream`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+
+        val result = fixedLengthInputStream.available()
+
+        assertThat(result).isEqualTo(5)
+    }
+
+    @Test
+    fun `available() after partial read`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+        fixedLengthInputStream.read()
+
+        val result = fixedLengthInputStream.available()
+
+        assertThat(result).isEqualTo(4)
+    }
+
+    @Test
+    fun `available() after partial multi-byte read`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+        fixedLengthInputStream.consumeBytes(2)
+
+        val result = fixedLengthInputStream.available()
+
+        assertThat(result).isEqualTo(3)
+    }
+
+    @Test
+    fun `available() after stream has been exhausted`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+        fixedLengthInputStream.exhaust()
+
+        val result = fixedLengthInputStream.available()
+
+        assertThat(result).isEqualTo(0)
+    }
+
+    @Test
+    fun `available() after skip()`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+        fixedLengthInputStream.guaranteedSkip(2)
+
+        val result = fixedLengthInputStream.available()
+
+        assertThat(result).isEqualTo(3)
+    }
+
+    @Test
+    fun `available() after skip remaining`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+        fixedLengthInputStream.skipRemaining()
+
+        val result = fixedLengthInputStream.available()
+
+        assertThat(result).isEqualTo(0)
+    }
+
+    @Test
+    fun `skip() should consume bytes`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+
+        fixedLengthInputStream.guaranteedSkip(2)
+
+        assertThat(fixedLengthInputStream).readToString().isEqualTo("llo")
+    }
+
+    @Test
+    fun `skipRemaining() should exhaust stream`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+
+        fixedLengthInputStream.skipRemaining()
+
+        assertThat(fixedLengthInputStream).isExhausted()
+    }
+
+    @Test
+    fun `skipRemaining() should not consume more than limit from underlying InputStream`() {
+        val inputStream = "Hello World".byteInputStream()
+        val fixedLengthInputStream = FixedLengthInputStream(inputStream, 6)
+
+        fixedLengthInputStream.skipRemaining()
+
+        assertThat(inputStream).readToString().isEqualTo("World")
+    }
+
+    private fun createFixedLengthInputStream(data: String, length: Int): FixedLengthInputStream {
+        return FixedLengthInputStream(data.byteInputStream(), length)
+    }
+
+    private fun InputStream.guaranteedSkip(numberOfBytesToSkip: Int) {
+        var remaining = numberOfBytesToSkip.toLong()
+        while (remaining > 0) {
+            remaining -= skip(remaining)
+        }
+
+        assertThat(remaining).isEqualTo(0L)
+    }
+
+    private fun InputStream.readToString(): String = source().buffer().readUtf8()
+
+    private fun InputStream.exhaust() {
+        source().buffer().readAll(blackholeSink())
+    }
+
+    private fun InputStream.consumeBytes(numberOfBytes: Int) {
+        val numberOfBytesRead = read(ByteArray(numberOfBytes))
+
+        assertThat(numberOfBytesRead).isEqualTo(numberOfBytes)
+    }
+
+    private fun Assert<InputStream>.isExhausted() = given { actual ->
+        assertThat(actual.read()).isEqualTo(-1)
+        assertThat(actual.available()).isEqualTo(0)
+    }
+
+    private fun Assert<InputStream>.readToString() = transform { it.readToString() }
+
+    private fun Assert<ByteArray>.slice(range: IntRange) = transform { it.sliceArray(range) }
+
+    private fun Assert<ByteArray>.asString() = transform { String(it) }
+}
diff --git a/mail/common/src/test/java/com/fsck/k9/mail/internet/AddressHeaderBuilderTest.kt b/mail/common/src/test/java/com/fsck/k9/mail/internet/AddressHeaderBuilderTest.kt
index 156458f46889a93808fc743bc6d87e0a12916f4f..f710ba6d9f458a954c9c6a0bc42dccc3860d4e8d 100644
--- a/mail/common/src/test/java/com/fsck/k9/mail/internet/AddressHeaderBuilderTest.kt
+++ b/mail/common/src/test/java/com/fsck/k9/mail/internet/AddressHeaderBuilderTest.kt
@@ -1,8 +1,12 @@
 package com.fsck.k9.mail.internet
 
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.hasMessage
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
 import com.fsck.k9.mail.Address
 import com.fsck.k9.mail.crlf
-import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class AddressHeaderBuilderTest {
@@ -13,7 +17,7 @@ class AddressHeaderBuilderTest {
 
         val headerValue = AddressHeaderBuilder.createHeaderValue(addresses)
 
-        assertEquals("test@domain.example", headerValue)
+        assertThat(headerValue).isEqualTo("test@domain.example")
     }
 
     @Test
@@ -25,7 +29,7 @@ class AddressHeaderBuilderTest {
 
         val headerValue = AddressHeaderBuilder.createHeaderValue(addresses)
 
-        assertEquals("one@domain.example, two@domain.example", headerValue)
+        assertThat(headerValue).isEqualTo("one@domain.example, two@domain.example")
     }
 
     @Test
@@ -40,19 +44,21 @@ class AddressHeaderBuilderTest {
 
         val headerValue = AddressHeaderBuilder.createHeaderValue(addresses)
 
-        assertEquals(
+        assertThat(headerValue).isEqualTo(
             """
             |Person One <one@domain.example>,
             | "Person \"Long Email Address\" Two" <two+because.i.can@this.is.quite.some.domain.example>,
             | Person Three <three@domain.example>, Person Four <four@domain.example>,
             | Person Five <five@domain.example>
             """.trimMargin().crlf(),
-            headerValue,
         )
     }
 
-    @Test(expected = IllegalArgumentException::class)
+    @Test
     fun createHeaderValue_withoutAddresses_shouldThrow() {
-        AddressHeaderBuilder.createHeaderValue(emptyArray())
+        assertFailure {
+            AddressHeaderBuilder.createHeaderValue(emptyArray())
+        }.isInstanceOf<IllegalArgumentException>()
+            .hasMessage("addresses must not be empty")
     }
 }
diff --git a/mail/common/src/test/java/com/fsck/k9/mail/internet/EncoderUtilTest.kt b/mail/common/src/test/java/com/fsck/k9/mail/internet/EncoderUtilTest.kt
index 22015a333b0f8bbbf9d01aaf55d077d440328617..acf887dbf98c4ee6b6f3aa5405686af8ee41e74e 100644
--- a/mail/common/src/test/java/com/fsck/k9/mail/internet/EncoderUtilTest.kt
+++ b/mail/common/src/test/java/com/fsck/k9/mail/internet/EncoderUtilTest.kt
@@ -1,33 +1,36 @@
 package com.fsck.k9.mail.internet
 
-import org.junit.Assert.assertEquals
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import org.junit.Test
 
 class EncoderUtilTest {
     @Test
     fun singleNonAsciiCharacter() {
-        assertInputEncodesToExpected("123456789Ä", "=?UTF-8?Q?123456789=C3=84?=")
+        val result = EncoderUtil.encodeEncodedWord("123456789Ä")
+
+        assertThat(result).isEqualTo("=?UTF-8?Q?123456789=C3=84?=")
     }
 
     @Test
     fun onlyNonAsciiCharacters() {
-        assertInputEncodesToExpected("ÄÖÜÄÖÜÄÖÜÄ", "=?UTF-8?B?w4TDlsOcw4TDlsOcw4TDlsOcw4Q=?=")
+        val result = EncoderUtil.encodeEncodedWord("ÄÖÜÄÖÜÄÖÜÄ")
+
+        assertThat(result).isEqualTo("=?UTF-8?B?w4TDlsOcw4TDlsOcw4TDlsOcw4Q=?=")
     }
 
     @Test
     fun nonAsciiCharactersThatNeedToBeEncodedAsMultipleEncodedWords() {
-        assertInputEncodesToExpected(
+        val result = EncoderUtil.encodeEncodedWord(
             "Re: \uD83D\uDC15\uD83D\uDC36\uD83D\uDC29\uD83D\uDC08\uD83D\uDC31\uD83D\uDC00\uD83D\uDC01\uD83D\uDC2D" +
                 "\uD83D\uDC39\uD83D\uDC22\uD83D\uDC07\uD83D\uDC30\uD83D\uDC13\uD83D\uDC14\uD83D\uDC23\uD83D\uDC24" +
                 "\uD83D\uDC25\uD83D\uDC26\uD83D\uDC0F\uD83D\uDC11\uD83D\uDC10",
+        )
+
+        assertThat(result).isEqualTo(
             "=?UTF-8?B?UmU6IPCfkJXwn5C28J+QqfCfkIjwn5Cx8J+QgPCfkIHwn5Ct8J+QuQ==?= " +
                 "=?UTF-8?B?8J+QovCfkIfwn5Cw8J+Qk/CfkJTwn5Cj?= " +
                 "=?UTF-8?B?8J+QpPCfkKXwn5Cm8J+Qj/CfkJHwn5CQ?=",
         )
     }
-
-    private fun assertInputEncodesToExpected(input: String, expected: String) {
-        val encodedText = EncoderUtil.encodeEncodedWord(input)
-        assertEquals(expected, encodedText)
-    }
 }
diff --git a/mail/common/src/test/java/com/fsck/k9/mail/internet/MessageIdGeneratorTest.kt b/mail/common/src/test/java/com/fsck/k9/mail/internet/MessageIdGeneratorTest.kt
index 64668e46e77d291a41cc805230bee0ee5d91255b..4a4350e99c28e344cb43fa3dbb52befcd091e610 100644
--- a/mail/common/src/test/java/com/fsck/k9/mail/internet/MessageIdGeneratorTest.kt
+++ b/mail/common/src/test/java/com/fsck/k9/mail/internet/MessageIdGeneratorTest.kt
@@ -1,7 +1,8 @@
 package com.fsck.k9.mail.internet
 
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import com.fsck.k9.mail.Address
-import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class MessageIdGeneratorTest {
@@ -20,7 +21,7 @@ class MessageIdGeneratorTest {
 
         val result = messageIdGenerator.generateMessageId(message)
 
-        assertEquals("<00000000-0000-4000-0000-000000000000@example.org>", result)
+        assertThat(result).isEqualTo("<00000000-0000-4000-0000-000000000000@example.org>")
     }
 
     @Test
@@ -31,7 +32,7 @@ class MessageIdGeneratorTest {
 
         val result = messageIdGenerator.generateMessageId(message)
 
-        assertEquals("<00000000-0000-4000-0000-000000000000@example.com>", result)
+        assertThat(result).isEqualTo("<00000000-0000-4000-0000-000000000000@example.com>")
     }
 
     @Test
@@ -40,6 +41,6 @@ class MessageIdGeneratorTest {
 
         val result = messageIdGenerator.generateMessageId(message)
 
-        assertEquals("<00000000-0000-4000-0000-000000000000@fallback.k9mail.app>", result)
+        assertThat(result).isEqualTo("<00000000-0000-4000-0000-000000000000@fallback.k9mail.app>")
     }
 }
diff --git a/mail/common/src/test/java/com/fsck/k9/mail/internet/MimeHeaderCheckerTest.kt b/mail/common/src/test/java/com/fsck/k9/mail/internet/MimeHeaderCheckerTest.kt
index 189a90938085643b39a4b16dbd8f33b215d97c00..9c5ed4543bef2298f49e66499ced1e02419b0be7 100644
--- a/mail/common/src/test/java/com/fsck/k9/mail/internet/MimeHeaderCheckerTest.kt
+++ b/mail/common/src/test/java/com/fsck/k9/mail/internet/MimeHeaderCheckerTest.kt
@@ -1,6 +1,7 @@
 package com.fsck.k9.mail.internet
 
-import org.junit.Assert.fail
+import assertk.assertFailure
+import assertk.assertions.isInstanceOf
 import org.junit.Test
 
 class MimeHeaderCheckerTest {
@@ -196,15 +197,15 @@ class MimeHeaderCheckerTest {
 
     private fun assertValidHeader(header: String) {
         val (name, value) = header.split(": ", limit = 2)
+
         MimeHeaderChecker.checkHeader(name, value)
     }
 
     private fun assertInvalidHeader(header: String) {
         val (name, value) = header.split(": ", limit = 2)
-        try {
+
+        assertFailure {
             MimeHeaderChecker.checkHeader(name, value)
-            fail("Expected exception")
-        } catch (expected: MimeHeaderParserException) {
-        }
+        }.isInstanceOf<MimeHeaderParserException>()
     }
 }
diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/ImapResponseParserTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/ImapResponseParserTest.kt
index a79e9d8783bd8a67770368abe6bacd2d053a0673..18f7a90dc06e2bf6fc01cb3e034b98dce1adb321 100644
--- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/ImapResponseParserTest.kt
+++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/ImapResponseParserTest.kt
@@ -1,6 +1,7 @@
 package com.fsck.k9.mail.store.imap
 
 import assertk.all
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.cause
 import assertk.assertions.containsExactly
@@ -8,10 +9,10 @@ import assertk.assertions.hasMessage
 import assertk.assertions.hasSize
 import assertk.assertions.index
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
 import assertk.assertions.isNull
+import assertk.assertions.isSameAs
 import assertk.assertions.isTrue
 import assertk.assertions.prop
 import com.fsck.k9.mail.filter.FixedLengthInputStream
@@ -51,7 +52,7 @@ class ImapResponseParserTest {
 
         assertThat(response).hasSize(2)
         assertThat(response).index(0).isEqualTo("OK")
-        assertThat(response).index(1).isInstanceOf(ImapList::class).containsExactly("UIDVALIDITY", "3857529045")
+        assertThat(response).index(1).isInstanceOf<ImapList>().containsExactly("UIDVALIDITY", "3857529045")
         assertThatAllInputWasConsumed()
     }
 
@@ -63,7 +64,7 @@ class ImapResponseParserTest {
 
         assertThat(response).hasSize(3)
         assertThat(response).index(0).isEqualTo("OK")
-        assertThat(response).index(1).isInstanceOf(ImapList::class).containsExactly("token1", "token2")
+        assertThat(response).index(1).isInstanceOf<ImapList>().containsExactly("token1", "token2")
         assertThat(response).index(2).isEqualTo("{x} test [...]")
         assertThatAllInputWasConsumed()
     }
@@ -148,10 +149,9 @@ class ImapResponseParserTest {
             "TAG ERROR COMMAND errored",
         )
 
-        assertThat {
+        assertFailure {
             parser.readStatusResponse("TAG", null, null, null)
-        }.isFailure()
-            .isInstanceOf(NegativeImapResponseException::class)
+        }.isInstanceOf<NegativeImapResponseException>()
     }
 
     @Test
@@ -165,9 +165,9 @@ class ImapResponseParserTest {
 
         assertThat(response).hasSize(3)
         assertThat(response).index(0).isEqualTo("OK")
-        assertThat(response).index(1).isInstanceOf(ImapList::class).all {
+        assertThat(response).index(1).isInstanceOf<ImapList>().all {
             index(0).isEqualTo("PERMANENTFLAGS")
-            index(1).isInstanceOf(ImapList::class).containsExactly(
+            index(1).isInstanceOf<ImapList>().containsExactly(
                 """\Answered""",
                 """\Flagged""",
                 """\Deleted""",
@@ -199,10 +199,9 @@ class ImapResponseParserTest {
     fun `readResponse() should throw if stream ends before end of line is found`() {
         val parser = createParserWithData("* OK Some text ")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(IOException::class)
+        }.isInstanceOf<IOException>()
     }
 
     @Test
@@ -240,10 +239,9 @@ class ImapResponseParserTest {
     fun `readResponse() with literal containing negative size`() {
         val parser = createParserWithResponses("* {-1}")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(ImapResponseParserException::class)
+        }.isInstanceOf<ImapResponseParserException>()
             .hasMessage("Invalid value for size of literal string")
     }
 
@@ -251,10 +249,9 @@ class ImapResponseParserTest {
     fun `readResponse() with literal size exceeding Int`() {
         val parser = createParserWithResponses("* {2147483648}")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(ImapResponseParserException::class)
+        }.isInstanceOf<ImapResponseParserException>()
             .hasMessage("Invalid value for size of literal string")
     }
 
@@ -262,10 +259,9 @@ class ImapResponseParserTest {
     fun `readResponse() with invalid characters for literal size`() {
         val parser = createParserWithResponses("* {invalid}")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(ImapResponseParserException::class)
+        }.isInstanceOf<ImapResponseParserException>()
             .hasMessage("Invalid value for size of literal string")
     }
 
@@ -273,10 +269,9 @@ class ImapResponseParserTest {
     fun `readResponse() should throw when end of stream is reached while reading literal`() {
         val parser = createParserWithData("* {4}\r\nabc")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(IOException::class)
+        }.isInstanceOf<IOException>()
     }
 
     @Test
@@ -307,10 +302,9 @@ class ImapResponseParserTest {
         val parser = createParserWithResponses("* {4}\r\ntest")
         val callback = TestImapResponseCallback.readBytesAndReturn(2, null)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(callback)
-        }.isFailure()
-            .isInstanceOf(AssertionError::class)
+        }.isInstanceOf<AssertionError>()
             .hasMessage("Callback consumed some data but returned no result")
     }
 
@@ -319,13 +313,12 @@ class ImapResponseParserTest {
         val parser = createParserWithResponses("* {4}\r\ntest")
         val callback = TestImapResponseCallback.readBytesAndThrow(2)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(callback)
-        }.isFailure()
-            .isInstanceOf(ImapResponseParserException::class)
+        }.isInstanceOf<ImapResponseParserException>()
             .all {
                 hasMessage("readResponse(): Exception in callback method")
-                cause().isNotNull().isInstanceOf(ImapResponseParserTestException::class)
+                cause().isNotNull().isInstanceOf<ImapResponseParserTestException>()
             }
         assertThatAllInputWasConsumed()
     }
@@ -335,13 +328,12 @@ class ImapResponseParserTest {
         val parser = createParserWithResponses("* {3}\r\none {3}\r\ntwo")
         val callback = TestImapResponseCallback.readBytesAndThrow(3)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(callback)
-        }.isFailure()
-            .isInstanceOf(ImapResponseParserException::class)
+        }.isInstanceOf<ImapResponseParserException>()
             .all {
                 hasMessage("readResponse(): Exception in callback method")
-                cause().isNotNull().isInstanceOf(ImapResponseParserTestException::class)
+                cause().isNotNull().isInstanceOf<ImapResponseParserTestException>()
                     .prop(ImapResponseParserTestException::instanceNumber).isEqualTo(0)
             }
         assertThatAllInputWasConsumed()
@@ -363,10 +355,9 @@ class ImapResponseParserTest {
         val parser = createParserWithResponses("* {4}\r\ntest")
         val callback = TestImapResponseCallback.readBytesAndThrow(0)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(callback)
-        }.isFailure()
-            .isInstanceOf(ImapResponseParserException::class)
+        }.isInstanceOf<ImapResponseParserException>()
             .hasMessage("readResponse(): Exception in callback method")
         assertThatAllInputWasConsumed()
     }
@@ -377,10 +368,9 @@ class ImapResponseParserTest {
         val exception = IOException()
         val callback = ImapResponseCallback { _, _ -> throw exception }
 
-        assertThat {
+        assertFailure {
             parser.readResponse(callback)
-        }.isFailure()
-            .isEqualTo(exception)
+        }.isSameAs(exception)
     }
 
     @Test
@@ -407,30 +397,27 @@ class ImapResponseParserTest {
     fun `readResponse() should throw when end of stream is reached before end of quoted string`() {
         val parser = createParserWithResponses("* \"abc")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(IOException::class)
+        }.isInstanceOf<IOException>()
     }
 
     @Test
     fun `readResponse() should throw if end of stream is reached before end of atom`() {
         val parser = createParserWithData("* abc")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(IOException::class)
+        }.isInstanceOf<IOException>()
     }
 
     @Test
     fun `readResponse() should throw if untagged response indicator is not followed by a space`() {
         val parser = createParserWithResponses("*")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(IOException::class)
+        }.isInstanceOf<IOException>()
     }
 
     @Test
@@ -441,7 +428,7 @@ class ImapResponseParserTest {
 
         assertThat(response).hasSize(4)
         assertThat(response).index(0).isEqualTo("LIST")
-        assertThat(response).index(1).isInstanceOf(ImapList::class).containsExactly("""\HasNoChildren""")
+        assertThat(response).index(1).isInstanceOf<ImapList>().containsExactly("""\HasNoChildren""")
         assertThat(response).index(2).isEqualTo(".")
         assertThat(response).index(3).isEqualTo("[FolderName]")
         assertThatAllInputWasConsumed()
@@ -451,10 +438,9 @@ class ImapResponseParserTest {
     fun `readResponse() with LIST response containing folder name with parentheses should throw`() {
         val parser = createParserWithResponses("""* LIST (\NoInferiors) "/" Root/Folder/Subfolder()""")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(IOException::class)
+        }.isInstanceOf<IOException>()
     }
 
     @Test
@@ -479,7 +465,7 @@ class ImapResponseParserTest {
 
         assertThat(response).hasSize(4)
         assertThat(response).index(0).isEqualTo("LIST")
-        assertThat(response).index(1).isInstanceOf(ImapList::class).containsExactly("""\NoInferiors""")
+        assertThat(response).index(1).isInstanceOf<ImapList>().containsExactly("""\NoInferiors""")
         assertThat(response).index(2).isNull()
         assertThat(response).index(3).isEqualTo("INBOX")
         assertThatAllInputWasConsumed()
@@ -489,10 +475,9 @@ class ImapResponseParserTest {
     fun `readResponse() with tagged response missing completion code should throw`() {
         val parser = createParserWithResponses("tag ")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(ImapResponseParserException::class)
+        }.isInstanceOf<ImapResponseParserException>()
             .hasMessage("Unexpected non-string token")
     }
 
@@ -500,10 +485,9 @@ class ImapResponseParserTest {
     fun `readResponse() with list as first token should throw`() {
         val parser = createParserWithResponses("* [1 2] 3")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(ImapResponseParserException::class)
+        }.isInstanceOf<ImapResponseParserException>()
             .hasMessage("Unexpected non-string token")
     }
 
@@ -524,7 +508,7 @@ class ImapResponseParserTest {
         assertThat(response).hasSize(3)
         assertThat(response).index(0).isEqualTo("1")
         assertThat(response).index(1).isEqualTo("FETCH")
-        assertThat(response).index(2).isInstanceOf(ImapList::class).all {
+        assertThat(response).index(2).isInstanceOf<ImapList>().all {
             hasSize(11)
             index(0).isEqualTo("UID")
             index(1).isEqualTo("23")
@@ -533,14 +517,14 @@ class ImapResponseParserTest {
             index(4).isEqualTo("RFC822.SIZE")
             index(5).isEqualTo("3456")
             index(6).isEqualTo("BODY")
-            index(7).isInstanceOf(ImapList::class).all {
+            index(7).isInstanceOf<ImapList>().all {
                 hasSize(2)
                 index(0).isEqualTo("HEADER.FIELDS")
-                index(1).isInstanceOf(ImapList::class).containsExactly("date", "subject", "from")
+                index(1).isInstanceOf<ImapList>().containsExactly("date", "subject", "from")
             }
             index(8).isEqualTo("<headers>")
             index(9).isEqualTo("FLAGS")
-            index(10).isInstanceOf(ImapList::class).containsExactly("""\Seen""")
+            index(10).isInstanceOf<ImapList>().containsExactly("""\Seen""")
         }
         assertThatAllInputWasConsumed()
     }
@@ -549,10 +533,9 @@ class ImapResponseParserTest {
     fun `readStatusResponse() with NO response should throw`() {
         val parser = createParserWithResponses("1 NO")
 
-        assertThat {
+        assertFailure {
             parser.readStatusResponse("1", "COMMAND", "[logId]", null)
-        }.isFailure()
-            .isInstanceOf(NegativeImapResponseException::class)
+        }.isInstanceOf<NegativeImapResponseException>()
             .hasMessage("Command: COMMAND; response: #1# [NO]")
     }
 
@@ -560,10 +543,9 @@ class ImapResponseParserTest {
     fun `readStatusResponse() with NO response and alert text should throw with alert text`() {
         val parser = createParserWithResponses("1 NO [ALERT] Access denied\r\n")
 
-        assertThat {
+        assertFailure {
             parser.readStatusResponse("1", "COMMAND", "[logId]", null)
-        }.isFailure()
-            .isInstanceOf(NegativeImapResponseException::class)
+        }.isInstanceOf<NegativeImapResponseException>()
             .prop(NegativeImapResponseException::getAlertText).isEqualTo("Access denied")
     }
 
diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapConnectionTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapConnectionTest.kt
index b56a1ca1f5dc8d089f965ea852876339aee58172..c5b3c3fd1fac276f74dcb5d6f063ab20cf9d989f 100644
--- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapConnectionTest.kt
+++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapConnectionTest.kt
@@ -1,12 +1,12 @@
 package com.fsck.k9.mail.store.imap
 
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.contains
 import assertk.assertions.containsExactly
 import assertk.assertions.hasMessage
 import assertk.assertions.hasSize
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isFalse
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
@@ -128,10 +128,9 @@ class RealImapConnectionTest {
         imapConnection.open()
         imapConnection.close()
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(IllegalStateException::class)
+        }.isInstanceOf<IllegalStateException>()
             .hasMessage("open() called after close(). Check wrapped exception to see where close() was called.")
     }
 
@@ -142,10 +141,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.PLAIN)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Server doesn't support unencrypted passwords using AUTH=PLAIN and LOGIN is disabled.")
 
         server.verifyConnectionClosed()
@@ -185,10 +183,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.PLAIN)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .prop(AuthenticationFailedException::messageFromServer)
             .isEqualTo("Go away")
 
@@ -208,10 +205,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.PLAIN)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(NegativeImapResponseException::class)
+        }.isInstanceOf<NegativeImapResponseException>()
             .message().isNotNull().contains("Maximum number of connections from user+IP exceeded")
 
         assertThat(imapConnection.isConnected).isFalse()
@@ -232,10 +228,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.PLAIN)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .prop(AuthenticationFailedException::messageFromServer)
             .isEqualTo("Login Failure")
 
@@ -288,10 +283,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.CRAM_MD5)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .prop(AuthenticationFailedException::messageFromServer)
             .isEqualTo("Who are you?")
 
@@ -306,10 +300,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.CRAM_MD5)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Server doesn't support encrypted passwords using CRAM-MD5.")
 
         server.verifyConnectionClosed()
@@ -393,10 +386,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.XOAUTH2)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .prop(AuthenticationFailedException::messageFromServer)
             .isEqualTo("SASL authentication failed")
     }
@@ -479,10 +471,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.XOAUTH2)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .prop(AuthenticationFailedException::messageFromServer)
             .isEqualTo("SASL authentication failed")
     }
@@ -530,10 +521,9 @@ class RealImapConnectionTest {
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.EXTERNAL)
 
         // FIXME: improve exception message
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(CertificateValidationException::class)
+        }.isInstanceOf<CertificateValidationException>()
             .message().isNotNull().contains("Bad certificate")
 
         server.verifyConnectionClosed()
@@ -547,10 +537,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.EXTERNAL)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(CertificateValidationException::class)
+        }.isInstanceOf<CertificateValidationException>()
             .prop(CertificateValidationException::getReason)
             .isEqualTo(CertificateValidationException.Reason.MissingCapability)
 
@@ -652,10 +641,9 @@ class RealImapConnectionTest {
         val settings = createImapSettings(host = "host name")
         val imapConnection = createImapConnection(settings, socketFactory, oAuth2TokenProvider)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(UnknownHostException::class)
+        }.isInstanceOf<UnknownHostException>()
 
         assertThat(imapConnection.isConnected).isFalse()
     }
@@ -699,10 +687,9 @@ class RealImapConnectionTest {
         )
 
         // FIXME: CertificateValidationException seems wrong
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(CertificateValidationException::class)
+        }.isInstanceOf<CertificateValidationException>()
             .hasMessage("STARTTLS connection security not available")
 
         server.verifyConnectionClosed()
@@ -749,10 +736,9 @@ class RealImapConnectionTest {
             authType = AuthType.PLAIN,
         )
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(NegativeImapResponseException::class)
+        }.isInstanceOf<NegativeImapResponseException>()
             .hasMessage("Command: STARTTLS; response: #2# [NO]")
 
         server.verifyConnectionClosed()
@@ -801,10 +787,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, useCompression = true)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(IOException::class)
+        }.isInstanceOf<IOException>()
 
         server.verifyConnectionClosed()
         server.verifyInteractionCompleted()
@@ -819,10 +804,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(IOException::class)
+        }.isInstanceOf<IOException>()
 
         server.verifyConnectionClosed()
         server.verifyInteractionCompleted()
@@ -1058,10 +1042,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server)
 
-        assertThat {
+        assertFailure {
             imapConnection.executeSimpleCommand("CREATE Folder")
-        }.isFailure()
-            .isInstanceOf(NegativeImapResponseException::class)
+        }.isInstanceOf<NegativeImapResponseException>()
             .prop(NegativeImapResponseException::getLastResponse)
             .containsExactly("NO", "Folder exists")
 
@@ -1100,10 +1083,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .prop(AuthenticationFailedException::messageFromServer)
             .isEqualTo("AUTHENTICATE failed")
 
diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderIdlerTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderIdlerTest.kt
index 3e9862379a1936d6cdbedaa70aab808efeb4d3e4..45f21aa4104d616b692eceb7faa6e3014ac6c37a 100644
--- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderIdlerTest.kt
+++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderIdlerTest.kt
@@ -1,9 +1,9 @@
 package com.fsck.k9.mail.store.imap
 
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isFalse
 import assertk.assertions.isGreaterThan
 import assertk.assertions.isInstanceOf
@@ -224,10 +224,9 @@ class RealImapFolderIdlerTest {
         imapFolder.throwOnOpen { throw AuthenticationFailedException("Authentication failure for test") }
 
         thread {
-            assertThat {
+            assertFailure {
                 idler.idle()
-            }.isFailure()
-                .isInstanceOf(AuthenticationFailedException::class)
+            }.isInstanceOf<AuthenticationFailedException>()
                 .hasMessage("Authentication failure for test")
 
             latch.countDown()
@@ -243,10 +242,9 @@ class RealImapFolderIdlerTest {
         imapFolder.throwOnOpen { throw IOException("I/O error for test") }
 
         thread {
-            assertThat {
+            assertFailure {
                 idler.idle()
-            }.isFailure()
-                .isInstanceOf(IOException::class)
+            }.isInstanceOf<IOException>()
                 .hasMessage("I/O error for test")
 
             latch.countDown()
@@ -261,10 +259,9 @@ class RealImapFolderIdlerTest {
         val latch = CountDownLatch(1)
 
         thread {
-            assertThat {
+            assertFailure {
                 idler.idle()
-            }.isFailure()
-                .isInstanceOf(IOException::class)
+            }.isInstanceOf<IOException>()
                 .hasMessage("Socket closed during IDLE")
 
             latch.countDown()
diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderTest.kt
index c2427ac35e090c106d31552d28e4492f4c3ba40d..27225051ea0f88cb1423b7a6c3ac4099b90ce59e 100644
--- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderTest.kt
+++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderTest.kt
@@ -1,14 +1,20 @@
 package com.fsck.k9.mail.store.imap
 
 import assertk.all
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.cause
 import assertk.assertions.containsExactly
+import assertk.assertions.containsOnly
+import assertk.assertions.extracting
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
+import assertk.assertions.isFalse
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
+import assertk.assertions.isNull
+import assertk.assertions.isTrue
+import assertk.fail
 import com.fsck.k9.mail.Body
 import com.fsck.k9.mail.DefaultBodyFactory
 import com.fsck.k9.mail.FetchProfile
@@ -27,12 +33,6 @@ import java.util.TimeZone
 import okio.Buffer
 import org.apache.james.mime4j.util.MimeUtil
 import org.junit.After
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
-import org.junit.Assert.fail
 import org.junit.Before
 import org.junit.Test
 import org.mockito.ArgumentMatchers.anySet
@@ -79,7 +79,7 @@ class RealImapFolderTest {
 
         imapFolder.open(OpenMode.READ_WRITE)
 
-        assertTrue(imapFolder.isOpen)
+        assertThat(imapFolder.isOpen).isTrue()
     }
 
     @Test
@@ -89,7 +89,7 @@ class RealImapFolderTest {
 
         imapFolder.open(OpenMode.READ_ONLY)
 
-        assertTrue(imapFolder.isOpen)
+        assertThat(imapFolder.isOpen).isTrue()
     }
 
     @Test
@@ -99,7 +99,7 @@ class RealImapFolderTest {
 
         imapFolder.open(OpenMode.READ_WRITE)
 
-        assertEquals(23, imapFolder.messageCount)
+        assertThat(imapFolder.messageCount).isEqualTo(23)
     }
 
     @Test
@@ -109,7 +109,7 @@ class RealImapFolderTest {
 
         imapFolder.open(OpenMode.READ_WRITE)
 
-        assertEquals(OpenMode.READ_WRITE, imapFolder.mode)
+        assertThat(imapFolder.mode).isEqualTo(OpenMode.READ_WRITE)
     }
 
     @Test
@@ -119,7 +119,7 @@ class RealImapFolderTest {
 
         imapFolder.open(OpenMode.READ_ONLY)
 
-        assertEquals(OpenMode.READ_ONLY, imapFolder.mode)
+        assertThat(imapFolder.mode).isEqualTo(OpenMode.READ_ONLY)
     }
 
     @Test
@@ -129,7 +129,7 @@ class RealImapFolderTest {
 
         imapFolder.open(OpenMode.READ_WRITE)
 
-        assertTrue(imapFolder.exists())
+        assertThat(imapFolder.exists()).isTrue()
         verify(imapConnection, times(1)).executeSimpleCommand(anyString())
     }
 
@@ -161,10 +161,10 @@ class RealImapFolderTest {
         val imapFolder = createFolder("Folder")
         doThrow(IOException::class).whenever(imapConnection).executeSimpleCommand("SELECT \"Folder\"")
 
-        assertThat {
+        assertFailure {
             imapFolder.open(OpenMode.READ_WRITE)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class).cause().isNotNull().isInstanceOf(IOException::class)
+        }.isInstanceOf<MessagingException>()
+            .cause().isNotNull().isInstanceOf<IOException>()
     }
 
     @Test
@@ -172,10 +172,9 @@ class RealImapFolderTest {
         val imapFolder = createFolder("Folder")
         doThrow(MessagingException::class).whenever(imapConnection).executeSimpleCommand("SELECT \"Folder\"")
 
-        assertThat {
+        assertFailure {
             imapFolder.open(OpenMode.READ_WRITE)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
     }
 
     @Test
@@ -187,10 +186,9 @@ class RealImapFolderTest {
         )
         whenever(imapConnection.executeSimpleCommand("SELECT \"Folder\"")).thenReturn(selectResponses)
 
-        assertThat {
+        assertFailure {
             imapFolder.open(OpenMode.READ_WRITE)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Did not find message count during open")
     }
 
@@ -202,7 +200,7 @@ class RealImapFolderTest {
 
         imapFolder.close()
 
-        assertFalse(imapFolder.isOpen)
+        assertThat(imapFolder.isOpen).isFalse()
     }
 
     @Test
@@ -220,7 +218,7 @@ class RealImapFolderTest {
 
         val folderExists = imapFolder.exists()
 
-        assertTrue(folderExists)
+        assertThat(folderExists).isTrue()
     }
 
     @Test
@@ -231,7 +229,7 @@ class RealImapFolderTest {
 
         val folderExists = imapFolder.exists()
 
-        assertFalse(folderExists)
+        assertThat(folderExists).isFalse()
     }
 
     @Test
@@ -249,7 +247,7 @@ class RealImapFolderTest {
 
         val success = imapFolder.create()
 
-        assertTrue(success)
+        assertThat(success).isTrue()
     }
 
     @Test
@@ -259,7 +257,7 @@ class RealImapFolderTest {
 
         val success = imapFolder.create()
 
-        assertFalse(success)
+        assertThat(success).isFalse()
     }
 
     @Test
@@ -270,7 +268,7 @@ class RealImapFolderTest {
 
         val uidMapping = sourceFolder.copyMessages(messages, destinationFolder)
 
-        assertNull(uidMapping)
+        assertThat(uidMapping).isNull()
     }
 
     @Test
@@ -279,10 +277,9 @@ class RealImapFolderTest {
         val destinationFolder = createFolder("Destination")
         val messages = listOf(mock<ImapMessage>())
 
-        assertThat {
+        assertFailure {
             sourceFolder.copyMessages(messages, destinationFolder)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Folder Source is not open.")
     }
 
@@ -297,8 +294,7 @@ class RealImapFolderTest {
 
         val uidMapping = sourceFolder.copyMessages(messages, destinationFolder)
 
-        assertNotNull(uidMapping)
-        assertEquals("101", uidMapping!!["1"])
+        assertThat(uidMapping).isNotNull().containsOnly("1" to "101")
     }
 
     @Test
@@ -312,8 +308,7 @@ class RealImapFolderTest {
 
         val uidMapping = sourceFolder.moveMessages(messages, destinationFolder)
 
-        assertNotNull(uidMapping)
-        assertEquals("101", uidMapping!!["1"])
+        assertThat(uidMapping).isNotNull().containsOnly("1" to "101")
     }
 
     @Test
@@ -337,17 +332,16 @@ class RealImapFolderTest {
 
         val uidMapping = sourceFolder.moveMessages(messages, destinationFolder)
 
-        assertNull(uidMapping)
+        assertThat(uidMapping).isNull()
     }
 
     @Test
     fun getUnreadMessageCount_withClosedFolder_shouldThrow() {
         val folder = createFolder("FolderName")
 
-        assertThat {
+        assertFailure {
             folder.unreadMessageCount
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Folder FolderName is not open.")
     }
 
@@ -358,10 +352,9 @@ class RealImapFolderTest {
         whenever(imapConnection.executeSimpleCommand("SEARCH 1:* UNSEEN NOT DELETED")).thenThrow(IOException())
         folder.open(OpenMode.READ_WRITE)
 
-        assertThat {
+        assertFailure {
             folder.unreadMessageCount
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("IO Error")
     }
 
@@ -375,17 +368,16 @@ class RealImapFolderTest {
 
         val unreadMessageCount = folder.unreadMessageCount
 
-        assertEquals(3, unreadMessageCount)
+        assertThat(unreadMessageCount).isEqualTo(3)
     }
 
     @Test
     fun getFlaggedMessageCount_withClosedFolder_shouldThrow() {
         val folder = createFolder("FolderName")
 
-        assertThat {
+        assertFailure {
             folder.flaggedMessageCount
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Folder FolderName is not open.")
     }
 
@@ -402,7 +394,7 @@ class RealImapFolderTest {
 
         val flaggedMessageCount = folder.flaggedMessageCount
 
-        assertEquals(4, flaggedMessageCount)
+        assertThat(flaggedMessageCount).isEqualTo(4)
     }
 
     @Test
@@ -414,7 +406,7 @@ class RealImapFolderTest {
 
         val highestUid = folder.highestUid
 
-        assertEquals(42L, highestUid)
+        assertThat(highestUid).isEqualTo(42L)
     }
 
     @Test
@@ -426,7 +418,7 @@ class RealImapFolderTest {
 
         val highestUid = folder.highestUid
 
-        assertEquals(-1L, highestUid)
+        assertThat(highestUid).isEqualTo(-1L)
     }
 
     @Test
@@ -436,10 +428,9 @@ class RealImapFolderTest {
         doThrow(IOException::class).whenever(imapConnection).executeSimpleCommand("UID SEARCH *:*")
         folder.open(OpenMode.READ_WRITE)
 
-        assertThat {
+        assertFailure {
             folder.highestUid
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("IO Error")
     }
 
@@ -452,8 +443,8 @@ class RealImapFolderTest {
 
         val messages = folder.getMessages(1, 10, null, null)
 
-        assertNotNull(messages)
-        assertEquals(setOf("3", "5", "6"), extractMessageUids(messages))
+        assertThat(messages).isNotNull()
+            .extracting { it.uid }.containsOnly("3", "5", "6")
     }
 
     @Test
@@ -466,8 +457,8 @@ class RealImapFolderTest {
 
         val messages = folder.getMessages(1, 10, Date(1454719826000L), null)
 
-        assertNotNull(messages)
-        assertEquals(setOf("18", "47"), extractMessageUids(messages))
+        assertThat(messages).isNotNull()
+            .extracting { it.uid }.containsOnly("18", "47")
     }
 
     @Test
@@ -488,10 +479,9 @@ class RealImapFolderTest {
     fun getMessages_withInvalidStartArgument_shouldThrow() {
         val folder = createFolder("Folder")
 
-        assertThat {
+        assertFailure {
             folder.getMessages(0, 10, null, null)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Invalid message set 0 10")
     }
 
@@ -499,10 +489,9 @@ class RealImapFolderTest {
     fun getMessages_withInvalidEndArgument_shouldThrow() {
         val folder = createFolder("Folder")
 
-        assertThat {
+        assertFailure {
             folder.getMessages(10, 0, null, null)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Invalid message set 10 0")
     }
 
@@ -510,10 +499,9 @@ class RealImapFolderTest {
     fun getMessages_withEndArgumentSmallerThanStartArgument_shouldThrow() {
         val folder = createFolder("Folder")
 
-        assertThat {
+        assertFailure {
             folder.getMessages(10, 5, null, null)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Invalid message set 10 5")
     }
 
@@ -521,10 +509,9 @@ class RealImapFolderTest {
     fun getMessages_withClosedFolder_shouldThrow() {
         val folder = createFolder("FolderName")
 
-        assertThat {
+        assertFailure {
             folder.getMessages(1, 5, null, null)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Folder FolderName is not open.")
     }
 
@@ -532,10 +519,9 @@ class RealImapFolderTest {
     fun getMessages_sequenceNumbers_withClosedFolder_shouldThrow() {
         val folder = createFolder("FolderName")
 
-        assertThat {
+        assertFailure {
             folder.getMessages(setOf(1L, 2L, 5L), false, null)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Folder FolderName is not open.")
     }
 
@@ -548,8 +534,8 @@ class RealImapFolderTest {
 
         val messages = folder.getMessages(setOf(1L, 2L, 5L), false, null)
 
-        assertNotNull(messages)
-        assertEquals(setOf("17", "18", "49"), extractMessageUids(messages))
+        assertThat(messages).isNotNull()
+            .extracting { it.uid }.containsOnly("17", "18", "49")
     }
 
     @Test
@@ -570,10 +556,9 @@ class RealImapFolderTest {
     fun getMessagesFromUids_withClosedFolder_shouldThrow() {
         val folder = createFolder("FolderName")
 
-        assertThat {
+        assertFailure {
             folder.getMessagesFromUids(listOf("11", "22", "25"))
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Folder FolderName is not open.")
     }
 
@@ -586,18 +571,17 @@ class RealImapFolderTest {
 
         val messages = folder.getMessagesFromUids(listOf("11", "22", "25"))
 
-        assertNotNull(messages)
-        assertEquals(setOf("11", "22", "25"), extractMessageUids(messages))
+        assertThat(messages).isNotNull()
+            .extracting { it.uid }.containsOnly("11", "22", "25")
     }
 
     @Test
     fun areMoreMessagesAvailable_withClosedFolder_shouldThrow() {
         val folder = createFolder("FolderName")
 
-        assertThat {
+        assertFailure {
             folder.areMoreMessagesAvailable(10, Date())
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Folder FolderName is not open.")
     }
 
@@ -610,7 +594,7 @@ class RealImapFolderTest {
 
         val areMoreMessagesAvailable = folder.areMoreMessagesAvailable(10, null)
 
-        assertTrue(areMoreMessagesAvailable)
+        assertThat(areMoreMessagesAvailable).isTrue()
     }
 
     @Test
@@ -622,7 +606,7 @@ class RealImapFolderTest {
 
         val areMoreMessagesAvailable = folder.areMoreMessagesAvailable(600, null)
 
-        assertFalse(areMoreMessagesAvailable)
+        assertThat(areMoreMessagesAvailable).isFalse()
     }
 
     @Test
@@ -633,7 +617,7 @@ class RealImapFolderTest {
 
         val areMoreMessagesAvailable = folder.areMoreMessagesAvailable(1, null)
 
-        assertFalse(areMoreMessagesAvailable)
+        assertThat(areMoreMessagesAvailable).isFalse()
         // SELECT during OPEN and no more
         verify(imapConnection, times(1)).executeSimpleCommand(anyString())
     }
@@ -922,7 +906,7 @@ class RealImapFolderTest {
         val body = bodyArgumentCaptor.firstValue
         val buffer = Buffer()
         body.writeTo(buffer.outputStream())
-        assertEquals("text", buffer.readUtf8())
+        assertThat(buffer.readUtf8()).isEqualTo("text")
     }
 
     @Test
@@ -946,13 +930,12 @@ class RealImapFolderTest {
         val messages = listOf(createImapMessage("1"))
         whenever(imapConnection.readResponse()).thenReturn(createImapResponse("x NO Can't append to this folder"))
 
-        assertThat {
+        assertFailure {
             folder.appendMessages(messages)
-        }.isFailure()
-            .isInstanceOf(NegativeImapResponseException::class.java).all {
-                hasMessage("APPEND failed")
-                transform { it.lastResponse[0] }.isEqualTo("NO")
-            }
+        }.isInstanceOf<NegativeImapResponseException>().all {
+            hasMessage("APPEND failed")
+            transform { it.lastResponse[0] }.isEqualTo("NO")
+        }
     }
 
     @Test
@@ -963,13 +946,12 @@ class RealImapFolderTest {
         val messages = listOf(createImapMessage("1"))
         whenever(imapConnection.readResponse()).thenReturn(createImapResponse("x BAD [TOOBIG] Message too large."))
 
-        assertThat {
+        assertFailure {
             folder.appendMessages(messages)
-        }.isFailure()
-            .isInstanceOf(NegativeImapResponseException::class.java).all {
-                hasMessage("APPEND failed")
-                transform { it.lastResponse[0] }.isEqualTo("BAD")
-            }
+        }.isInstanceOf<NegativeImapResponseException>().all {
+            hasMessage("APPEND failed")
+            transform { it.lastResponse[0] }.isEqualTo("BAD")
+        }
     }
 
     @Test
@@ -993,7 +975,7 @@ class RealImapFolderTest {
 
         val uid = folder.getUidFromMessageId("<00000000.0000000@example.org>")
 
-        assertEquals("23", uid)
+        assertThat(uid).isEqualTo("23")
     }
 
     @Test
@@ -1066,7 +1048,7 @@ class RealImapFolderTest {
 
         val message = folder.getMessage("uid")
 
-        assertEquals("uid", message.uid)
+        assertThat(message.uid).isEqualTo("uid")
     }
 
     @Suppress("SameParameterValue")
@@ -1103,8 +1085,6 @@ class RealImapFolderTest {
         return response
     }
 
-    private fun extractMessageUids(messages: List<ImapMessage>) = messages.map { it.uid }.toSet()
-
     private fun createFolder(folderName: String): RealImapFolder {
         return RealImapFolder(internalImapStore, testConnectionManager, folderName, FolderNameCodec())
     }
diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapStoreTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapStoreTest.kt
index 04c9af4f9a409e5f9e4afcd8b9080a2e42de4b93..54e236bdbb4878735d2c59151f87caa2444fe0cf 100644
--- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapStoreTest.kt
+++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapStoreTest.kt
@@ -1,11 +1,11 @@
 package com.fsck.k9.mail.store.imap
 
 import assertk.all
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.cause
 import assertk.assertions.containsExactly
 import assertk.assertions.hasMessage
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
 import assertk.assertions.isSameAs
@@ -50,11 +50,12 @@ class RealImapStoreTest {
         }
         imapStore.enqueueImapConnection(imapConnection)
 
-        assertThat { imapStore.checkSettings() }.isFailure()
-            .isInstanceOf(MessagingException::class).all {
-                hasMessage("Unable to connect")
-                cause().isNotNull().isInstanceOf(IOException::class)
-            }
+        assertFailure {
+            imapStore.checkSettings()
+        }.isInstanceOf<MessagingException>().all {
+            hasMessage("Unable to connect")
+            cause().isNotNull().isInstanceOf<IOException>()
+        }
     }
 
     @Test
@@ -249,8 +250,9 @@ class RealImapStoreTest {
         }
         imapStore.enqueueImapConnection(imapConnection)
 
-        assertThat { imapStore.getFolders() }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        assertFailure {
+            imapStore.getFolders()
+        }.isInstanceOf<MessagingException>()
 
         verify(imapConnection).close()
     }
diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/UidValidityResponseTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/UidValidityResponseTest.kt
index 9d6f84227415b7e79475acb53d69c2321f2718aa..46acef0e0109802fa2ec26169cdfeabe16cc5211 100644
--- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/UidValidityResponseTest.kt
+++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/UidValidityResponseTest.kt
@@ -1,8 +1,10 @@
 package com.fsck.k9.mail.store.imap
 
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertNull
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
+import assertk.assertions.prop
 import org.junit.Test
 
 class UidValidityResponseTest {
@@ -12,8 +14,8 @@ class UidValidityResponseTest {
 
         val result = UidValidityResponse.parse(response)
 
-        assertNotNull(result)
-        assertEquals(23, result!!.uidValidity)
+        assertThat(result).isNotNull()
+            .prop(UidValidityResponse::uidValidity).isEqualTo(23)
     }
 
     @Test
@@ -22,8 +24,8 @@ class UidValidityResponseTest {
 
         val result = UidValidityResponse.parse(response)
 
-        assertNotNull(result)
-        assertEquals(42, result!!.uidValidity)
+        assertThat(result).isNotNull()
+            .prop(UidValidityResponse::uidValidity).isEqualTo(42)
     }
 
     @Test
@@ -58,6 +60,7 @@ class UidValidityResponseTest {
 
     private fun assertNotValid(response: String) {
         val result = UidValidityResponse.parse(ImapResponseHelper.createImapResponse(response))
-        assertNull(result)
+
+        assertThat(result).isNull()
     }
 }
diff --git a/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3ConnectionTest.kt b/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3ConnectionTest.kt
index 397745e3cc4bad359232ecc561b4bc6e3747814d..db1f483500e9d8f12f5a849f737c32ba4f9a1b47 100644
--- a/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3ConnectionTest.kt
+++ b/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3ConnectionTest.kt
@@ -1,9 +1,8 @@
 package com.fsck.k9.mail.store.pop3
 
-import assertk.assertThat
+import assertk.assertFailure
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
 import assertk.assertions.prop
 import com.fsck.k9.mail.AuthType
@@ -162,10 +161,9 @@ class Pop3ConnectionTest {
         }
         val settings = server.createSettings(authType = PLAIN)
 
-        assertThat {
+        assertFailure {
             createAndOpenPop3Connection(settings)
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
 
         server.verifyInteractionCompleted()
     }
@@ -197,10 +195,9 @@ class Pop3ConnectionTest {
         }
         val settings = server.createSettings(authType = PLAIN)
 
-        assertThat {
+        assertFailure {
             createAndOpenPop3Connection(settings)
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
 
         server.verifyInteractionCompleted()
     }
@@ -233,10 +230,9 @@ class Pop3ConnectionTest {
         }
         val settings = server.createSettings(authType = CRAM_MD5)
 
-        assertThat {
+        assertFailure {
             createAndOpenPop3Connection(settings)
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
 
         server.verifyInteractionCompleted()
     }
@@ -273,10 +269,9 @@ class Pop3ConnectionTest {
         }
         val settings = server.createSettings(authType = CRAM_MD5)
 
-        assertThat {
+        assertFailure {
             createAndOpenPop3Connection(settings)
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
 
         server.verifyInteractionCompleted()
     }
@@ -303,10 +298,9 @@ class Pop3ConnectionTest {
         }
         val settings = server.createSettings(authType = EXTERNAL)
 
-        assertThat {
+        assertFailure {
             createAndOpenPop3Connection(settings)
-        }.isFailure()
-            .isInstanceOf(CertificateValidationException::class.java)
+        }.isInstanceOf<CertificateValidationException>()
             .prop(CertificateValidationException::getReason)
             .isEqualTo(CertificateValidationException.Reason.MissingCapability)
 
@@ -323,10 +317,9 @@ class Pop3ConnectionTest {
         }
         val settings = server.createSettings(authType = EXTERNAL)
 
-        assertThat {
+        assertFailure {
             createAndOpenPop3Connection(settings)
-        }.isFailure()
-            .isInstanceOf(CertificateValidationException::class.java)
+        }.isInstanceOf<CertificateValidationException>()
             .hasMessage("POP3 client certificate authentication failed: -ERR Invalid certificate")
 
         server.verifyInteractionCompleted()
diff --git a/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpResponseParserTest.kt b/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpResponseParserTest.kt
index 91c82341f6a2ce9d3885c976c66f1ac465622f13..b81d8172ee86615291a0abe147cb267b09d3e947 100644
--- a/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpResponseParserTest.kt
+++ b/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpResponseParserTest.kt
@@ -1,6 +1,7 @@
 package com.fsck.k9.mail.transport.smtp
 
 import assertk.all
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.containsExactly
 import assertk.assertions.containsExactlyInAnyOrder
@@ -8,7 +9,6 @@ import assertk.assertions.hasMessage
 import assertk.assertions.hasSize
 import assertk.assertions.isEmpty
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isFalse
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
@@ -69,7 +69,7 @@ class SmtpResponseParserTest {
 
         val response = parser.readHelloResponse()
 
-        assertThat(response).isInstanceOf(SmtpHelloResponse.Hello::class).all {
+        assertThat(response).isInstanceOf<SmtpHelloResponse.Hello>().all {
             prop(SmtpHelloResponse.Hello::response)
                 .transform { it.toLogString(false, "") }.isEqualTo(input)
             prop(SmtpHelloResponse.Hello::keywords).all {
@@ -98,7 +98,7 @@ class SmtpResponseParserTest {
 
         val response = parser.readHelloResponse()
 
-        assertThat(response).isInstanceOf(SmtpHelloResponse.Hello::class).all {
+        assertThat(response).isInstanceOf<SmtpHelloResponse.Hello>().all {
             prop(SmtpHelloResponse.Hello::response).all {
                 prop(SmtpResponse::replyCode).isEqualTo(250)
                 prop(SmtpResponse::texts).containsExactly("smtp.domain.example")
@@ -114,7 +114,7 @@ class SmtpResponseParserTest {
 
         val response = parser.readHelloResponse()
 
-        assertThat(response).isInstanceOf(SmtpHelloResponse.Error::class)
+        assertThat(response).isInstanceOf<SmtpHelloResponse.Error>()
             .prop(SmtpHelloResponse.Error::response).all {
                 prop(SmtpResponse::replyCode).isEqualTo(421)
                 prop(SmtpResponse::texts).containsExactly("Service not available")
@@ -126,10 +126,9 @@ class SmtpResponseParserTest {
         val input = "250".toPeekableInputStream()
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readHelloResponse()
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Unexpected character: (13)")
 
         assertThat(logger.logEntries).containsExactly(
@@ -151,10 +150,9 @@ class SmtpResponseParserTest {
         """.toPeekableInputStream()
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readHelloResponse()
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Multi-line response with reply codes not matching: 250 != 220")
 
         assertThat(logger.logEntries).containsExactly(
@@ -185,7 +183,7 @@ class SmtpResponseParserTest {
 
         val response = parser.readHelloResponse()
 
-        assertThat(response).isInstanceOf(SmtpHelloResponse.Hello::class)
+        assertThat(response).isInstanceOf<SmtpHelloResponse.Hello>()
             .prop(SmtpHelloResponse.Hello::keywords).transform { it.keys }.containsExactlyInAnyOrder(
                 "SIZE",
                 "8BITMIME",
@@ -215,7 +213,7 @@ class SmtpResponseParserTest {
 
         val response = parser.readHelloResponse()
 
-        assertThat(response).isInstanceOf(SmtpHelloResponse.Hello::class)
+        assertThat(response).isInstanceOf<SmtpHelloResponse.Hello>()
             .transform { it.keywords.keys }.isEmpty()
 
         assertThat(logger.logEntries).isNotNull().hasSize(1)
@@ -234,7 +232,7 @@ class SmtpResponseParserTest {
 
         val response = parser.readHelloResponse()
 
-        assertThat(response).isInstanceOf(SmtpHelloResponse.Hello::class)
+        assertThat(response).isInstanceOf<SmtpHelloResponse.Hello>()
             .transform { it.keywords.keys }.containsExactlyInAnyOrder("8BITMIME")
 
         assertThat(logger.logEntries).hasSize(1)
@@ -253,10 +251,9 @@ class SmtpResponseParserTest {
         val parser = SmtpResponseParser(logger, input)
         parser.readGreeting()
 
-        assertThat {
+        assertFailure {
             parser.readHelloResponse()
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Unexpected character: I (73)")
 
         assertThat(logger.logEntries).containsExactly(
@@ -441,10 +438,9 @@ class SmtpResponseParserTest {
         """.toPeekableInputStream()
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(enhancedStatusCodes = false)
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Multi-line response with reply codes not matching: 200 != 500")
 
         assertThat(logger.logEntries).containsExactly(
@@ -468,10 +464,9 @@ class SmtpResponseParserTest {
         val logger = TestSmtpLogger(isRawProtocolLoggingEnabled = false)
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(enhancedStatusCodes = false)
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Multi-line response with reply codes not matching: 200 != 500")
         assertThat(logger.logEntries).isEmpty()
     }
@@ -481,10 +476,9 @@ class SmtpResponseParserTest {
         val input = "611".toPeekableInputStream()
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(enhancedStatusCodes = false)
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Unsupported 1st reply code digit: 6")
     }
 
@@ -508,10 +502,9 @@ class SmtpResponseParserTest {
         val input = "20x".toPeekableInputStream()
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(enhancedStatusCodes = false)
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Unexpected character: x (120)")
 
         assertThat(logger.logEntries).containsExactly(
@@ -530,10 +523,9 @@ class SmtpResponseParserTest {
         val input = PeekableInputStream("200".byteInputStream())
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(enhancedStatusCodes = false)
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Unexpected end of stream")
 
         assertThat(logger.logEntries).containsExactly(
@@ -552,10 +544,9 @@ class SmtpResponseParserTest {
         val input = PeekableInputStream("200\r".byteInputStream())
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(enhancedStatusCodes = false)
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Unexpected end of stream")
     }
 
@@ -564,10 +555,9 @@ class SmtpResponseParserTest {
         val input = PeekableInputStream("200\n".byteInputStream())
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(enhancedStatusCodes = false)
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Unexpected character: (10)")
 
         assertThat(logger.logEntries).containsExactly(
@@ -694,10 +684,9 @@ class SmtpResponseParserTest {
         """.toPeekableInputStream()
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(enhancedStatusCodes = true)
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage(
                 "Multi-line response with enhanced status codes not matching: " +
                     "EnhancedStatusCode(statusClass=PERMANENT_FAILURE, subject=2, detail=1) != null",
diff --git a/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpTransportTest.kt b/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpTransportTest.kt
index 5d35e5bdb5c074dcd8abfd3318d067f819ba4647..29d199c649d13d7898a28005a293bdc3067e85ce 100644
--- a/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpTransportTest.kt
+++ b/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpTransportTest.kt
@@ -1,10 +1,9 @@
 package com.fsck.k9.mail.transport.smtp
 
 import assertk.all
-import assertk.assertThat
+import assertk.assertFailure
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isTrue
 import assertk.assertions.prop
@@ -122,10 +121,9 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.PLAIN)
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Authentication methods SASL PLAIN and LOGIN are unavailable.")
 
         server.verifyConnectionClosed()
@@ -164,10 +162,9 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.CRAM_MD5)
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Authentication method CRAM-MD5 is unavailable.")
 
         server.verifyConnectionClosed()
@@ -245,10 +242,9 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.XOAUTH2)
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .hasMessage(
                 "5.7.1 Username and Password not accepted. Learn more at " +
                     "5.7.1 http://support.google.com/mail/bin/answer.py?answer=14257 hx9sm5317360pbc.68",
@@ -369,10 +365,9 @@ class SmtpTransportTest {
 
         val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.XOAUTH2)
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .hasMessage(
                 "5.7.1 Username and Password not accepted. Learn more at " +
                     "5.7.1 http://support.google.com/mail/bin/answer.py?answer=14257 hx9sm5317360pbc.68",
@@ -397,10 +392,9 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.XOAUTH2)
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .hasMessage("Failed to fetch token")
 
         server.verifyConnectionClosed()
@@ -419,10 +413,9 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.XOAUTH2)
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Server doesn't support SASL OAUTHBEARER or XOAUTH2.")
 
         server.verifyConnectionClosed()
@@ -459,10 +452,9 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.EXTERNAL)
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(CertificateValidationException::class)
+        }.isInstanceOf<CertificateValidationException>()
             .prop(CertificateValidationException::getReason)
             .isEqualTo(CertificateValidationException.Reason.MissingCapability)
 
@@ -509,10 +501,9 @@ class SmtpTransportTest {
             connectionSecurity = ConnectionSecurity.NONE,
         )
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Update your outgoing server authentication setting. AUTOMATIC authentication is unavailable.")
 
         server.verifyConnectionClosed()
@@ -553,10 +544,9 @@ class SmtpTransportTest {
         server.output("221 BYE")
         val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.XOAUTH2)
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .hasMessage(
                 "Username and Password not accepted. " +
                     "Learn more at http://support.google.com/mail/bin/answer.py?answer=14257 hx9sm5317360pbc.68",
@@ -718,13 +708,12 @@ class SmtpTransportTest {
         val server = createServerAndSetupForPlainAuthentication("SIZE 1000")
         val transport = startServerAndCreateSmtpTransport(server)
 
-        assertThat {
+        assertFailure {
             transport.sendMessage(message)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class).all {
-                hasMessage("Message too large for server")
-                transform { it.isPermanentFailure }.isTrue()
-            }
+        }.isInstanceOf<MessagingException>().all {
+            hasMessage("Message too large for server")
+            transform { it.isPermanentFailure }.isTrue()
+        }
 
         // FIXME: Make sure connection was closed
         // server.verifyConnectionClosed();
@@ -749,13 +738,12 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server)
 
-        assertThat {
+        assertFailure {
             transport.sendMessage(message)
-        }.isFailure()
-            .isInstanceOf(NegativeSmtpReplyException::class).all {
-                prop(NegativeSmtpReplyException::replyCode).isEqualTo(421)
-                prop(NegativeSmtpReplyException::replyText).isEqualTo("4.7.0 Temporary system problem")
-            }
+        }.isInstanceOf<NegativeSmtpReplyException>().all {
+            prop(NegativeSmtpReplyException::replyCode).isEqualTo(421)
+            prop(NegativeSmtpReplyException::replyText).isEqualTo("4.7.0 Temporary system problem")
+        }
 
         server.verifyConnectionClosed()
         server.verifyInteractionCompleted()
@@ -825,14 +813,13 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server)
 
-        assertThat {
+        assertFailure {
             transport.sendMessage(message)
-        }.isFailure()
-            .isInstanceOf(NegativeSmtpReplyException::class).all {
-                prop(NegativeSmtpReplyException::replyCode).isEqualTo(550)
-                prop(NegativeSmtpReplyException::replyText)
-                    .isEqualTo("remote mail to <user2@localhost> not allowed")
-            }
+        }.isInstanceOf<NegativeSmtpReplyException>().all {
+            prop(NegativeSmtpReplyException::replyCode).isEqualTo(550)
+            prop(NegativeSmtpReplyException::replyText)
+                .isEqualTo("remote mail to <user2@localhost> not allowed")
+        }
 
         server.verifyConnectionClosed()
         server.verifyInteractionCompleted()
@@ -851,14 +838,13 @@ class SmtpTransportTest {
         server.closeConnection()
         val transport = startServerAndCreateSmtpTransport(server)
 
-        assertThat {
+        assertFailure {
             transport.sendMessage(message)
-        }.isFailure()
-            .isInstanceOf(NegativeSmtpReplyException::class).all {
-                prop(NegativeSmtpReplyException::replyCode).isEqualTo(550)
-                prop(NegativeSmtpReplyException::replyText)
-                    .isEqualTo("remote mail to <user2@localhost> not allowed")
-            }
+        }.isInstanceOf<NegativeSmtpReplyException>().all {
+            prop(NegativeSmtpReplyException::replyCode).isEqualTo(550)
+            prop(NegativeSmtpReplyException::replyText)
+                .isEqualTo("remote mail to <user2@localhost> not allowed")
+        }
 
         server.verifyConnectionClosed()
         server.verifyInteractionCompleted()
@@ -880,14 +866,13 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server)
 
-        assertThat {
+        assertFailure {
             transport.sendMessage(message)
-        }.isFailure()
-            .isInstanceOf(NegativeSmtpReplyException::class).all {
-                prop(NegativeSmtpReplyException::replyCode).isEqualTo(550)
-                prop(NegativeSmtpReplyException::replyText)
-                    .isEqualTo("remote mail to <user2@localhost> not allowed")
-            }
+        }.isInstanceOf<NegativeSmtpReplyException>().all {
+            prop(NegativeSmtpReplyException::replyCode).isEqualTo(550)
+            prop(NegativeSmtpReplyException::replyText)
+                .isEqualTo("remote mail to <user2@localhost> not allowed")
+        }
 
         server.verifyConnectionClosed()
         server.verifyInteractionCompleted()
@@ -909,14 +894,13 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server)
 
-        assertThat {
+        assertFailure {
             transport.sendMessage(message)
-        }.isFailure()
-            .isInstanceOf(NegativeSmtpReplyException::class).all {
-                prop(NegativeSmtpReplyException::replyCode).isEqualTo(550)
-                prop(NegativeSmtpReplyException::replyText)
-                    .isEqualTo("remote mail to <user3@localhost> not allowed")
-            }
+        }.isInstanceOf<NegativeSmtpReplyException>().all {
+            prop(NegativeSmtpReplyException::replyCode).isEqualTo(550)
+            prop(NegativeSmtpReplyException::replyText)
+                .isEqualTo("remote mail to <user3@localhost> not allowed")
+        }
 
         server.verifyConnectionClosed()
         server.verifyInteractionCompleted()
diff --git a/mail/testing/build.gradle.kts b/mail/testing/build.gradle.kts
index a5253fd9cfdeb1dc58aa71de2b3a47882c9fb294..38ff9537928898f5b6ef6270e44dd307e8794d1d 100644
--- a/mail/testing/build.gradle.kts
+++ b/mail/testing/build.gradle.kts
@@ -13,4 +13,5 @@ dependencies {
 
     api(libs.okio)
     api(libs.junit)
+    api(libs.assertk)
 }
diff --git a/mail/testing/src/main/java/com/fsck/k9/mail/assertk/MessageExtensions.kt b/mail/testing/src/main/java/com/fsck/k9/mail/assertk/MessageExtensions.kt
new file mode 100644
index 0000000000000000000000000000000000000000..42cfd968a4ffe2631146a9d68cc143c692b815c7
--- /dev/null
+++ b/mail/testing/src/main/java/com/fsck/k9/mail/assertk/MessageExtensions.kt
@@ -0,0 +1,41 @@
+@file:Suppress("TooManyFunctions")
+
+package com.fsck.k9.mail.assertk
+
+import assertk.Assert
+import assertk.assertions.prop
+import com.fsck.k9.mail.Body
+import com.fsck.k9.mail.BodyPart
+import com.fsck.k9.mail.Part
+import com.fsck.k9.mail.internet.MimeMultipart
+import com.fsck.k9.mail.internet.MimeParameterDecoder
+import com.fsck.k9.mail.internet.MimeUtility
+import com.fsck.k9.mail.internet.MimeValue
+import com.fsck.k9.mail.internet.RawDataBody
+import com.fsck.k9.mail.internet.TextBody
+
+fun Assert<Part>.body() = prop(Part::getBody)
+
+@JvmName("textBodyEncoding")
+fun Assert<TextBody>.contentTransferEncoding() = prop(TextBody::getEncoding)
+
+@JvmName("rawDataBodyEncoding")
+fun Assert<RawDataBody>.contentTransferEncoding() = prop(RawDataBody::getEncoding)
+
+fun Assert<Body>.asBytes() = transform { it.inputStream.readBytes() }
+
+fun Assert<Body>.asText() = transform {
+    String(MimeUtility.decodeBody(it).readBytes())
+}
+
+fun Assert<MimeMultipart>.bodyParts() = transform { it.bodyParts }
+
+fun Assert<MimeMultipart>.bodyPart(index: Int): Assert<BodyPart> = transform { it.getBodyPart(index) }
+
+fun Assert<Part>.mimeType() = transform { it.mimeType }
+
+fun Assert<Part>.contentType() = transform { MimeParameterDecoder.decode(it.contentType) }
+
+fun Assert<MimeValue>.value() = transform { it.value }
+
+fun Assert<MimeValue>.parameter(name: String): Assert<String?> = transform { it.parameters[name] }
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 8606d7c6febeea50ff39b380afb32d28c1847cf7..b1efe6bc9cbf68af4f0bedaad7c9384575b632e0 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -46,6 +46,7 @@ include(
     ":feature:autodiscovery:providersxml",
     ":feature:autodiscovery:srvrecords",
     ":feature:autodiscovery:autoconfig",
+    ":feature:autodiscovery:service",
 )
 
 include(
@@ -83,4 +84,7 @@ include(
 
 include(":plugins:openpgp-api-lib:openpgp-api")
 
-include(":cli:html-cleaner-cli")
+include(
+    ":cli:autodiscovery-cli",
+    ":cli:html-cleaner-cli",
+)