Merge remote-tracking branch 'upstream/master'

2024-10-22 20:07:00 +03:00 · 2022-10-29 18:30:40 -04:00 · 2022-10-29 18:30:40 -04:00 · 9326be9b48
commit 9326be9b48
parent 51ae6f8b54 8417f5a63c
862 changed files with 49424 additions and 25241 deletions
--- a/.editorconfig
+++ b/.editorconfig
@ -3,3 +3,5 @@ indent_size=4
 insert_final_newline=true
 ij_kotlin_allow_trailing_comma=true
 ij_kotlin_allow_trailing_comma_on_call_site=true
+ij_kotlin_name_count_to_use_star_import = 2147483647
+ij_kotlin_name_count_to_use_star_import_for_members = 2147483647
--- a/.github/workflows/build_pull_request.yml
+++ b/.github/workflows/build_pull_request.yml
@ -3,7 +3,11 @@ on:
  pull_request:
    paths-ignore:
      - '**.md'
-      - 'app/src/main/res/**/strings.xml'
+      - 'i18n/src/main/res/**/strings.xml'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
+  cancel-in-progress: true

 permissions:
  contents: read
--- a/.github/workflows/build_push.yml
+++ b/.github/workflows/build_push.yml
@ -7,18 +7,16 @@ on:
    tags:
      - v*

+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
  build:
    name: Build app
    runs-on: ubuntu-latest

    steps:
-      - name: Cancel previous runs
-        uses: styfle/cancel-workflow-action@0.10.0
-        with:
-          access_token: ${{ github.token }}
-          all_but_latest: true
-
      - name: Clone repo
        uses: actions/checkout@v3

--- a/.github/workflows/cancel_pull_request.yml
+++ b/.github/workflows/cancel_pull_request.yml
@ -1,16 +0,0 @@
-name: Cancel old pull request workflows
-
-on:
-  workflow_run:
-    workflows: ["PR build check"]
-    types:
-      - requested
-
-jobs:
-  cancel:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: styfle/cancel-workflow-action@0.10.0
-      with:
-        all_but_latest: true
-        workflow_id: ${{ github.event.workflow.id }}
--- a/.gitignore
+++ b/.gitignore
@ -11,6 +11,3 @@
 /build
 *.apk
 app/**/output.json
-
-# Hebrew assets are copied on build
-app/src/main/res/values-iw/
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@ -1,3 +1,4 @@
+import org.gradle.api.tasks.testing.logging.TestLogEvent
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

 plugins {
@ -27,7 +28,7 @@ android {
        applicationId = "xyz.jmir.tachiyomi.mi"
        minSdk = AndroidConfig.minSdk
        targetSdk = AndroidConfig.targetSdk
-        versionCode = 81
+        versionCode = 90
        versionName = "0.13.5.0"

        buildConfigField("String", "COMMIT_COUNT", "\"${getCommitCount()}\"")
@ -73,11 +74,22 @@ android {
            signingConfig = debugType.signingConfig
            versionNameSuffix = debugType.versionNameSuffix
            applicationIdSuffix = debugType.applicationIdSuffix
+            matchingFallbacks.add("release")
+        }
+        create("benchmark") {
+            initWith(getByName("release"))
+
+            signingConfig = signingConfigs.getByName("debug")
+            matchingFallbacks.add("release")
+            isDebuggable = false
+            versionNameSuffix = "-benchmark"
+            applicationIdSuffix = ".benchmark"
        }
    }

    sourceSets {
        getByName("preview").res.srcDirs("src/debug/res")
+        getByName("benchmark").res.srcDirs("src/debug/res")
    }

    flavorDimensions.add("default")
@ -132,7 +144,6 @@ android {
    }

    lint {
-        disable.addAll(listOf("MissingTranslation", "ExtraTranslation"))
        abortOnError = false
        checkReleaseBuilds = false
    }
@ -165,11 +176,15 @@ android {
 }

 dependencies {
+    implementation(project(":i18n"))
+    implementation(project(":core"))
+    implementation(project(":source-api"))
+
    // Compose
+    implementation(platform(compose.bom))
    implementation(compose.activity)
    implementation(compose.foundation)
    implementation(compose.material3.core)
-    implementation(compose.material3.windowsizeclass)
    implementation(compose.material3.adapter)
    implementation(compose.material.icons)
    implementation(compose.animation)
@ -179,6 +194,7 @@ dependencies {
    implementation(compose.accompanist.webview)
    implementation(compose.accompanist.swiperefresh)
    implementation(compose.accompanist.flowlayout)
+    implementation(compose.accompanist.permissions)

    implementation(androidx.paging.runtime)
    implementation(androidx.paging.compose)
@ -192,9 +208,6 @@ dependencies {
    implementation(kotlinx.reflect)
    implementation(kotlinx.bundles.coroutines)

-    // Source models and interfaces from Tachiyomi 1.x
-    implementation(libs.tachiyomi.api)
-
    // AndroidX libraries
    implementation(androidx.annotation)
    implementation(androidx.appcompat)
@ -204,8 +217,9 @@ dependencies {
    implementation(androidx.corektx)
    implementation(androidx.splashscreen)
    implementation(androidx.recyclerview)
-    implementation(androidx.swiperefreshlayout)
    implementation(androidx.viewpager)
+    implementation(androidx.glance)
+    implementation(androidx.profileinstaller)

    implementation(androidx.bundles.lifecycle)

@ -226,9 +240,6 @@ dependencies {
    // Data serialization (JSON, protobuf)
    implementation(kotlinx.bundles.serialization)

-    // JavaScript engine
-    implementation(libs.bundles.js.engine)
-
    // HTML parser
    implementation(libs.jsoup)

@ -239,7 +250,6 @@ dependencies {

    // Preferences
    implementation(libs.preferencektx)
-    implementation(libs.flowpreferences)

    // Model View Presenter
    implementation(libs.bundles.nucleus)
@ -260,10 +270,8 @@ dependencies {

    // UI libraries
    implementation(libs.material)
-    implementation(libs.androidprocessbutton)
    implementation(libs.flexible.adapter.core)
    implementation(libs.flexible.adapter.ui)
-    implementation(libs.viewstatepageradapter)
    implementation(libs.photoview)
    implementation(libs.directionalviewpager) {
        exclude(group = "androidx.viewpager", module = "viewpager")
@ -272,6 +280,9 @@ dependencies {
    implementation(libs.markwon)
    implementation(libs.aboutLibraries.core)
    implementation(libs.aboutLibraries.compose)
+    implementation(libs.cascade)
+    implementation(libs.numberpicker)
+    implementation(libs.bundles.voyager)

    // Conductor
    implementation(libs.bundles.conductor)
@ -306,42 +317,62 @@ dependencies {
    implementation(libs.aniyomi.mpv)
 }

+androidComponents {
+    beforeVariants { variantBuilder ->
+        // Disables standardBenchmark
+        if (variantBuilder.buildType == "benchmark") {
+            variantBuilder.enable = variantBuilder.productFlavors.containsAll(listOf("default" to "dev"))
+        }
+    }
+}
+
 tasks {
    withType<Test> {
        useJUnitPlatform()
        testLogging {
-            events("passed", "skipped", "failed")
+            events(TestLogEvent.PASSED, TestLogEvent.SKIPPED, TestLogEvent.FAILED)
        }
    }

+    withType<org.jmailen.gradle.kotlinter.tasks.LintTask>().configureEach {
+        exclude { it.file.path.contains("generated[\\\\/]".toRegex()) }
+    }
+
    // See https://kotlinlang.org/docs/reference/experimental.html#experimental-status-of-experimental-api(-markers)
    withType<KotlinCompile> {
        kotlinOptions.freeCompilerArgs += listOf(
-            "-opt-in=kotlin.Experimental",
-            "-opt-in=kotlin.RequiresOptIn",
-            "-opt-in=kotlin.ExperimentalStdlibApi",
-            "-opt-in=kotlinx.coroutines.FlowPreview",
-            "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
-            "-opt-in=kotlinx.coroutines.InternalCoroutinesApi",
-            "-opt-in=kotlinx.serialization.ExperimentalSerializationApi",
            "-opt-in=coil.annotation.ExperimentalCoilApi",
+            "-opt-in=com.google.accompanist.pager.ExperimentalPagerApi",
+            "-opt-in=com.google.accompanist.permissions.ExperimentalPermissionsApi",
+            "-opt-in=androidx.compose.material.ExperimentalMaterialApi",
            "-opt-in=androidx.compose.material3.ExperimentalMaterial3Api",
            "-opt-in=androidx.compose.ui.ExperimentalComposeUiApi",
            "-opt-in=androidx.compose.foundation.ExperimentalFoundationApi",
+            "-opt-in=androidx.compose.animation.ExperimentalAnimationApi",
            "-opt-in=androidx.compose.animation.graphics.ExperimentalAnimationGraphicsApi",
-            "-opt-in=androidx.compose.material3.windowsizeclass.ExperimentalMaterial3WindowSizeClassApi",
+            "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
+            "-opt-in=kotlinx.coroutines.FlowPreview",
+            "-opt-in=kotlinx.coroutines.InternalCoroutinesApi",
+            "-opt-in=kotlinx.serialization.ExperimentalSerializationApi",
+        )
+
+        if (project.findProperty("tachiyomi.enableComposeCompilerMetrics") == "true") {
+            kotlinOptions.freeCompilerArgs += listOf(
+                "-P",
+                "plugin:androidx.compose.compiler.plugins.kotlin:reportsDestination=" +
+                    project.buildDir.absolutePath + "/compose_metrics"
+            )
+            kotlinOptions.freeCompilerArgs += listOf(
+                "-P",
+                "plugin:androidx.compose.compiler.plugins.kotlin:metricsDestination=" +
+                    project.buildDir.absolutePath + "/compose_metrics"
            )
        }
-
-    // Duplicating Hebrew string assets due to some locale code issues on different devices
-    val copyHebrewStrings = task("copyHebrewStrings", type = Copy::class) {
-        from("./src/main/res/values-he")
-        into("./src/main/res/values-iw")
-        include("**/*")
    }

    preBuild {
-        dependsOn(formatKotlin, copyHebrewStrings)
+        val ktlintTask = if (System.getenv("GITHUB_BASE_REF") == null) formatKotlin else lintKotlin
+        dependsOn(ktlintTask)
    }
 }

--- a/app/proguard-rules.pro
+++ b/app/proguard-rules.pro
@ -1,7 +1,6 @@
 -dontobfuscate

 # Keep common dependencies used in extensions
-keep,allowoptimization class eu.kanade.tachiyomi.** { public protected *; }
 -keep,allowoptimization class androidx.preference.** { public protected *; }
 -keep,allowoptimization class android.content.** { *; }
 -keep,allowoptimization class uy.kohesive.injekt.** { public protected *; }
@ -13,12 +12,19 @@
 -keep,allowoptimization class okio.** { public protected *; }
 -keep,allowoptimization class rx.** { public protected *; }
 -keep,allowoptimization class org.jsoup.** { public protected *; }
-keep,allowoptimization class com.squareup.duktape.** { public protected *; }
 -keep,allowoptimization class app.cash.quickjs.** { public protected *; }
 -keep,allowoptimization class uy.kohesive.injekt.** { public protected *; }
 -keep,allowoptimization class is.xyz.mpv.** { public protected *; }
 -keep,allowoptimization class com.arthenica.** { public protected *; }

+# From extensions-lib
+-keep,allowoptimization class eu.kanade.tachiyomi.network.interceptor.RateLimitInterceptorKt { public protected *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.network.interceptor.SpecificHostRateLimitInterceptorKt { public protected *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.network.NetworkHelper { public protected *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.network.OkHttpExtensionsKt { public protected *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.network.RequestsKt { public protected *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.AppInfo { public protected *; }
+
 ##---------------Begin: proguard configuration for RxJava 1.x  ----------
 -dontwarn sun.misc.**

@ -50,11 +56,11 @@
    kotlinx.serialization.KSerializer serializer(...);
 }

-keep,includedescriptorclasses class eu.kanade.tachiyomi.**$$serializer { *; }
-keepclassmembers class eu.kanade.tachiyomi.** {
+-keep,includedescriptorclasses class eu.kanade.**$$serializer { *; }
+-keepclassmembers class eu.kanade.** {
    *** Companion;
 }
-keepclasseswithmembers class eu.kanade.tachiyomi.** {
+-keepclasseswithmembers class eu.kanade.** {
    kotlinx.serialization.KSerializer serializer(...);
 }

@ -63,3 +69,6 @@
    <methods>;
 }
 ##---------------End: proguard configuration for kotlinx.serialization  ----------
+
+# XmlUtil
+-keep public enum nl.adaptivity.xmlutil.EventType { *; }
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@ -22,6 +22,12 @@
    <!-- To view extension packages in API 30+ -->
    <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES" />

+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+    <!-- Remove permission from Firebase dependency -->
+    <uses-permission android:name="com.google.android.gms.permission.AD_ID"
+        tools:node="remove" />
+
    <application
        android:name=".App"
        android:allowBackup="false"
@ -29,12 +35,18 @@
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:largeHeap="true"
+        android:localeConfig="@xml/locales_config"
        android:requestLegacyExternalStorage="true"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:theme="@style/Theme.Tachiyomi"
        android:supportsRtl="true"
        android:networkSecurityConfig="@xml/network_security_config">

+        <!-- enable profiling by macrobenchmark -->
+        <profileable
+            android:shell="true"
+            tools:targetApi="q" />
+
        <activity
            android:name=".ui.main.MainActivity"
            android:launchMode="singleTop"
@ -49,6 +61,12 @@
                android:name="android.app.shortcuts"
                android:resource="@xml/shortcuts" />
        </activity>
+
+        <activity
+            android:process=":error_handler"
+            android:name=".crash.CrashActivity"
+            android:exported="false" />
+
        <activity
            android:name=".ui.main.DeepLinkActivity"
            android:launchMode="singleTask"
@ -213,6 +231,20 @@
            </intent-filter>
        </receiver>

+        <receiver
+            android:name=".glance.UpdatesGridGlanceReceiver"
+            android:enabled="@bool/glance_appwidget_available"
+            android:exported="false"
+            android:label="@string/label_recent_updates">
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
+            </intent-filter>
+
+            <meta-data
+                android:name="android.appwidget.provider"
+                android:resource="@xml/updates_grid_glance_widget_info" />
+        </receiver>
+
        <service
            android:name=".data.library.LibraryUpdateService"
            android:exported="false" />
@ -242,6 +274,14 @@

        <service android:name=".extension.util.AnimeExtensionInstallService"
            android:exported="false" />
+        <service
+            android:name="androidx.appcompat.app.AppLocalesMetadataHolderService"
+            android:enabled="false"
+            android:exported="false">
+            <meta-data
+                android:name="autoStoreLocales"
+                android:value="true" />
+        </service>

        <provider
            android:name="androidx.core.content.FileProvider"
@ -261,11 +301,18 @@
            android:exported="true"
            android:permission="android.permission.INTERACT_ACROSS_USERS_FULL" />

-        <meta-data android:name="android.webkit.WebView.EnableSafeBrowsing"
+        <meta-data
+            android:name="android.webkit.WebView.EnableSafeBrowsing"
            android:value="false" />
-        <meta-data android:name="android.webkit.WebView.MetricsOptOut"
+        <meta-data
+            android:name="android.webkit.WebView.MetricsOptOut"
            android:value="true" />

+        <!-- Disable advertising ID collection for Firebase -->
+        <meta-data
+            android:name="google_analytics_adid_collection_enabled"
+            android:value="false" />
+
    </application>

 </manifest>
--- a/app/src/main/baseline-prof.txt
+++ b/app/src/main/baseline-prof.txt
--- a/app/src/main/java/eu/kanade/core/prefs/CheckboxState.kt
+++ b/app/src/main/java/eu/kanade/core/prefs/CheckboxState.kt
@ -0,0 +1,55 @@
+package eu.kanade.core.prefs
+
+import androidx.compose.ui.state.ToggleableState
+
+sealed class CheckboxState<T>(open val value: T) {
+    abstract fun next(): CheckboxState<T>
+
+    sealed class State<T>(override val value: T) : CheckboxState<T>(value) {
+        data class Checked<T>(override val value: T) : State<T>(value)
+        data class None<T>(override val value: T) : State<T>(value)
+
+        val isChecked: Boolean
+            get() = this is Checked
+
+        override fun next(): CheckboxState<T> {
+            return when (this) {
+                is Checked -> None(value)
+                is None -> Checked(value)
+            }
+        }
+    }
+    sealed class TriState<T>(override val value: T) : CheckboxState<T>(value) {
+        data class Include<T>(override val value: T) : TriState<T>(value)
+        data class Exclude<T>(override val value: T) : TriState<T>(value)
+        data class None<T>(override val value: T) : TriState<T>(value)
+
+        override fun next(): CheckboxState<T> {
+            return when (this) {
+                is Exclude -> None(value)
+                is Include -> Exclude(value)
+                is None -> Include(value)
+            }
+        }
+
+        fun asState(): ToggleableState {
+            return when (this) {
+                is Exclude -> ToggleableState.Indeterminate
+                is Include -> ToggleableState.On
+                is None -> ToggleableState.Off
+            }
+        }
+    }
+}
+
+inline fun <T> T.asCheckboxState(condition: (T) -> Boolean): CheckboxState.State<T> {
+    return if (condition(this)) {
+        CheckboxState.State.Checked(this)
+    } else {
+        CheckboxState.State.None(this)
+    }
+}
+
+inline fun <T> List<T>.mapAsCheckboxState(condition: (T) -> Boolean): List<CheckboxState.State<T>> {
+    return this.map { it.asCheckboxState(condition) }
+}
--- a/app/src/main/java/eu/kanade/core/prefs/PreferenceMutableState.kt
+++ b/app/src/main/java/eu/kanade/core/prefs/PreferenceMutableState.kt
@ -2,9 +2,8 @@ package eu.kanade.core.prefs

 import androidx.compose.runtime.MutableState
 import androidx.compose.runtime.mutableStateOf
-import com.fredporciuncula.flow.preferences.Preference
+import eu.kanade.tachiyomi.core.preference.Preference
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach

@ -16,8 +15,7 @@ class PreferenceMutableState<T>(
    private val state = mutableStateOf(preference.get())

    init {
-        preference.asFlow()
-            .distinctUntilChanged()
+        preference.changes()
            .onEach { state.value = it }
            .launchIn(scope)
    }
--- a/app/src/main/java/eu/kanade/core/util/ListUtils.kt
+++ b/app/src/main/java/eu/kanade/core/util/ListUtils.kt
@ -0,0 +1,16 @@
+package eu.kanade.core.util
+
+fun <T : R, R : Any> List<T>.insertSeparators(
+    generator: (T?, T?) -> R?,
+): List<R> {
+    if (isEmpty()) return emptyList()
+    val newList = mutableListOf<R>()
+    for (i in -1..lastIndex) {
+        val before = getOrNull(i)
+        before?.let { newList.add(it) }
+        val after = getOrNull(i + 1)
+        val separator = generator.invoke(before, after)
+        separator?.let { newList.add(it) }
+    }
+    return newList
+}
--- a/app/src/main/java/eu/kanade/data/DatabaseAdapter.kt
+++ b/app/src/main/java/eu/kanade/data/DatabaseAdapter.kt
@ -1,6 +1,7 @@
 package eu.kanade.data

 import com.squareup.sqldelight.ColumnAdapter
+import eu.kanade.tachiyomi.source.model.UpdateStrategy
 import java.util.Date

 val dateAdapter = object : ColumnAdapter<Date, Long> {
@ -18,3 +19,12 @@ val listOfStringsAdapter = object : ColumnAdapter<List<String>, String> {
        }
    override fun encode(value: List<String>) = value.joinToString(separator = listOfStringsSeparator)
 }
+
+val updateStrategyAdapter = object : ColumnAdapter<UpdateStrategy, Long> {
+    private val enumValues by lazy { UpdateStrategy.values() }
+
+    override fun decode(databaseValue: Long): UpdateStrategy =
+        enumValues.getOrElse(databaseValue.toInt()) { UpdateStrategy.ALWAYS_UPDATE }
+
+    override fun encode(value: UpdateStrategy): Long = value.ordinal.toLong()
+}
--- a/app/src/main/java/eu/kanade/data/DatabaseUtils.kt
+++ b/app/src/main/java/eu/kanade/data/DatabaseUtils.kt
@ -1,3 +0,0 @@
-package eu.kanade.data
-
-fun Boolean.toLong() = if (this) 1L else 0L
--- a/app/src/main/java/eu/kanade/data/category/CategoryRepositoryImpl.kt
+++ b/app/src/main/java/eu/kanade/data/category/CategoryRepositoryImpl.kt
@ -4,13 +4,17 @@ import eu.kanade.data.DatabaseHandler
 import eu.kanade.domain.category.model.Category
 import eu.kanade.domain.category.model.CategoryUpdate
 import eu.kanade.domain.category.repository.CategoryRepository
-import eu.kanade.domain.category.repository.DuplicateNameException
+import eu.kanade.tachiyomi.Database
 import kotlinx.coroutines.flow.Flow

 class CategoryRepositoryImpl(
    private val handler: DatabaseHandler,
 ) : CategoryRepository {

+    override suspend fun get(id: Long): Category? {
+        return handler.awaitOneOrNull { categoriesQueries.getCategory(id, categoryMapper) }
+    }
+
    override suspend fun getAll(): List<Category> {
        return handler.awaitList { categoriesQueries.getCategories(categoryMapper) }
    }
@ -31,29 +35,43 @@ class CategoryRepositoryImpl(
        }
    }

-    @Throws(DuplicateNameException::class)
-    override suspend fun insert(name: String, order: Long) {
-        if (checkDuplicateName(name)) throw DuplicateNameException(name)
+    override suspend fun insert(category: Category) {
        handler.await {
            categoriesQueries.insert(
-                name = name,
-                order = order,
-                flags = 0L,
+                name = category.name,
+                order = category.order,
+                flags = category.flags,
            )
        }
    }

-    @Throws(DuplicateNameException::class)
-    override suspend fun update(payload: CategoryUpdate) {
-        if (payload.name != null && checkDuplicateName(payload.name)) throw DuplicateNameException(payload.name)
+    override suspend fun updatePartial(update: CategoryUpdate) {
        handler.await {
+            updatePartialBlocking(update)
+        }
+    }
+
+    override suspend fun updatePartial(updates: List<CategoryUpdate>) {
+        handler.await(inTransaction = true) {
+            for (update in updates) {
+                updatePartialBlocking(update)
+            }
+        }
+    }
+
+    private fun Database.updatePartialBlocking(update: CategoryUpdate) {
        categoriesQueries.update(
-                name = payload.name,
-                order = payload.order,
-                flags = payload.flags,
-                categoryId = payload.id,
+            name = update.name,
+            order = update.order,
+            flags = update.flags,
+            categoryId = update.id,
        )
    }
+
+    override suspend fun updateAllFlags(flags: Long?) {
+        handler.await {
+            categoriesQueries.updateAllFlags(flags)
+        }
    }

    override suspend fun delete(categoryId: Long) {
@ -63,10 +81,4 @@ class CategoryRepositoryImpl(
            )
        }
    }
-
-    override suspend fun checkDuplicateName(name: String): Boolean {
-        return handler
-            .awaitList { categoriesQueries.getCategories() }
-            .any { it.name == name }
-    }
 }
--- a/app/src/main/java/eu/kanade/data/chapter/ChapterRepositoryImpl.kt
+++ b/app/src/main/java/eu/kanade/data/chapter/ChapterRepositoryImpl.kt
@ -1,11 +1,11 @@
 package eu.kanade.data.chapter

 import eu.kanade.data.DatabaseHandler
-import eu.kanade.data.toLong
 import eu.kanade.domain.chapter.model.Chapter
 import eu.kanade.domain.chapter.model.ChapterUpdate
 import eu.kanade.domain.chapter.repository.ChapterRepository
 import eu.kanade.tachiyomi.util.system.logcat
+import eu.kanade.tachiyomi.util.system.toLong
 import kotlinx.coroutines.flow.Flow
 import logcat.LogPriority

@ -81,6 +81,10 @@ class ChapterRepositoryImpl(
        return handler.awaitList { chaptersQueries.getChaptersByMangaId(mangaId, chapterMapper) }
    }

+    override suspend fun getBookmarkedChaptersByMangaId(mangaId: Long): List<Chapter> {
+        return handler.awaitList { chaptersQueries.getBookmarkedChaptersByMangaId(mangaId, chapterMapper) }
+    }
+
    override suspend fun getChapterById(id: Long): Chapter? {
        return handler.awaitOneOrNull { chaptersQueries.getChapterById(id, chapterMapper) }
    }
--- a/app/src/main/java/eu/kanade/data/chapter/CleanupChapterName.kt
+++ b/app/src/main/java/eu/kanade/data/chapter/CleanupChapterName.kt
@ -0,0 +1,47 @@
+package eu.kanade.data.chapter
+
+object CleanupChapterName {
+
+    fun await(chapterName: String, mangaTitle: String): String {
+        return chapterName
+            .trim()
+            .removePrefix(mangaTitle)
+            .trim(*CHAPTER_TRIM_CHARS)
+    }
+
+    private val CHAPTER_TRIM_CHARS = arrayOf(
+        // Whitespace
+        ' ',
+        '\u0009',
+        '\u000A',
+        '\u000B',
+        '\u000C',
+        '\u000D',
+        '\u0020',
+        '\u0085',
+        '\u00A0',
+        '\u1680',
+        '\u2000',
+        '\u2001',
+        '\u2002',
+        '\u2003',
+        '\u2004',
+        '\u2005',
+        '\u2006',
+        '\u2007',
+        '\u2008',
+        '\u2009',
+        '\u200A',
+        '\u2028',
+        '\u2029',
+        '\u202F',
+        '\u205F',
+        '\u3000',
+
+        // Separators
+        '-',
+        '_',
+        ',',
+        ':',
+    ).toCharArray()
+}
--- a/app/src/main/java/eu/kanade/data/history/HistoryRepositoryImpl.kt
+++ b/app/src/main/java/eu/kanade/data/history/HistoryRepositoryImpl.kt
@ -1,28 +1,21 @@
 package eu.kanade.data.history

-import androidx.paging.PagingSource
 import eu.kanade.data.DatabaseHandler
-import eu.kanade.data.chapter.chapterMapper
-import eu.kanade.data.manga.mangaMapper
-import eu.kanade.domain.chapter.model.Chapter
 import eu.kanade.domain.history.model.HistoryUpdate
 import eu.kanade.domain.history.model.HistoryWithRelations
 import eu.kanade.domain.history.repository.HistoryRepository
-import eu.kanade.domain.manga.model.Manga
 import eu.kanade.tachiyomi.util.system.logcat
+import kotlinx.coroutines.flow.Flow
 import logcat.LogPriority

 class HistoryRepositoryImpl(
    private val handler: DatabaseHandler,
 ) : HistoryRepository {

-    override fun getHistory(query: String): PagingSource<Long, HistoryWithRelations> {
-        return handler.subscribeToPagingSource(
-            countQuery = { historyViewQueries.countHistory(query) },
-            queryProvider = { limit, offset ->
-                historyViewQueries.history(query, limit, offset, historyWithRelationsMapper)
-            },
-        )
+    override fun getHistory(query: String): Flow<List<HistoryWithRelations>> {
+        return handler.subscribeToList {
+            historyViewQueries.history(query, historyWithRelationsMapper)
+        }
    }

    override suspend fun getLastHistory(): HistoryWithRelations? {
@ -31,45 +24,6 @@ class HistoryRepositoryImpl(
        }
    }

-    override suspend fun getNextChapter(mangaId: Long, chapterId: Long): Chapter? {
-        val chapter = handler.awaitOne { chaptersQueries.getChapterById(chapterId, chapterMapper) }
-        val manga = handler.awaitOne { mangasQueries.getMangaById(mangaId, mangaMapper) }
-
-        if (!chapter.read) {
-            return chapter
-        }
-
-        val sortFunction: (Chapter, Chapter) -> Int = when (manga.sorting) {
-            Manga.CHAPTER_SORTING_SOURCE -> { c1, c2 -> c2.sourceOrder.compareTo(c1.sourceOrder) }
-            Manga.CHAPTER_SORTING_NUMBER -> { c1, c2 -> c1.chapterNumber.compareTo(c2.chapterNumber) }
-            Manga.CHAPTER_SORTING_UPLOAD_DATE -> { c1, c2 -> c1.dateUpload.compareTo(c2.dateUpload) }
-            else -> throw NotImplementedError("Unknown sorting method")
-        }
-
-        val chapters = handler.awaitList { chaptersQueries.getChaptersByMangaId(mangaId, chapterMapper) }
-            .sortedWith(sortFunction)
-
-        val currChapterIndex = chapters.indexOfFirst { chapter.id == it.id }
-        return when (manga.sorting) {
-            Manga.CHAPTER_SORTING_SOURCE -> chapters.getOrNull(currChapterIndex + 1)
-            Manga.CHAPTER_SORTING_NUMBER -> {
-                val chapterNumber = chapter.chapterNumber
-
-                ((currChapterIndex + 1) until chapters.size)
-                    .map { chapters[it] }
-                    .firstOrNull {
-                        it.chapterNumber > chapterNumber &&
-                            it.chapterNumber <= chapterNumber + 1
-                    }
-            }
-            Manga.CHAPTER_SORTING_UPLOAD_DATE -> {
-                chapters.drop(currChapterIndex + 1)
-                    .firstOrNull { it.dateUpload >= chapter.dateUpload }
-            }
-            else -> throw NotImplementedError("Unknown sorting method")
-        }
-    }
-
    override suspend fun resetHistory(historyId: Long) {
        try {
            handler.await { historyQueries.resetHistoryById(historyId) }
--- a/app/src/main/java/eu/kanade/data/manga/MangaMapper.kt
+++ b/app/src/main/java/eu/kanade/data/manga/MangaMapper.kt
@ -1,40 +1,17 @@
 package eu.kanade.data.manga

-import eu.kanade.domain.chapter.model.Chapter
+import eu.kanade.domain.library.model.LibraryManga
 import eu.kanade.domain.manga.model.Manga
-import eu.kanade.tachiyomi.data.database.models.LibraryManga
+import eu.kanade.tachiyomi.source.model.UpdateStrategy

-val mangaMapper: (Long, Long, String, String?, String?, String?, List<String>?, String, Long, String?, Boolean, Long?, Long?, Boolean, Long, Long, Long, Long) -> Manga =
-    { id, source, url, artist, author, description, genre, title, status, thumbnailUrl, favorite, lastUpdate, _, initialized, viewer, chapterFlags, coverLastModified, dateAdded ->
+val mangaMapper: (Long, Long, String, String?, String?, String?, List<String>?, String, Long, String?, Boolean, Long?, Long?, Boolean, Long, Long, Long, Long, UpdateStrategy) -> Manga =
+    { id, source, url, artist, author, description, genre, title, status, thumbnailUrl, favorite, lastUpdate, _, initialized, viewerFlags, chapterFlags, coverLastModified, dateAdded, updateStrategy ->
        Manga(
            id = id,
            source = source,
            favorite = favorite,
            lastUpdate = lastUpdate ?: 0,
            dateAdded = dateAdded,
-            viewerFlags = viewer,
-            chapterFlags = chapterFlags,
-            coverLastModified = coverLastModified,
-            url = url,
-            title = title,
-            artist = artist,
-            author = author,
-            description = description,
-            genre = genre,
-            status = status,
-            thumbnailUrl = thumbnailUrl,
-            initialized = initialized,
-        )
-    }
-
-val mangaChapterMapper: (Long, Long, String, String?, String?, String?, List<String>?, String, Long, String?, Boolean, Long?, Long?, Boolean, Long, Long, Long, Long, Long, Long, String, String, String?, Boolean, Boolean, Long, Float, Long, Long, Long) -> Pair<Manga, Chapter> =
-    { _id, source, url, artist, author, description, genre, title, status, thumbnailUrl, favorite, lastUpdate, next_update, initialized, viewerFlags, chapterFlags, coverLastModified, dateAdded, chapterId, mangaId, chapterUrl, name, scanlator, read, bookmark, lastPageRead, chapterNumber, sourceOrder, dateFetch, dateUpload ->
-        Manga(
-            id = _id,
-            source = source,
-            favorite = favorite,
-            lastUpdate = lastUpdate ?: 0,
-            dateAdded = dateAdded,
            viewerFlags = viewerFlags,
            chapterFlags = chapterFlags,
            coverLastModified = coverLastModified,
@ -46,45 +23,41 @@ val mangaChapterMapper: (Long, Long, String, String?, String?, String?, List<Str
            genre = genre,
            status = status,
            thumbnailUrl = thumbnailUrl,
+            updateStrategy = updateStrategy,
            initialized = initialized,
-        ) to Chapter(
-            id = chapterId,
-            mangaId = mangaId,
-            read = read,
-            bookmark = bookmark,
-            lastPageRead = lastPageRead,
-            dateFetch = dateFetch,
-            sourceOrder = sourceOrder,
-            url = chapterUrl,
-            name = name,
-            dateUpload = dateUpload,
-            chapterNumber = chapterNumber,
-            scanlator = scanlator,
        )
    }

-val libraryManga: (Long, Long, String, String?, String?, String?, List<String>?, String, Long, String?, Boolean, Long?, Long?, Boolean, Long, Long, Long, Long, Long, Long, Long) -> LibraryManga =
-    { _id, source, url, artist, author, description, genre, title, status, thumbnail_url, favorite, last_update, next_update, initialized, viewer, chapter_flags, cover_last_modified, date_added, unread_count, read_count, category ->
-        LibraryManga().apply {
-            this.id = _id
-            this.source = source
-            this.url = url
-            this.artist = artist
-            this.author = author
-            this.description = description
-            this.genre = genre?.joinToString()
-            this.title = title
-            this.status = status.toInt()
-            this.thumbnail_url = thumbnail_url
-            this.favorite = favorite
-            this.last_update = last_update ?: 0
-            this.initialized = initialized
-            this.viewer_flags = viewer.toInt()
-            this.chapter_flags = chapter_flags.toInt()
-            this.cover_last_modified = cover_last_modified
-            this.date_added = date_added
-            this.unreadCount = unread_count.toInt()
-            this.readCount = read_count.toInt()
-            this.category = category.toInt()
-        }
+val libraryManga: (Long, Long, String, String?, String?, String?, List<String>?, String, Long, String?, Boolean, Long?, Long?, Boolean, Long, Long, Long, Long, UpdateStrategy, Long, Long, Long, Long, Long, Long, Long) -> LibraryManga =
+    { id, source, url, artist, author, description, genre, title, status, thumbnailUrl, favorite, lastUpdate, nextUpdate, initialized, viewerFlags, chapterFlags, coverLastModified, dateAdded, updateStrategy, totalCount, readCount, latestUpload, chapterFetchedAt, lastRead, bookmarkCount, category ->
+        LibraryManga(
+            manga = mangaMapper(
+                id,
+                source,
+                url,
+                artist,
+                author,
+                description,
+                genre,
+                title,
+                status,
+                thumbnailUrl,
+                favorite,
+                lastUpdate,
+                nextUpdate,
+                initialized,
+                viewerFlags,
+                chapterFlags,
+                coverLastModified,
+                dateAdded,
+                updateStrategy,
+            ),
+            category = category,
+            totalChapters = totalCount,
+            readCount = readCount,
+            bookmarkCount = bookmarkCount,
+            latestUpload = latestUpload,
+            chapterFetchedAt = chapterFetchedAt,
+            lastRead = lastRead,
+        )
    }
--- a/app/src/main/java/eu/kanade/data/manga/MangaRepositoryImpl.kt
+++ b/app/src/main/java/eu/kanade/data/manga/MangaRepositoryImpl.kt
@ -2,12 +2,13 @@ package eu.kanade.data.manga

 import eu.kanade.data.DatabaseHandler
 import eu.kanade.data.listOfStringsAdapter
-import eu.kanade.data.toLong
+import eu.kanade.data.updateStrategyAdapter
+import eu.kanade.domain.library.model.LibraryManga
 import eu.kanade.domain.manga.model.Manga
 import eu.kanade.domain.manga.model.MangaUpdate
 import eu.kanade.domain.manga.repository.MangaRepository
-import eu.kanade.tachiyomi.data.database.models.LibraryManga
 import eu.kanade.tachiyomi.util.system.logcat
+import eu.kanade.tachiyomi.util.system.toLong
 import kotlinx.coroutines.flow.Flow
 import logcat.LogPriority

@ -24,7 +25,11 @@ class MangaRepositoryImpl(
    }

    override suspend fun getMangaByUrlAndSourceId(url: String, sourceId: Long): Manga? {
-        return handler.awaitOneOrNull { mangasQueries.getMangaByUrlAndSource(url, sourceId, mangaMapper) }
+        return handler.awaitOneOrNull(inTransaction = true) { mangasQueries.getMangaByUrlAndSource(url, sourceId, mangaMapper) }
+    }
+
+    override fun getMangaByUrlAndSourceIdAsFlow(url: String, sourceId: Long): Flow<Manga?> {
+        return handler.subscribeToOneOrNull { mangasQueries.getMangaByUrlAndSource(url, sourceId, mangaMapper) }
    }

    override suspend fun getFavorites(): List<Manga> {
@ -32,11 +37,11 @@ class MangaRepositoryImpl(
    }

    override suspend fun getLibraryManga(): List<LibraryManga> {
-        return handler.awaitList { mangasQueries.getLibrary(libraryManga) }
+        return handler.awaitList { libraryViewQueries.library(libraryManga) }
    }

    override fun getLibraryMangaAsFlow(): Flow<List<LibraryManga>> {
-        return handler.subscribeToList { mangasQueries.getLibrary(libraryManga) }
+        return handler.subscribeToList { libraryViewQueries.library(libraryManga) }
    }

    override fun getFavoritesBySourceId(sourceId: Long): Flow<List<Manga>> {
@ -69,7 +74,7 @@ class MangaRepositoryImpl(
    }

    override suspend fun insert(manga: Manga): Long? {
-        return handler.awaitOneOrNull {
+        return handler.awaitOneOrNull(inTransaction = true) {
            mangasQueries.insert(
                source = manga.source,
                url = manga.url,
@ -88,6 +93,7 @@ class MangaRepositoryImpl(
                chapterFlags = manga.chapterFlags,
                coverLastModified = manga.coverLastModified,
                dateAdded = manga.dateAdded,
+                updateStrategy = manga.updateStrategy,
            )
            mangasQueries.selectLastInsertedRowId()
        }
@ -103,9 +109,9 @@ class MangaRepositoryImpl(
        }
    }

-    override suspend fun updateAll(values: List<MangaUpdate>): Boolean {
+    override suspend fun updateAll(mangaUpdates: List<MangaUpdate>): Boolean {
        return try {
-            partialUpdate(*values.toTypedArray())
+            partialUpdate(*mangaUpdates.toTypedArray())
            true
        } catch (e: Exception) {
            logcat(LogPriority.ERROR, e)
@ -113,9 +119,9 @@ class MangaRepositoryImpl(
        }
    }

-    private suspend fun partialUpdate(vararg values: MangaUpdate) {
+    private suspend fun partialUpdate(vararg mangaUpdates: MangaUpdate) {
        handler.await(inTransaction = true) {
-            values.forEach { value ->
+            mangaUpdates.forEach { value ->
                mangasQueries.update(
                    source = value.source,
                    url = value.url,
@ -134,6 +140,7 @@ class MangaRepositoryImpl(
                    coverLastModified = value.coverLastModified,
                    dateAdded = value.dateAdded,
                    mangaId = value.id,
+                    updateStrategy = value.updateStrategy?.let(updateStrategyAdapter::encode),
                )
            }
        }
--- a/app/src/main/java/eu/kanade/data/source/NoResultsException.kt
+++ b/app/src/main/java/eu/kanade/data/source/NoResultsException.kt
@ -0,0 +1,3 @@
+package eu.kanade.data.source
+
+class NoResultsException : Exception()
--- a/app/src/main/java/eu/kanade/data/source/SourceDataRepositoryImpl.kt
+++ b/app/src/main/java/eu/kanade/data/source/SourceDataRepositoryImpl.kt
@ -0,0 +1,23 @@
+package eu.kanade.data.source
+
+import eu.kanade.data.DatabaseHandler
+import eu.kanade.domain.source.model.SourceData
+import eu.kanade.domain.source.repository.SourceDataRepository
+import kotlinx.coroutines.flow.Flow
+
+class SourceDataRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : SourceDataRepository {
+
+    override fun subscribeAll(): Flow<List<SourceData>> {
+        return handler.subscribeToList { sourcesQueries.findAll(sourceDataMapper) }
+    }
+
+    override suspend fun getSourceData(id: Long): SourceData? {
+        return handler.awaitOneOrNull { sourcesQueries.findOne(id, sourceDataMapper) }
+    }
+
+    override suspend fun upsertSourceData(id: Long, lang: String, name: String) {
+        handler.await { sourcesQueries.upsert(id, lang, name) }
+    }
+}
--- a/app/src/main/java/eu/kanade/data/source/SourcePagingSource.kt
+++ b/app/src/main/java/eu/kanade/data/source/SourcePagingSource.kt
@ -0,0 +1,62 @@
+package eu.kanade.data.source
+
+import androidx.paging.PagingState
+import eu.kanade.domain.source.model.SourcePagingSourceType
+import eu.kanade.tachiyomi.source.CatalogueSource
+import eu.kanade.tachiyomi.source.model.FilterList
+import eu.kanade.tachiyomi.source.model.MangasPage
+import eu.kanade.tachiyomi.source.model.SManga
+import eu.kanade.tachiyomi.util.lang.awaitSingle
+import eu.kanade.tachiyomi.util.lang.withIOContext
+
+abstract class SourcePagingSource(
+    protected val source: CatalogueSource,
+) : SourcePagingSourceType() {
+
+    abstract suspend fun requestNextPage(currentPage: Int): MangasPage
+
+    override suspend fun load(params: LoadParams<Long>): LoadResult<Long, SManga> {
+        val page = params.key ?: 1
+
+        val mangasPage = try {
+            withIOContext {
+                requestNextPage(page.toInt())
+                    .takeIf { it.mangas.isNotEmpty() }
+                    ?: throw NoResultsException()
+            }
+        } catch (e: Exception) {
+            return LoadResult.Error(e)
+        }
+
+        return LoadResult.Page(
+            data = mangasPage.mangas,
+            prevKey = null,
+            nextKey = if (mangasPage.hasNextPage) page + 1 else null,
+        )
+    }
+
+    override fun getRefreshKey(state: PagingState<Long, SManga>): Long? {
+        return state.anchorPosition?.let { anchorPosition ->
+            val anchorPage = state.closestPageToPosition(anchorPosition)
+            anchorPage?.prevKey ?: anchorPage?.nextKey
+        }
+    }
+}
+
+class SourceSearchPagingSource(source: CatalogueSource, val query: String, val filters: FilterList) : SourcePagingSource(source) {
+    override suspend fun requestNextPage(currentPage: Int): MangasPage {
+        return source.fetchSearchManga(currentPage, query, filters).awaitSingle()
+    }
+}
+
+class SourcePopularPagingSource(source: CatalogueSource) : SourcePagingSource(source) {
+    override suspend fun requestNextPage(currentPage: Int): MangasPage {
+        return source.fetchPopularManga(currentPage).awaitSingle()
+    }
+}
+
+class SourceLatestPagingSource(source: CatalogueSource) : SourcePagingSource(source) {
+    override suspend fun requestNextPage(currentPage: Int): MangasPage {
+        return source.fetchLatestUpdates(currentPage).awaitSingle()
+    }
+}
--- a/app/src/main/java/eu/kanade/data/source/SourceRepositoryImpl.kt
+++ b/app/src/main/java/eu/kanade/data/source/SourceRepositoryImpl.kt
@ -2,13 +2,15 @@ package eu.kanade.data.source

 import eu.kanade.data.DatabaseHandler
 import eu.kanade.domain.source.model.Source
-import eu.kanade.domain.source.model.SourceData
+import eu.kanade.domain.source.model.SourcePagingSourceType
+import eu.kanade.domain.source.model.SourceWithCount
 import eu.kanade.domain.source.repository.SourceRepository
+import eu.kanade.tachiyomi.source.CatalogueSource
 import eu.kanade.tachiyomi.source.LocalSource
 import eu.kanade.tachiyomi.source.SourceManager
+import eu.kanade.tachiyomi.source.model.FilterList
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
-import eu.kanade.tachiyomi.source.Source as LoadedSource

 class SourceRepositoryImpl(
    private val sourceManager: SourceManager,
@ -41,21 +43,32 @@ class SourceRepositoryImpl(
        }
    }

-    override fun getSourcesWithNonLibraryManga(): Flow<List<Pair<LoadedSource, Long>>> {
+    override fun getSourcesWithNonLibraryManga(): Flow<List<SourceWithCount>> {
        val sourceIdWithNonLibraryManga = handler.subscribeToList { mangasQueries.getSourceIdsWithNonLibraryManga() }
        return sourceIdWithNonLibraryManga.map { sourceId ->
            sourceId.map { (sourceId, count) ->
                val source = sourceManager.getOrStub(sourceId)
-                source to count
+                SourceWithCount(sourceMapper(source), count)
            }
        }
    }

-    override suspend fun getSourceData(id: Long): SourceData? {
-        return handler.awaitOneOrNull { sourcesQueries.getSourceData(id, sourceDataMapper) }
+    override fun search(
+        sourceId: Long,
+        query: String,
+        filterList: FilterList,
+    ): SourcePagingSourceType {
+        val source = sourceManager.get(sourceId) as CatalogueSource
+        return SourceSearchPagingSource(source, query, filterList)
    }

-    override suspend fun upsertSourceData(id: Long, lang: String, name: String) {
-        handler.await { sourcesQueries.upsert(id, lang, name) }
+    override fun getPopular(sourceId: Long): SourcePagingSourceType {
+        val source = sourceManager.get(sourceId) as CatalogueSource
+        return SourcePopularPagingSource(source)
+    }
+
+    override fun getLatest(sourceId: Long): SourcePagingSourceType {
+        val source = sourceManager.get(sourceId) as CatalogueSource
+        return SourceLatestPagingSource(source)
    }
 }
--- a/app/src/main/java/eu/kanade/data/track/TrackRepositoryImpl.kt
+++ b/app/src/main/java/eu/kanade/data/track/TrackRepositoryImpl.kt
@ -44,9 +44,9 @@ class TrackRepositoryImpl(
        insertValues(*tracks.toTypedArray())
    }

-    private suspend fun insertValues(vararg values: Track) {
+    private suspend fun insertValues(vararg tracks: Track) {
        handler.await(inTransaction = true) {
-            values.forEach { mangaTrack ->
+            tracks.forEach { mangaTrack ->
                manga_syncQueries.insert(
                    mangaId = mangaTrack.mangaId,
                    syncId = mangaTrack.syncId,
--- a/app/src/main/java/eu/kanade/data/updates/UpdatesMapper.kt
+++ b/app/src/main/java/eu/kanade/data/updates/UpdatesMapper.kt
@ -0,0 +1,26 @@
+package eu.kanade.data.updates
+
+import eu.kanade.domain.manga.model.MangaCover
+import eu.kanade.domain.updates.model.UpdatesWithRelations
+
+val updateWithRelationMapper: (Long, String, Long, String, String?, Boolean, Boolean, Long, Boolean, String?, Long, Long, Long) -> UpdatesWithRelations = {
+        mangaId, mangaTitle, chapterId, chapterName, scanlator, read, bookmark, sourceId, favorite, thumbnailUrl, coverLastModified, _, dateFetch ->
+    UpdatesWithRelations(
+        mangaId = mangaId,
+        mangaTitle = mangaTitle,
+        chapterId = chapterId,
+        chapterName = chapterName,
+        scanlator = scanlator,
+        read = read,
+        bookmark = bookmark,
+        sourceId = sourceId,
+        dateFetch = dateFetch,
+        coverData = MangaCover(
+            mangaId = mangaId,
+            sourceId = sourceId,
+            isMangaFavorite = favorite,
+            url = thumbnailUrl,
+            lastModified = coverLastModified,
+        ),
+    )
+}
--- a/app/src/main/java/eu/kanade/data/updates/UpdatesRepositoryImpl.kt
+++ b/app/src/main/java/eu/kanade/data/updates/UpdatesRepositoryImpl.kt
@ -0,0 +1,17 @@
+package eu.kanade.data.updates
+
+import eu.kanade.data.DatabaseHandler
+import eu.kanade.domain.updates.model.UpdatesWithRelations
+import eu.kanade.domain.updates.repository.UpdatesRepository
+import kotlinx.coroutines.flow.Flow
+
+class UpdatesRepositoryImpl(
+    val databaseHandler: DatabaseHandler,
+) : UpdatesRepository {
+
+    override fun subscribeAll(after: Long): Flow<List<UpdatesWithRelations>> {
+        return databaseHandler.subscribeToList {
+            updatesViewQueries.updates(after, updateWithRelationMapper)
+        }
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/DomainModule.kt
+++ b/app/src/main/java/eu/kanade/domain/DomainModule.kt
@ -10,13 +10,13 @@ import eu.kanade.data.chapter.ChapterRepositoryImpl
 import eu.kanade.data.episode.EpisodeRepositoryImpl
 import eu.kanade.data.history.HistoryRepositoryImpl
 import eu.kanade.data.manga.MangaRepositoryImpl
+import eu.kanade.data.source.SourceDataRepositoryImpl
 import eu.kanade.data.source.SourceRepositoryImpl
 import eu.kanade.data.track.TrackRepositoryImpl
 import eu.kanade.domain.anime.interactor.GetAnime
 import eu.kanade.domain.anime.interactor.GetAnimeWithEpisodes
 import eu.kanade.domain.anime.interactor.GetAnimelibAnime
 import eu.kanade.domain.anime.interactor.GetDuplicateLibraryAnime
-import eu.kanade.domain.anime.interactor.InsertAnime
 import eu.kanade.domain.anime.interactor.SetAnimeEpisodeFlags
 import eu.kanade.domain.anime.interactor.SetAnimeViewerFlags
 import eu.kanade.domain.anime.interactor.UpdateAnime
@ -46,20 +46,30 @@ import eu.kanade.domain.animetrack.interactor.DeleteAnimeTrack
 import eu.kanade.domain.animetrack.interactor.GetAnimeTracks
 import eu.kanade.domain.animetrack.interactor.InsertAnimeTrack
 import eu.kanade.domain.animetrack.repository.AnimeTrackRepository
+import eu.kanade.data.updates.UpdatesRepositoryImpl
+import eu.kanade.domain.category.interactor.CreateCategoryWithName
 import eu.kanade.domain.category.interactor.DeleteCategory
 import eu.kanade.domain.category.interactor.DeleteCategoryAnime
 import eu.kanade.domain.category.interactor.GetCategories
 import eu.kanade.domain.category.interactor.GetCategoriesAnime
-import eu.kanade.domain.category.interactor.InsertCategory
-import eu.kanade.domain.category.interactor.InsertCategoryAnime
 import eu.kanade.domain.category.interactor.SetAnimeCategories
+import eu.kanade.domain.category.interactor.RenameCategory
+import eu.kanade.domain.category.interactor.RenameAnimeCategory
+import eu.kanade.domain.category.interactor.ReorderCategory
+import eu.kanade.domain.category.interactor.ReorderAnimeCategory
+import eu.kanade.domain.category.interactor.ResetCategoryFlags
+import eu.kanade.domain.category.interactor.ResetAnimeCategoryFlags
+import eu.kanade.domain.category.interactor.SetDisplayModeForCategory
+import eu.kanade.domain.category.interactor.SetDisplayModeForAnimeCategory
 import eu.kanade.domain.category.interactor.SetMangaCategories
+import eu.kanade.domain.category.interactor.SetSortModeForCategory
 import eu.kanade.domain.category.interactor.UpdateCategory
 import eu.kanade.domain.category.interactor.UpdateCategoryAnime
 import eu.kanade.domain.category.repository.CategoryRepository
 import eu.kanade.domain.category.repository.CategoryRepositoryAnime
 import eu.kanade.domain.chapter.interactor.GetChapter
 import eu.kanade.domain.chapter.interactor.GetChapterByMangaId
+import eu.kanade.domain.chapter.interactor.SetMangaDefaultChapterFlags
 import eu.kanade.domain.chapter.interactor.SetReadStatus
 import eu.kanade.domain.chapter.interactor.ShouldUpdateDbChapter
 import eu.kanade.domain.chapter.interactor.SyncChaptersWithSource
@ -77,9 +87,8 @@ import eu.kanade.domain.episode.interactor.UpdateEpisode
 import eu.kanade.domain.episode.repository.EpisodeRepository
 import eu.kanade.domain.extension.interactor.GetExtensionLanguages
 import eu.kanade.domain.extension.interactor.GetExtensionSources
-import eu.kanade.domain.extension.interactor.GetExtensionUpdates
-import eu.kanade.domain.extension.interactor.GetExtensions
-import eu.kanade.domain.history.interactor.DeleteHistoryTable
+import eu.kanade.domain.extension.interactor.GetExtensionsByType
+import eu.kanade.domain.history.interactor.DeleteAllHistory
 import eu.kanade.domain.history.interactor.GetHistory
 import eu.kanade.domain.history.interactor.GetNextChapter
 import eu.kanade.domain.history.interactor.RemoveHistoryById
@ -91,7 +100,7 @@ import eu.kanade.domain.manga.interactor.GetFavorites
 import eu.kanade.domain.manga.interactor.GetLibraryManga
 import eu.kanade.domain.manga.interactor.GetManga
 import eu.kanade.domain.manga.interactor.GetMangaWithChapters
-import eu.kanade.domain.manga.interactor.InsertManga
+import eu.kanade.domain.manga.interactor.NetworkToLocalManga
 import eu.kanade.domain.manga.interactor.ResetViewerFlags
 import eu.kanade.domain.manga.interactor.SetMangaChapterFlags
 import eu.kanade.domain.manga.interactor.SetMangaViewerFlags
@ -99,19 +108,22 @@ import eu.kanade.domain.manga.interactor.UpdateManga
 import eu.kanade.domain.manga.repository.MangaRepository
 import eu.kanade.domain.source.interactor.GetEnabledSources
 import eu.kanade.domain.source.interactor.GetLanguagesWithSources
-import eu.kanade.domain.source.interactor.GetSourceData
+import eu.kanade.domain.source.interactor.GetRemoteManga
 import eu.kanade.domain.source.interactor.GetSourcesWithFavoriteCount
 import eu.kanade.domain.source.interactor.GetSourcesWithNonLibraryManga
 import eu.kanade.domain.source.interactor.SetMigrateSorting
 import eu.kanade.domain.source.interactor.ToggleLanguage
 import eu.kanade.domain.source.interactor.ToggleSource
 import eu.kanade.domain.source.interactor.ToggleSourcePin
-import eu.kanade.domain.source.interactor.UpsertSourceData
+import eu.kanade.domain.source.repository.SourceDataRepository
 import eu.kanade.domain.source.repository.SourceRepository
 import eu.kanade.domain.track.interactor.DeleteTrack
 import eu.kanade.domain.track.interactor.GetTracks
+import eu.kanade.domain.track.interactor.GetTracksPerManga
 import eu.kanade.domain.track.interactor.InsertTrack
 import eu.kanade.domain.track.repository.TrackRepository
+import eu.kanade.domain.updates.interactor.GetUpdates
+import eu.kanade.domain.updates.repository.UpdatesRepository
 import uy.kohesive.injekt.api.InjektModule
 import uy.kohesive.injekt.api.InjektRegistrar
 import uy.kohesive.injekt.api.addFactory
@ -123,62 +135,68 @@ import eu.kanade.domain.anime.interactor.ResetViewerFlags as ResetViewerFlagsAni
 class DomainModule : InjektModule {

    override fun InjektRegistrar.registerInjectables() {
+
+        addSingletonFactory<CategoryRepositoryAnime> { CategoryRepositoryImplAnime(get()) }
+        addFactory { GetCategoriesAnime(get()) }
+        addFactory { ResetAnimeCategoryFlags(get(), get()) }
+        addFactory { SetDisplayModeForAnimeCategory(get(), get()) }
+        addFactory { SetSortModeForAnimeCategory(get(), get()) }
+        addFactory { CreateAnimeCategoryWithName(get(), get()) }
+        addFactory { RenameAnimeCategory(get()) }
+        addFactory { ReorderAnimeCategory(get()) }
+        addFactory { UpdateAnimeCategory(get()) }
+        addFactory { DeleteAnimeCategory(get()) }
+
+        addSingletonFactory<CategoryRepository> { CategoryRepositoryImpl(get()) }
+        addFactory { GetCategories(get()) }
+        addFactory { ResetCategoryFlags(get(), get()) }
+        addFactory { SetDisplayModeForCategory(get(), get()) }
+        addFactory { SetSortModeForCategory(get(), get()) }
+        addFactory { CreateCategoryWithName(get(), get()) }
+        addFactory { RenameCategory(get()) }
+        addFactory { ReorderCategory(get()) }
+        addFactory { UpdateCategory(get()) }
+        addFactory { DeleteCategory(get()) }
+
        addSingletonFactory<AnimeRepository> { AnimeRepositoryImpl(get()) }
        addFactory { GetDuplicateLibraryAnime(get()) }
        addFactory { GetFavoritesAnime(get()) }
        addFactory { GetAnimelibAnime(get()) }
        addFactory { GetAnimeWithEpisodes(get(), get()) }
        addFactory { GetAnime(get()) }
-        addFactory { GetNextEpisode(get()) }
+        addFactory { GetNextEpisode(get(), get(), get(), get()) }
        addFactory { ResetViewerFlagsAnime(get()) }
        addFactory { SetAnimeEpisodeFlags(get()) }
+        addFactory { SetAnimeDefaultEpisodeFlags(get(), get(), get()) }
        addFactory { SetAnimeViewerFlags(get()) }
-        addFactory { InsertAnime(get()) }
+        addFactory { NetworkToLocalAnime(get()) }
        addFactory { UpdateAnime(get()) }
        addFactory { SetAnimeCategories(get()) }

-        addSingletonFactory<EpisodeRepository> { EpisodeRepositoryImpl(get()) }
-        addFactory { GetEpisode(get()) }
-        addFactory { GetEpisodeByAnimeId(get()) }
-        addFactory { UpdateEpisode(get()) }
-        addFactory { SetSeenStatus(get(), get(), get(), get()) }
-        addFactory { ShouldUpdateDbEpisode() }
-        addFactory { SyncEpisodesWithSource(get(), get(), get(), get()) }
-        addFactory { SyncEpisodesWithTrackServiceTwoWay(get(), get()) }
-
-        addSingletonFactory<CategoryRepositoryAnime> { CategoryRepositoryImplAnime(get()) }
-        addFactory { GetCategoriesAnime(get()) }
-        addFactory { InsertCategoryAnime(get()) }
-        addFactory { UpdateCategoryAnime(get()) }
-        addFactory { DeleteCategoryAnime(get()) }
-
-        addSingletonFactory<CategoryRepository> { CategoryRepositoryImpl(get()) }
-        addFactory { GetCategories(get()) }
-        addFactory { InsertCategory(get()) }
-        addFactory { UpdateCategory(get()) }
-        addFactory { DeleteCategory(get()) }
-
        addSingletonFactory<MangaRepository> { MangaRepositoryImpl(get()) }
        addFactory { GetDuplicateLibraryManga(get()) }
        addFactory { GetFavorites(get()) }
        addFactory { GetLibraryManga(get()) }
        addFactory { GetMangaWithChapters(get(), get()) }
        addFactory { GetManga(get()) }
-        addFactory { GetNextChapter(get()) }
+        addFactory { GetNextChapter(get(), get(), get(), get()) }
        addFactory { ResetViewerFlags(get()) }
        addFactory { SetMangaChapterFlags(get()) }
+        addFactory { SetMangaDefaultChapterFlags(get(), get(), get()) }
        addFactory { SetMangaViewerFlags(get()) }
-        addFactory { InsertManga(get()) }
+        addFactory { NetworkToLocalManga(get()) }
        addFactory { UpdateManga(get()) }
        addFactory { SetMangaCategories(get()) }

        addSingletonFactory<AnimeTrackRepository> { AnimeTrackRepositoryImpl(get()) }
        addFactory { DeleteAnimeTrack(get()) }
+        addFactory { GetAnimeTracksPerAnime(get()) 
        addFactory { GetAnimeTracks(get()) }
        addFactory { InsertAnimeTrack(get()) }

        addSingletonFactory<TrackRepository> { TrackRepositoryImpl(get()) }
        addFactory { DeleteTrack(get()) }
+        addFactory { GetTracksPerManga(get()) }
        addFactory { GetTracks(get()) }
        addFactory { InsertTrack(get()) }

@ -191,53 +209,69 @@ class DomainModule : InjektModule {
        addFactory { SyncChaptersWithSource(get(), get(), get(), get()) }
        addFactory { SyncChaptersWithTrackServiceTwoWay(get(), get()) }

+        addSingletonFactory<EpisodeRepository> { EpisodeRepositoryImpl(get()) }
+        addFactory { GetEpisode(get()) }
+        addFactory { GetEpisodeByAnimeId(get()) }
+        addFactory { UpdateEpisode(get()) }
+        addFactory { SetSeenStatus(get(), get(), get(), get()) }
+        addFactory { ShouldUpdateDbEpisode() }
+        addFactory { SyncEpisodesWithSource(get(), get(), get(), get()) }
+        addFactory { SyncEpisodesWithTrackServiceTwoWay(get(), get()) }
+
        addSingletonFactory<AnimeHistoryRepository> { AnimeHistoryRepositoryImpl(get()) }
-        addFactory { DeleteAnimeHistoryTable(get()) }
+        addFactory { DeleteAllAnimeHistory(get()) }
        addFactory { GetAnimeHistory(get()) }
        addFactory { UpsertAnimeHistory(get()) }
        addFactory { RemoveAnimeHistoryById(get()) }
        addFactory { RemoveAnimeHistoryByAnimeId(get()) }

+        addFactory { DeleteAnimeDownload(get(), get()) }
+
+        addFactory { GetAnimeExtensionsByType(get(), get()) }
+        addFactory { GetAnimeExtensionSources(get()) }
+        addFactory { GetAnimeExtensionLanguages(get(), get()) }
+
        addSingletonFactory<HistoryRepository> { HistoryRepositoryImpl(get()) }
-        addFactory { DeleteHistoryTable(get()) }
+        addFactory { DeleteAllHistory(get()) }
        addFactory { GetHistory(get()) }
        addFactory { UpsertHistory(get()) }
        addFactory { RemoveHistoryById(get()) }
        addFactory { RemoveHistoryByMangaId(get()) }
        
-        addSingletonFactory<AnimeSourceRepository> { AnimeSourceRepositoryImpl(get(), get()) }
-        addFactory { GetEnabledAnimeSources(get(), get()) }
-        addFactory { GetLanguagesWithAnimeSources(get(), get()) }
-        addFactory { GetAnimeSourceData(get()) }
-        addFactory { GetAnimeSourcesWithFavoriteCount(get(), get()) }
-        addFactory { GetAnimeSourcesWithNonLibraryAnime(get()) }
-        addFactory { ToggleAnimeSource(get()) }
-        addFactory { ToggleAnimeSourcePin(get()) }
-        addFactory { UpsertAnimeSourceData(get()) }
-
-        addFactory { GetAnimeExtensions(get(), get()) }
-        addFactory { GetAnimeExtensionSources(get()) }
-        addFactory { GetAnimeExtensionUpdates(get(), get()) }
-        addFactory { GetAnimeExtensionLanguages(get(), get()) }
-
        addFactory { DeleteDownload(get(), get()) }
-        addFactory { DeleteAnimeDownload(get(), get()) }

-        addFactory { GetExtensions(get(), get()) }
+        addFactory { GetExtensionsByType(get(), get()) }
        addFactory { GetExtensionSources(get()) }
-        addFactory { GetExtensionUpdates(get(), get()) }
        addFactory { GetExtensionLanguages(get(), get()) }

+        addSingletonFactory<AnimeUpdatesRepository> { AnimeUpdatesRepositoryImpl(get()) }
+        addFactory { GetAnimeUpdates(get(), get()) }
+
+        addSingletonFactory<UpdatesRepository> { UpdatesRepositoryImpl(get()) }
+        addFactory { GetUpdates(get(), get()) }
+
+        addSingletonFactory<AnimeSourceRepository> { AnimeSourceRepositoryImpl(get(), get()) }
+        addSingletonFactory<AnimeSourceDataRepository> { AnimeSourceDataRepositoryImpl(get()) }
+        addFactory { GetEnabledAnimeSources(get(), get()) }
+        addFactory { GetLanguagesWithAnimeSources(get(), get()) }
+        addFactory { GetRemoteAnime(get()) }
+        addFactory { GetAnimeSourcesWithFavoriteCount(get(), get()) }
+        addFactory { GetAnimeSourcesWithNonLibraryAnime(get()) }
+        addFactory { SetAnimeMigrateSorting(get()) }
+        addFactory { ToggleAnimeLanguage(get()) }
+        addFactory { ToggleAnimeSource(get()) }
+        addFactory { ToggleAnimeSourcePin(get()) }
+
        addSingletonFactory<SourceRepository> { SourceRepositoryImpl(get(), get()) }
+        addSingletonFactory<SourceDataRepository> { SourceDataRepositoryImpl(get()) }
        addFactory { GetEnabledSources(get(), get()) }
        addFactory { GetLanguagesWithSources(get(), get()) }
-        addFactory { GetSourceData(get()) }
+        addFactory { GetRemoteManga(get()) }
        addFactory { GetSourcesWithFavoriteCount(get(), get()) }
        addFactory { GetSourcesWithNonLibraryManga(get()) }
        addFactory { SetMigrateSorting(get()) }
        addFactory { ToggleLanguage(get()) }
        addFactory { ToggleSource(get()) }
        addFactory { ToggleSourcePin(get()) }
-        addFactory { UpsertSourceData(get()) }
    }
 }
--- a/app/src/main/java/eu/kanade/domain/backup/service/BackupPreferences.kt
+++ b/app/src/main/java/eu/kanade/domain/backup/service/BackupPreferences.kt
@ -0,0 +1,16 @@
+package eu.kanade.domain.backup.service
+
+import eu.kanade.tachiyomi.core.preference.PreferenceStore
+import eu.kanade.tachiyomi.core.provider.FolderProvider
+
+class BackupPreferences(
+    private val folderProvider: FolderProvider,
+    private val preferenceStore: PreferenceStore,
+) {
+
+    fun backupsDirectory() = preferenceStore.getString("backup_directory", folderProvider.path())
+
+    fun numberOfBackups() = preferenceStore.getInt("backup_slots", 2)
+
+    fun backupInterval() = preferenceStore.getInt("backup_interval", 12)
+}
--- a/app/src/main/java/eu/kanade/domain/base/BasePreferences.kt
+++ b/app/src/main/java/eu/kanade/domain/base/BasePreferences.kt
@ -0,0 +1,30 @@
+package eu.kanade.domain.base
+
+import android.content.Context
+import eu.kanade.tachiyomi.core.preference.PreferenceStore
+import eu.kanade.tachiyomi.core.preference.getEnum
+import eu.kanade.tachiyomi.data.preference.PreferenceValues
+import eu.kanade.tachiyomi.util.system.DeviceUtil
+import eu.kanade.tachiyomi.util.system.isPreviewBuildType
+import eu.kanade.tachiyomi.util.system.isReleaseBuildType
+
+class BasePreferences(
+    val context: Context,
+    private val preferenceStore: PreferenceStore,
+) {
+
+    fun confirmExit() = preferenceStore.getBoolean("pref_confirm_exit", false)
+
+    fun downloadedOnly() = preferenceStore.getBoolean("pref_downloaded_only", false)
+
+    fun incognitoMode() = preferenceStore.getBoolean("incognito_mode", false)
+
+    fun automaticExtUpdates() = preferenceStore.getBoolean("automatic_ext_updates", true)
+
+    fun extensionInstaller() = preferenceStore.getEnum(
+        "extension_installer",
+        if (DeviceUtil.isMiui) PreferenceValues.ExtensionInstaller.LEGACY else PreferenceValues.ExtensionInstaller.PACKAGEINSTALLER,
+    )
+
+    fun acraEnabled() = preferenceStore.getBoolean("acra.enable", isPreviewBuildType || isReleaseBuildType)
+}
--- a/app/src/main/java/eu/kanade/domain/category/interactor/CreateCategoryWithName.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/CreateCategoryWithName.kt
@ -0,0 +1,52 @@
+package eu.kanade.domain.category.interactor
+
+import eu.kanade.domain.category.model.Category
+import eu.kanade.domain.category.model.anyWithName
+import eu.kanade.domain.category.repository.CategoryRepository
+import eu.kanade.domain.library.service.LibraryPreferences
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext
+import eu.kanade.tachiyomi.util.system.logcat
+import logcat.LogPriority
+
+class CreateCategoryWithName(
+    private val categoryRepository: CategoryRepository,
+    private val preferences: LibraryPreferences,
+) {
+
+    private val initialFlags: Long
+        get() {
+            val sort = preferences.librarySortingMode().get()
+            return preferences.libraryDisplayMode().get().flag or
+                sort.type.flag or
+                sort.direction.flag
+        }
+
+    suspend fun await(name: String): Result = withNonCancellableContext {
+        val categories = categoryRepository.getAll()
+        if (categories.anyWithName(name)) {
+            return@withNonCancellableContext Result.NameAlreadyExistsError
+        }
+
+        val nextOrder = categories.maxOfOrNull { it.order }?.plus(1) ?: 0
+        val newCategory = Category(
+            id = 0,
+            name = name,
+            order = nextOrder,
+            flags = initialFlags,
+        )
+
+        try {
+            categoryRepository.insert(newCategory)
+            Result.Success
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            Result.InternalError(e)
+        }
+    }
+
+    sealed class Result {
+        object Success : Result()
+        object NameAlreadyExistsError : Result()
+        data class InternalError(val error: Throwable) : Result()
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/category/interactor/DeleteCategory.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/DeleteCategory.kt
@ -1,12 +1,42 @@
 package eu.kanade.domain.category.interactor

+import eu.kanade.domain.category.model.CategoryUpdate
 import eu.kanade.domain.category.repository.CategoryRepository
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext
+import eu.kanade.tachiyomi.util.system.logcat
+import logcat.LogPriority

 class DeleteCategory(
    private val categoryRepository: CategoryRepository,
 ) {

-    suspend fun await(categoryId: Long) {
+    suspend fun await(categoryId: Long) = withNonCancellableContext {
+        try {
            categoryRepository.delete(categoryId)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            return@withNonCancellableContext Result.InternalError(e)
+        }
+
+        val categories = categoryRepository.getAll()
+        val updates = categories.mapIndexed { index, category ->
+            CategoryUpdate(
+                id = category.id,
+                order = index.toLong(),
+            )
+        }
+
+        try {
+            categoryRepository.updatePartial(updates)
+            Result.Success
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            Result.InternalError(e)
+        }
+    }
+
+    sealed class Result {
+        object Success : Result()
+        data class InternalError(val error: Throwable) : Result()
    }
 }
--- a/app/src/main/java/eu/kanade/domain/category/interactor/InsertCategory.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/InsertCategory.kt
@ -1,22 +0,0 @@
-package eu.kanade.domain.category.interactor
-
-import eu.kanade.domain.category.repository.CategoryRepository
-
-class InsertCategory(
-    private val categoryRepository: CategoryRepository,
-) {
-
-    suspend fun await(name: String, order: Long): Result {
-        return try {
-            categoryRepository.insert(name, order)
-            Result.Success
-        } catch (e: Exception) {
-            Result.Error(e)
-        }
-    }
-
-    sealed class Result {
-        object Success : Result()
-        data class Error(val error: Exception) : Result()
-    }
-}
--- a/app/src/main/java/eu/kanade/domain/category/interactor/RenameCategory.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/RenameCategory.kt
@ -0,0 +1,42 @@
+package eu.kanade.domain.category.interactor
+
+import eu.kanade.domain.category.model.Category
+import eu.kanade.domain.category.model.CategoryUpdate
+import eu.kanade.domain.category.model.anyWithName
+import eu.kanade.domain.category.repository.CategoryRepository
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext
+import eu.kanade.tachiyomi.util.system.logcat
+import logcat.LogPriority
+
+class RenameCategory(
+    private val categoryRepository: CategoryRepository,
+) {
+
+    suspend fun await(categoryId: Long, name: String) = withNonCancellableContext {
+        val categories = categoryRepository.getAll()
+        if (categories.anyWithName(name)) {
+            return@withNonCancellableContext Result.NameAlreadyExistsError
+        }
+
+        val update = CategoryUpdate(
+            id = categoryId,
+            name = name,
+        )
+
+        try {
+            categoryRepository.updatePartial(update)
+            Result.Success
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            Result.InternalError(e)
+        }
+    }
+
+    suspend fun await(category: Category, name: String) = await(category.id, name)
+
+    sealed class Result {
+        object Success : Result()
+        object NameAlreadyExistsError : Result()
+        data class InternalError(val error: Throwable) : Result()
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/category/interactor/ReorderCategory.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/ReorderCategory.kt
@ -0,0 +1,50 @@
+package eu.kanade.domain.category.interactor
+
+import eu.kanade.domain.category.model.Category
+import eu.kanade.domain.category.model.CategoryUpdate
+import eu.kanade.domain.category.repository.CategoryRepository
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext
+import eu.kanade.tachiyomi.util.system.logcat
+import logcat.LogPriority
+
+class ReorderCategory(
+    private val categoryRepository: CategoryRepository,
+) {
+
+    suspend fun await(categoryId: Long, newPosition: Int) = withNonCancellableContext {
+        val categories = categoryRepository.getAll().filterNot(Category::isSystemCategory)
+
+        val currentIndex = categories.indexOfFirst { it.id == categoryId }
+        if (currentIndex == newPosition) {
+            return@withNonCancellableContext Result.Unchanged
+        }
+
+        val reorderedCategories = categories.toMutableList()
+        val reorderedCategory = reorderedCategories.removeAt(currentIndex)
+        reorderedCategories.add(newPosition, reorderedCategory)
+
+        val updates = reorderedCategories.mapIndexed { index, category ->
+            CategoryUpdate(
+                id = category.id,
+                order = index.toLong(),
+            )
+        }
+
+        try {
+            categoryRepository.updatePartial(updates)
+            Result.Success
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            Result.InternalError(e)
+        }
+    }
+
+    suspend fun await(category: Category, newPosition: Long): Result =
+        await(category.id, newPosition.toInt())
+
+    sealed class Result {
+        object Success : Result()
+        object Unchanged : Result()
+        data class InternalError(val error: Throwable) : Result()
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/category/interactor/ResetCategoryFlags.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/ResetCategoryFlags.kt
@ -0,0 +1,17 @@
+package eu.kanade.domain.category.interactor
+
+import eu.kanade.domain.category.repository.CategoryRepository
+import eu.kanade.domain.library.model.plus
+import eu.kanade.domain.library.service.LibraryPreferences
+
+class ResetCategoryFlags(
+    private val preferences: LibraryPreferences,
+    private val categoryRepository: CategoryRepository,
+) {
+
+    suspend fun await() {
+        val display = preferences.libraryDisplayMode().get()
+        val sort = preferences.librarySortingMode().get()
+        categoryRepository.updateAllFlags(display + sort.type + sort.direction)
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/category/interactor/SetDisplayModeForCategory.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/SetDisplayModeForCategory.kt
@ -0,0 +1,34 @@
+package eu.kanade.domain.category.interactor
+
+import eu.kanade.domain.category.model.Category
+import eu.kanade.domain.category.model.CategoryUpdate
+import eu.kanade.domain.category.repository.CategoryRepository
+import eu.kanade.domain.library.model.LibraryDisplayMode
+import eu.kanade.domain.library.model.plus
+import eu.kanade.domain.library.service.LibraryPreferences
+
+class SetDisplayModeForCategory(
+    private val preferences: LibraryPreferences,
+    private val categoryRepository: CategoryRepository,
+) {
+
+    suspend fun await(categoryId: Long, display: LibraryDisplayMode) {
+        val category = categoryRepository.get(categoryId) ?: return
+        val flags = category.flags + display
+        if (preferences.categorizedDisplaySettings().get()) {
+            categoryRepository.updatePartial(
+                CategoryUpdate(
+                    id = category.id,
+                    flags = flags,
+                ),
+            )
+        } else {
+            preferences.libraryDisplayMode().set(display)
+            categoryRepository.updateAllFlags(flags)
+        }
+    }
+
+    suspend fun await(category: Category, display: LibraryDisplayMode) {
+        await(category.id, display)
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/category/interactor/SetSortModeForCategory.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/SetSortModeForCategory.kt
@ -0,0 +1,34 @@
+package eu.kanade.domain.category.interactor
+
+import eu.kanade.domain.category.model.Category
+import eu.kanade.domain.category.model.CategoryUpdate
+import eu.kanade.domain.category.repository.CategoryRepository
+import eu.kanade.domain.library.model.LibrarySort
+import eu.kanade.domain.library.model.plus
+import eu.kanade.domain.library.service.LibraryPreferences
+
+class SetSortModeForCategory(
+    private val preferences: LibraryPreferences,
+    private val categoryRepository: CategoryRepository,
+) {
+
+    suspend fun await(categoryId: Long, type: LibrarySort.Type, direction: LibrarySort.Direction) {
+        val category = categoryRepository.get(categoryId) ?: return
+        val flags = category.flags + type + direction
+        if (preferences.categorizedDisplaySettings().get()) {
+            categoryRepository.updatePartial(
+                CategoryUpdate(
+                    id = category.id,
+                    flags = flags,
+                ),
+            )
+        } else {
+            preferences.librarySortingMode().set(LibrarySort(type, direction))
+            categoryRepository.updateAllFlags(flags)
+        }
+    }
+
+    suspend fun await(category: Category, type: LibrarySort.Type, direction: LibrarySort.Direction) {
+        await(category.id, type, direction)
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/category/interactor/UpdateCategory.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/UpdateCategory.kt
@ -2,14 +2,15 @@ package eu.kanade.domain.category.interactor

 import eu.kanade.domain.category.model.CategoryUpdate
 import eu.kanade.domain.category.repository.CategoryRepository
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext

 class UpdateCategory(
    private val categoryRepository: CategoryRepository,
 ) {

-    suspend fun await(payload: CategoryUpdate): Result {
-        return try {
-            categoryRepository.update(payload)
+    suspend fun await(payload: CategoryUpdate): Result = withNonCancellableContext {
+        try {
+            categoryRepository.updatePartial(payload)
            Result.Success
        } catch (e: Exception) {
            Result.Error(e)
--- a/app/src/main/java/eu/kanade/domain/category/model/Category.kt
+++ b/app/src/main/java/eu/kanade/domain/category/model/Category.kt
@ -1,13 +1,6 @@
 package eu.kanade.domain.category.model

-import android.content.Context
-import eu.kanade.tachiyomi.R
-import eu.kanade.tachiyomi.data.database.models.CategoryImpl
-import eu.kanade.tachiyomi.ui.library.setting.DisplayModeSetting
-import eu.kanade.tachiyomi.ui.library.setting.SortDirectionSetting
-import eu.kanade.tachiyomi.ui.library.setting.SortModeSetting
 import java.io.Serializable
-import eu.kanade.tachiyomi.data.database.models.Category as DbCategory

 data class Category(
    val id: Long,
@ -16,30 +9,14 @@ data class Category(
    val flags: Long,
 ) : Serializable {

-    val displayMode: Long
-        get() = flags and DisplayModeSetting.MASK
-
-    val sortMode: Long
-        get() = flags and SortModeSetting.MASK
-
-    val sortDirection: Long
-        get() = flags and SortDirectionSetting.MASK
+    val isSystemCategory: Boolean = id == UNCATEGORIZED_ID

    companion object {
-        val default = { context: Context ->
-            Category(
-                id = 0,
-                name = context.getString(R.string.label_default),
-                order = 0,
-                flags = 0,
-            )
-        }
+
+        const val UNCATEGORIZED_ID = 0L
    }
 }

-fun Category.toDbCategory(): DbCategory = CategoryImpl().also {
-    it.name = name
-    it.id = id.toInt()
-    it.order = order.toInt()
-    it.flags = flags.toInt()
+internal fun List<Category>.anyWithName(name: String): Boolean {
+    return any { name == it.name }
 }
--- a/app/src/main/java/eu/kanade/domain/category/repository/CategoryRepository.kt
+++ b/app/src/main/java/eu/kanade/domain/category/repository/CategoryRepository.kt
@ -6,6 +6,8 @@ import kotlinx.coroutines.flow.Flow

 interface CategoryRepository {

+    suspend fun get(id: Long): Category?
+
    suspend fun getAll(): List<Category>

    fun getAllAsFlow(): Flow<List<Category>>
@ -14,15 +16,13 @@ interface CategoryRepository {

    fun getCategoriesByMangaIdAsFlow(mangaId: Long): Flow<List<Category>>

-    @Throws(DuplicateNameException::class)
-    suspend fun insert(name: String, order: Long)
+    suspend fun insert(category: Category)

-    @Throws(DuplicateNameException::class)
-    suspend fun update(payload: CategoryUpdate)
+    suspend fun updatePartial(update: CategoryUpdate)
+
+    suspend fun updatePartial(updates: List<CategoryUpdate>)
+
+    suspend fun updateAllFlags(flags: Long?)

    suspend fun delete(categoryId: Long)
-
-    suspend fun checkDuplicateName(name: String): Boolean
 }
-
-class DuplicateNameException(name: String) : Exception("There's a category which is named \"$name\" already")
--- a/app/src/main/java/eu/kanade/domain/chapter/interactor/SetDefaultChapterSettings.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/interactor/SetDefaultChapterSettings.kt
@ -0,0 +1,36 @@
+package eu.kanade.domain.chapter.interactor
+
+import eu.kanade.domain.library.service.LibraryPreferences
+import eu.kanade.domain.manga.interactor.GetFavorites
+import eu.kanade.domain.manga.interactor.SetMangaChapterFlags
+import eu.kanade.domain.manga.model.Manga
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext
+
+class SetMangaDefaultChapterFlags(
+    private val libraryPreferences: LibraryPreferences,
+    private val setMangaChapterFlags: SetMangaChapterFlags,
+    private val getFavorites: GetFavorites,
+) {
+
+    suspend fun await(manga: Manga) {
+        withNonCancellableContext {
+            with(libraryPreferences) {
+                setMangaChapterFlags.awaitSetAllFlags(
+                    mangaId = manga.id,
+                    unreadFilter = filterChapterByRead().get(),
+                    downloadedFilter = filterChapterByDownloaded().get(),
+                    bookmarkedFilter = filterChapterByBookmarked().get(),
+                    sortingMode = sortChapterBySourceOrNumber().get(),
+                    sortingDirection = sortChapterByAscendingOrDescending().get(),
+                    displayMode = displayChapterByNameOrNumber().get(),
+                )
+            }
+        }
+    }
+
+    suspend fun awaitAll() {
+        withNonCancellableContext {
+            getFavorites.await().forEach { await(it) }
+        }
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/chapter/interactor/SetReadStatus.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/interactor/SetReadStatus.kt
@ -4,16 +4,15 @@ import eu.kanade.domain.chapter.model.Chapter
 import eu.kanade.domain.chapter.model.ChapterUpdate
 import eu.kanade.domain.chapter.repository.ChapterRepository
 import eu.kanade.domain.download.interactor.DeleteDownload
+import eu.kanade.domain.download.service.DownloadPreferences
 import eu.kanade.domain.manga.model.Manga
 import eu.kanade.domain.manga.repository.MangaRepository
-import eu.kanade.tachiyomi.data.preference.PreferencesHelper
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext
 import eu.kanade.tachiyomi.util.system.logcat
-import kotlinx.coroutines.NonCancellable
-import kotlinx.coroutines.withContext
 import logcat.LogPriority

 class SetReadStatus(
-    private val preferences: PreferencesHelper,
+    private val downloadPreferences: DownloadPreferences,
    private val deleteDownload: DeleteDownload,
    private val mangaRepository: MangaRepository,
    private val chapterRepository: ChapterRepository,
@ -27,38 +26,33 @@ class SetReadStatus(
        )
    }

-    suspend fun await(read: Boolean, vararg values: Chapter): Result = withContext(NonCancellable) f@{
-        val chapters = values.filterNot { it.read == read }
-
-        if (chapters.isEmpty()) {
-            return@f Result.NoChapters
+    suspend fun await(read: Boolean, vararg chapters: Chapter): Result = withNonCancellableContext {
+        val chaptersToUpdate = chapters.filter {
+            when (read) {
+                true -> !it.read
+                false -> it.read || it.lastPageRead > 0
            }
-
-        val manga = chapters.fold(mutableSetOf<Manga>()) { acc, chapter ->
-            if (acc.all { it.id != chapter.mangaId }) {
-                acc += mangaRepository.getMangaById(chapter.mangaId)
        }
-            acc
+        if (chaptersToUpdate.isEmpty()) {
+            return@withNonCancellableContext Result.NoChapters
        }

        try {
            chapterRepository.updateAll(
-                chapters.map { chapter ->
-                    mapper(chapter, read)
-                },
+                chaptersToUpdate.map { mapper(it, read) },
            )
        } catch (e: Exception) {
            logcat(LogPriority.ERROR, e)
-            return@f Result.InternalError(e)
+            return@withNonCancellableContext Result.InternalError(e)
        }

-        if (read && preferences.removeAfterMarkedAsRead()) {
-            manga.forEach { manga ->
+        if (read && downloadPreferences.removeAfterMarkedAsRead().get()) {
+            chaptersToUpdate
+                .groupBy { it.mangaId }
+                .forEach { (mangaId, chapters) ->
                    deleteDownload.awaitAll(
-                    manga = manga,
-                    values = chapters
-                        .filter { manga.id == it.mangaId }
-                        .toTypedArray(),
+                        manga = mangaRepository.getMangaById(mangaId),
+                        chapters = chapters.toTypedArray(),
                    )
                }
        }
@ -66,10 +60,10 @@ class SetReadStatus(
        Result.Success
    }

-    suspend fun await(mangaId: Long, read: Boolean): Result = withContext(NonCancellable) f@{
-        return@f await(
+    suspend fun await(mangaId: Long, read: Boolean): Result = withNonCancellableContext {
+        await(
            read = read,
-            values = chapterRepository
+            chapters = chapterRepository
                .getChapterByMangaId(mangaId)
                .toTypedArray(),
        )
--- a/app/src/main/java/eu/kanade/domain/chapter/interactor/SyncChaptersWithSource.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/interactor/SyncChaptersWithSource.kt
@ -1,5 +1,6 @@
 package eu.kanade.domain.chapter.interactor

+import eu.kanade.data.chapter.CleanupChapterName
 import eu.kanade.data.chapter.NoChaptersException
 import eu.kanade.domain.chapter.model.Chapter
 import eu.kanade.domain.chapter.model.toChapterUpdate
@ -8,8 +9,9 @@ import eu.kanade.domain.chapter.repository.ChapterRepository
 import eu.kanade.domain.manga.interactor.UpdateManga
 import eu.kanade.domain.manga.model.Manga
 import eu.kanade.tachiyomi.data.download.DownloadManager
-import eu.kanade.tachiyomi.source.LocalSource
+import eu.kanade.tachiyomi.data.download.DownloadProvider
 import eu.kanade.tachiyomi.source.Source
+import eu.kanade.tachiyomi.source.isLocal
 import eu.kanade.tachiyomi.source.model.SChapter
 import eu.kanade.tachiyomi.source.online.HttpSource
 import eu.kanade.tachiyomi.util.chapter.ChapterRecognition
@ -21,6 +23,7 @@ import java.util.TreeSet

 class SyncChaptersWithSource(
    private val downloadManager: DownloadManager = Injekt.get(),
+    private val downloadProvider: DownloadProvider = Injekt.get(),
    private val chapterRepository: ChapterRepository = Injekt.get(),
    private val shouldUpdateDbChapter: ShouldUpdateDbChapter = Injekt.get(),
    private val updateManga: UpdateManga = Injekt.get(),
@ -28,12 +31,20 @@ class SyncChaptersWithSource(
    private val getChapterByMangaId: GetChapterByMangaId = Injekt.get(),
 ) {

+    /**
+     * Method to synchronize db chapters with source ones
+     *
+     * @param rawSourceChapters the chapters from the source.
+     * @param manga the manga the chapters belong to.
+     * @param source the source the manga belongs to.
+     * @return Newly added chapters
+     */
    suspend fun await(
        rawSourceChapters: List<SChapter>,
        manga: Manga,
        source: Source,
-    ): Pair<List<Chapter>, List<Chapter>> {
-        if (rawSourceChapters.isEmpty() && source.id != LocalSource.ID) {
+    ): List<Chapter> {
+        if (rawSourceChapters.isEmpty() && !source.isLocal()) {
            throw NoChaptersException()
        }

@ -42,6 +53,7 @@ class SyncChaptersWithSource(
            .mapIndexed { i, sChapter ->
                Chapter.create()
                    .copyFromSChapter(sChapter)
+                    .copy(name = CleanupChapterName.await(sChapter.name, manga.title))
                    .copy(mangaId = manga.id, sourceOrder = i.toLong())
            }

@ -95,7 +107,10 @@ class SyncChaptersWithSource(
                toAdd.add(toAddChapter)
            } else {
                if (shouldUpdateDbChapter.await(dbChapter, chapter)) {
-                    if (dbChapter.name != chapter.name && downloadManager.isChapterDownloaded(dbChapter.name, dbChapter.scanlator, manga.title, manga.source)) {
+                    val shouldRenameChapter = downloadProvider.isChapterDirNameChanged(dbChapter, chapter) &&
+                        downloadManager.isChapterDownloaded(dbChapter.name, dbChapter.scanlator, manga.title, manga.source)
+
+                    if (shouldRenameChapter) {
                        downloadManager.renameChapter(source, manga, dbChapter.toDbChapter(), chapter.toDbChapter())
                    }
                    var toChangeChapter = dbChapter.copy(
@ -114,18 +129,18 @@ class SyncChaptersWithSource(

        // Return if there's nothing to add, delete or change, avoiding unnecessary db transactions.
        if (toAdd.isEmpty() && toDelete.isEmpty() && toChange.isEmpty()) {
-            return Pair(emptyList(), emptyList())
+            return emptyList()
        }

        val reAdded = mutableListOf<Chapter>()

        val deletedChapterNumbers = TreeSet<Float>()
        val deletedReadChapterNumbers = TreeSet<Float>()
+        val deletedBookmarkedChapterNumbers = TreeSet<Float>()

        toDelete.forEach { chapter ->
-            if (chapter.read) {
-                deletedReadChapterNumbers.add(chapter.chapterNumber)
-            }
+            if (chapter.read) deletedReadChapterNumbers.add(chapter.chapterNumber)
+            if (chapter.bookmark) deletedBookmarkedChapterNumbers.add(chapter.chapterNumber)
            deletedChapterNumbers.add(chapter.chapterNumber)
        }

@ -134,20 +149,19 @@ class SyncChaptersWithSource(

        // Date fetch is set in such a way that the upper ones will have bigger value than the lower ones
        // Sources MUST return the chapters from most to less recent, which is common.
-
        var itemCount = toAdd.size
        var updatedToAdd = toAdd.map { toAddItem ->
            var chapter = toAddItem.copy(dateFetch = rightNow + itemCount--)

-            if (chapter.isRecognizedNumber.not() && chapter.chapterNumber !in deletedChapterNumbers) return@map chapter
+            if (chapter.isRecognizedNumber.not() || chapter.chapterNumber !in deletedChapterNumbers) return@map chapter

-            if (chapter.chapterNumber in deletedReadChapterNumbers) {
-                chapter = chapter.copy(read = true)
-            }
+            chapter = chapter.copy(
+                read = chapter.chapterNumber in deletedReadChapterNumbers,
+                bookmark = chapter.chapterNumber in deletedBookmarkedChapterNumbers,
+            )

            // Try to to use the fetch date of the original entry to not pollute 'Updates' tab
-            val oldDateFetch = deletedChapterNumberDateFetchMap[chapter.chapterNumber]
-            oldDateFetch?.let {
+            deletedChapterNumberDateFetchMap[chapter.chapterNumber]?.let {
                chapter = chapter.copy(dateFetch = it)
            }

@ -174,7 +188,8 @@ class SyncChaptersWithSource(
        // Note that last_update actually represents last time the chapter list changed at all
        updateManga.awaitUpdateLastUpdate(manga.id)

-        @Suppress("ConvertArgumentToSet") // See tachiyomiorg/tachiyomi#6372.
-        return Pair(updatedToAdd.subtract(reAdded).toList(), toDelete.subtract(reAdded).toList())
+        val reAddedUrls = reAdded.map { it.url }.toHashSet()
+
+        return updatedToAdd.filterNot { it.url in reAddedUrls }
    }
 }
--- a/app/src/main/java/eu/kanade/domain/chapter/model/Chapter.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/model/Chapter.kt
@ -37,7 +37,7 @@ data class Chapter(
            url = sChapter.url,
            dateUpload = sChapter.date_upload,
            chapterNumber = sChapter.chapter_number,
-            scanlator = sChapter.scanlator,
+            scanlator = sChapter.scanlator?.ifBlank { null },
        )
    }

--- a/app/src/main/java/eu/kanade/domain/chapter/repository/ChapterRepository.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/repository/ChapterRepository.kt
@ -16,6 +16,8 @@ interface ChapterRepository {

    suspend fun getChapterByMangaId(mangaId: Long): List<Chapter>

+    suspend fun getBookmarkedChaptersByMangaId(mangaId: Long): List<Chapter>
+
    suspend fun getChapterById(id: Long): Chapter?

    suspend fun getChapterByMangaIdAsFlow(mangaId: Long): Flow<List<Chapter>>
--- a/app/src/main/java/eu/kanade/domain/download/interactor/DeleteDownload.kt
+++ b/app/src/main/java/eu/kanade/domain/download/interactor/DeleteDownload.kt
@ -5,17 +5,16 @@ import eu.kanade.domain.chapter.model.toDbChapter
 import eu.kanade.domain.manga.model.Manga
 import eu.kanade.tachiyomi.data.download.DownloadManager
 import eu.kanade.tachiyomi.source.SourceManager
-import kotlinx.coroutines.NonCancellable
-import kotlinx.coroutines.withContext
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext

 class DeleteDownload(
    private val sourceManager: SourceManager,
    private val downloadManager: DownloadManager,
 ) {

-    suspend fun awaitAll(manga: Manga, vararg values: Chapter) = withContext(NonCancellable) {
+    suspend fun awaitAll(manga: Manga, vararg chapters: Chapter) = withNonCancellableContext {
        sourceManager.get(manga.source)?.let { source ->
-            downloadManager.deleteChapters(values.map { it.toDbChapter() }, manga, source)
+            downloadManager.deleteChapters(chapters.map { it.toDbChapter() }, manga, source)
        }
    }
 }
--- a/app/src/main/java/eu/kanade/domain/download/service/DownloadPreferences.kt
+++ b/app/src/main/java/eu/kanade/domain/download/service/DownloadPreferences.kt
@ -0,0 +1,34 @@
+package eu.kanade.domain.download.service
+
+import eu.kanade.tachiyomi.core.preference.PreferenceStore
+import eu.kanade.tachiyomi.core.provider.FolderProvider
+
+class DownloadPreferences(
+    private val folderProvider: FolderProvider,
+    private val preferenceStore: PreferenceStore,
+) {
+
+    fun downloadsDirectory() = preferenceStore.getString("download_directory", folderProvider.path())
+
+    fun downloadOnlyOverWifi() = preferenceStore.getBoolean("pref_download_only_over_wifi_key", true)
+
+    fun saveChaptersAsCBZ() = preferenceStore.getBoolean("save_chapter_as_cbz", true)
+
+    fun splitTallImages() = preferenceStore.getBoolean("split_tall_images", false)
+
+    fun autoDownloadWhileReading() = preferenceStore.getInt("auto_download_while_reading", 0)
+
+    fun removeAfterReadSlots() = preferenceStore.getInt("remove_after_read_slots", -1)
+
+    fun removeAfterMarkedAsRead() = preferenceStore.getBoolean("pref_remove_after_marked_as_read_key", false)
+
+    fun removeBookmarkedChapters() = preferenceStore.getBoolean("pref_remove_bookmarked", false)
+
+    fun removeExcludeCategories() = preferenceStore.getStringSet("remove_exclude_categories", emptySet())
+
+    fun downloadNewChapters() = preferenceStore.getBoolean("download_new", false)
+
+    fun downloadNewChapterCategories() = preferenceStore.getStringSet("download_new_categories", emptySet())
+
+    fun downloadNewChapterCategoriesExclude() = preferenceStore.getStringSet("download_new_categories_exclude", emptySet())
+}
--- a/app/src/main/java/eu/kanade/domain/extension/interactor/GetExtensionLanguages.kt
+++ b/app/src/main/java/eu/kanade/domain/extension/interactor/GetExtensionLanguages.kt
@ -1,23 +1,28 @@
 package eu.kanade.domain.extension.interactor

-import eu.kanade.core.util.asFlow
-import eu.kanade.tachiyomi.data.preference.PreferencesHelper
+import eu.kanade.domain.source.service.SourcePreferences
 import eu.kanade.tachiyomi.extension.ExtensionManager
 import eu.kanade.tachiyomi.util.system.LocaleHelper
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine

 class GetExtensionLanguages(
-    private val preferences: PreferencesHelper,
+    private val preferences: SourcePreferences,
    private val extensionManager: ExtensionManager,
 ) {
    fun subscribe(): Flow<List<String>> {
        return combine(
-            preferences.enabledLanguages().asFlow(),
-            extensionManager.getAvailableExtensionsObservable().asFlow(),
+            preferences.enabledLanguages().changes(),
+            extensionManager.availableExtensionsFlow,
        ) { enabledLanguage, availableExtensions ->
            availableExtensions
-                .map { it.lang }
+                .flatMap { ext ->
+                    if (ext.sources.isEmpty()) {
+                        listOf(ext.lang)
+                    } else {
+                        ext.sources.map { it.lang }
+                    }
+                }
                .distinct()
                .sortedWith(
                    compareBy(
--- a/app/src/main/java/eu/kanade/domain/extension/interactor/GetExtensionSources.kt
+++ b/app/src/main/java/eu/kanade/domain/extension/interactor/GetExtensionSources.kt
@ -1,6 +1,6 @@
 package eu.kanade.domain.extension.interactor

-import eu.kanade.tachiyomi.data.preference.PreferencesHelper
+import eu.kanade.domain.source.service.SourcePreferences
 import eu.kanade.tachiyomi.extension.model.Extension
 import eu.kanade.tachiyomi.source.Source
 import eu.kanade.tachiyomi.ui.browse.extension.details.ExtensionSourceItem
@ -8,7 +8,7 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map

 class GetExtensionSources(
-    private val preferences: PreferencesHelper,
+    private val preferences: SourcePreferences,
 ) {

    fun subscribe(extension: Extension.Installed): Flow<List<ExtensionSourceItem>> {
@ -16,7 +16,7 @@ class GetExtensionSources(
        val isMultiLangSingleSource =
            isMultiSource && extension.sources.map { it.name }.distinct().size == 1

-        return preferences.disabledSources().asFlow().map { disabledSources ->
+        return preferences.disabledSources().changes().map { disabledSources ->
            fun Source.isEnabled() = id.toString() !in disabledSources

            extension.sources
--- a/app/src/main/java/eu/kanade/domain/extension/interactor/GetExtensionUpdates.kt
+++ b/app/src/main/java/eu/kanade/domain/extension/interactor/GetExtensionUpdates.kt
@ -1,25 +0,0 @@
-package eu.kanade.domain.extension.interactor
-
-import eu.kanade.core.util.asFlow
-import eu.kanade.tachiyomi.data.preference.PreferencesHelper
-import eu.kanade.tachiyomi.extension.ExtensionManager
-import eu.kanade.tachiyomi.extension.model.Extension
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.map
-
-class GetExtensionUpdates(
-    private val preferences: PreferencesHelper,
-    private val extensionManager: ExtensionManager,
-) {
-
-    fun subscribe(): Flow<List<Extension.Installed>> {
-        val showNsfwSources = preferences.showNsfwSource().get()
-
-        return extensionManager.getInstalledExtensionsObservable().asFlow()
-            .map { installed ->
-                installed
-                    .filter { it.hasUpdate && (showNsfwSources || it.isNsfw.not()) }
-                    .sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.name })
-            }
-    }
-}
--- a/app/src/main/java/eu/kanade/domain/extension/interactor/GetExtensions.kt
+++ b/app/src/main/java/eu/kanade/domain/extension/interactor/GetExtensions.kt
@ -1,48 +0,0 @@
-package eu.kanade.domain.extension.interactor
-
-import eu.kanade.core.util.asFlow
-import eu.kanade.tachiyomi.data.preference.PreferencesHelper
-import eu.kanade.tachiyomi.extension.ExtensionManager
-import eu.kanade.tachiyomi.extension.model.Extension
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.combine
-
-typealias ExtensionSegregation = Triple<List<Extension.Installed>, List<Extension.Untrusted>, List<Extension.Available>>
-
-class GetExtensions(
-    private val preferences: PreferencesHelper,
-    private val extensionManager: ExtensionManager,
-) {
-
-    fun subscribe(): Flow<ExtensionSegregation> {
-        val showNsfwSources = preferences.showNsfwSource().get()
-
-        return combine(
-            preferences.enabledLanguages().asFlow(),
-            extensionManager.getInstalledExtensionsObservable().asFlow(),
-            extensionManager.getUntrustedExtensionsObservable().asFlow(),
-            extensionManager.getAvailableExtensionsObservable().asFlow(),
-        ) { _activeLanguages, _installed, _untrusted, _available ->
-
-            val installed = _installed
-                .filter { it.hasUpdate.not() && (showNsfwSources || it.isNsfw.not()) }
-                .sortedWith(
-                    compareBy<Extension.Installed> { it.isObsolete.not() }
-                        .thenBy(String.CASE_INSENSITIVE_ORDER) { it.name },
-                )
-
-            val untrusted = _untrusted
-                .sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.name })
-
-            val available = _available
-                .filter { extension ->
-                    _installed.none { it.pkgName == extension.pkgName } &&
-                        _untrusted.none { it.pkgName == extension.pkgName } &&
-                        extension.lang in _activeLanguages &&
-                        (showNsfwSources || extension.isNsfw.not())
-                }
-
-            Triple(installed, untrusted, available)
-        }
-    }
-}
--- a/app/src/main/java/eu/kanade/domain/extension/interactor/GetExtensionsByType.kt
+++ b/app/src/main/java/eu/kanade/domain/extension/interactor/GetExtensionsByType.kt
@ -0,0 +1,60 @@
+package eu.kanade.domain.extension.interactor
+
+import eu.kanade.domain.extension.model.Extensions
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.extension.ExtensionManager
+import eu.kanade.tachiyomi.extension.model.Extension
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+
+class GetExtensionsByType(
+    private val preferences: SourcePreferences,
+    private val extensionManager: ExtensionManager,
+) {
+
+    fun subscribe(): Flow<Extensions> {
+        val showNsfwSources = preferences.showNsfwSource().get()
+
+        return combine(
+            preferences.enabledLanguages().changes(),
+            extensionManager.installedExtensionsFlow,
+            extensionManager.untrustedExtensionsFlow,
+            extensionManager.availableExtensionsFlow,
+        ) { _activeLanguages, _installed, _untrusted, _available ->
+            val (updates, installed) = _installed
+                .filter { (showNsfwSources || it.isNsfw.not()) }
+                .sortedWith(
+                    compareBy<Extension.Installed> { it.isObsolete.not() }
+                        .thenBy(String.CASE_INSENSITIVE_ORDER) { it.name },
+                )
+                .partition { it.hasUpdate }
+
+            val untrusted = _untrusted
+                .sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.name })
+
+            val available = _available
+                .filter { extension ->
+                    _installed.none { it.pkgName == extension.pkgName } &&
+                        _untrusted.none { it.pkgName == extension.pkgName } &&
+                        (showNsfwSources || extension.isNsfw.not())
+                }
+                .flatMap { ext ->
+                    if (ext.sources.isEmpty()) {
+                        return@flatMap if (ext.lang in _activeLanguages) listOf(ext) else emptyList()
+                    }
+                    ext.sources.filter { it.lang in _activeLanguages }
+                        .map {
+                            ext.copy(
+                                name = it.name,
+                                lang = it.lang,
+                                pkgName = "${ext.pkgName}-${it.id}",
+                                sources = listOf(it),
+                            )
+                        }
+                }
+                .sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.name })
+
+            Extensions(updates, installed, available, untrusted)
+        }
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/extension/model/Extensions.kt
+++ b/app/src/main/java/eu/kanade/domain/extension/model/Extensions.kt
@ -0,0 +1,10 @@
+package eu.kanade.domain.extension.model
+
+import eu.kanade.tachiyomi.extension.model.Extension
+
+data class Extensions(
+    val updates: List<Extension.Installed>,
+    val installed: List<Extension.Installed>,
+    val available: List<Extension.Available>,
+    val untrusted: List<Extension.Untrusted>,
+)
--- a/app/src/main/java/eu/kanade/domain/history/interactor/DeleteHistoryTable.kt
+++ b/app/src/main/java/eu/kanade/domain/history/interactor/DeleteHistoryTable.kt
@ -2,7 +2,7 @@ package eu.kanade.domain.history.interactor

 import eu.kanade.domain.history.repository.HistoryRepository

-class DeleteHistoryTable(
+class DeleteAllHistory(
    private val repository: HistoryRepository,
 ) {

--- a/app/src/main/java/eu/kanade/domain/history/interactor/GetHistory.kt
+++ b/app/src/main/java/eu/kanade/domain/history/interactor/GetHistory.kt
@ -1,8 +1,5 @@
 package eu.kanade.domain.history.interactor

-import androidx.paging.Pager
-import androidx.paging.PagingConfig
-import androidx.paging.PagingData
 import eu.kanade.domain.history.model.HistoryWithRelations
 import eu.kanade.domain.history.repository.HistoryRepository
 import kotlinx.coroutines.flow.Flow
@ -10,12 +7,7 @@ import kotlinx.coroutines.flow.Flow
 class GetHistory(
    private val repository: HistoryRepository,
 ) {
-
-    fun subscribe(query: String): Flow<PagingData<HistoryWithRelations>> {
-        return Pager(
-            PagingConfig(pageSize = 25),
-        ) {
-            repository.getHistory(query)
-        }.flow
+    fun subscribe(query: String): Flow<List<HistoryWithRelations>> {
+        return repository.getHistory(query)
    }
 }
--- a/app/src/main/java/eu/kanade/domain/history/interactor/GetNextChapter.kt
+++ b/app/src/main/java/eu/kanade/domain/history/interactor/GetNextChapter.kt
@ -1,18 +1,51 @@
 package eu.kanade.domain.history.interactor

+import eu.kanade.domain.chapter.interactor.GetChapter
+import eu.kanade.domain.chapter.interactor.GetChapterByMangaId
 import eu.kanade.domain.chapter.model.Chapter
 import eu.kanade.domain.history.repository.HistoryRepository
+import eu.kanade.domain.manga.interactor.GetManga
+import eu.kanade.domain.manga.model.Manga
+import eu.kanade.tachiyomi.util.chapter.getChapterSort

 class GetNextChapter(
-    private val repository: HistoryRepository,
+    private val getChapter: GetChapter,
+    private val getChapterByMangaId: GetChapterByMangaId,
+    private val getManga: GetManga,
+    private val historyRepository: HistoryRepository,
 ) {

-    suspend fun await(mangaId: Long, chapterId: Long): Chapter? {
-        return repository.getNextChapter(mangaId, chapterId)
+    suspend fun await(): Chapter? {
+        val history = historyRepository.getLastHistory() ?: return null
+        return await(history.mangaId, history.chapterId)
    }

-    suspend fun await(): Chapter? {
-        val history = repository.getLastHistory() ?: return null
-        return repository.getNextChapter(history.mangaId, history.chapterId)
+    suspend fun await(mangaId: Long, chapterId: Long): Chapter? {
+        val chapter = getChapter.await(chapterId) ?: return null
+        val manga = getManga.await(mangaId) ?: return null
+
+        if (!chapter.read) return chapter
+
+        val chapters = getChapterByMangaId.await(mangaId)
+            .sortedWith(getChapterSort(manga, sortDescending = false))
+
+        val currChapterIndex = chapters.indexOfFirst { chapter.id == it.id }
+        return when (manga.sorting) {
+            Manga.CHAPTER_SORTING_SOURCE -> chapters.getOrNull(currChapterIndex + 1)
+            Manga.CHAPTER_SORTING_NUMBER -> {
+                val chapterNumber = chapter.chapterNumber
+
+                ((currChapterIndex + 1) until chapters.size)
+                    .map { chapters[it] }
+                    .firstOrNull {
+                        it.chapterNumber > chapterNumber && it.chapterNumber <= chapterNumber + 1
+                    }
+            }
+            Manga.CHAPTER_SORTING_UPLOAD_DATE -> {
+                chapters.drop(currChapterIndex + 1)
+                    .firstOrNull { it.dateUpload >= chapter.dateUpload }
+            }
+            else -> throw NotImplementedError("Invalid chapter sorting method: ${manga.sorting}")
+        }
    }
 }
--- a/app/src/main/java/eu/kanade/domain/history/repository/HistoryRepository.kt
+++ b/app/src/main/java/eu/kanade/domain/history/repository/HistoryRepository.kt
@ -1,18 +1,15 @@
 package eu.kanade.domain.history.repository

-import androidx.paging.PagingSource
-import eu.kanade.domain.chapter.model.Chapter
 import eu.kanade.domain.history.model.HistoryUpdate
 import eu.kanade.domain.history.model.HistoryWithRelations
+import kotlinx.coroutines.flow.Flow

 interface HistoryRepository {

-    fun getHistory(query: String): PagingSource<Long, HistoryWithRelations>
+    fun getHistory(query: String): Flow<List<HistoryWithRelations>>

    suspend fun getLastHistory(): HistoryWithRelations?

-    suspend fun getNextChapter(mangaId: Long, chapterId: Long): Chapter?
-
    suspend fun resetHistory(historyId: Long)

    suspend fun resetHistoryByMangaId(mangaId: Long)
--- a/app/src/main/java/eu/kanade/domain/library/model/Flag.kt
+++ b/app/src/main/java/eu/kanade/domain/library/model/Flag.kt
@ -0,0 +1,35 @@
+package eu.kanade.domain.library.model
+
+interface Flag {
+    val flag: Long
+}
+
+interface Mask {
+    val mask: Long
+}
+
+interface FlagWithMask : Flag, Mask
+
+operator fun Long.contains(other: Flag): Boolean {
+    return if (other is Mask) {
+        other.flag == this and other.mask
+    } else {
+        other.flag == this
+    }
+}
+
+operator fun Long.plus(other: Flag): Long {
+    return if (other is Mask) {
+        this and other.mask.inv() or (other.flag and other.mask)
+    } else {
+        this or other.flag
+    }
+}
+
+operator fun Flag.plus(other: Flag): Long {
+    return if (other is Mask) {
+        this.flag and other.mask.inv() or (other.flag and other.mask)
+    } else {
+        this.flag or other.flag
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/library/model/LibraryDisplayMode.kt
+++ b/app/src/main/java/eu/kanade/domain/library/model/LibraryDisplayMode.kt
@ -0,0 +1,59 @@
+package eu.kanade.domain.library.model
+
+import eu.kanade.domain.category.model.Category
+
+sealed class LibraryDisplayMode(
+    override val flag: Long,
+) : FlagWithMask {
+
+    override val mask: Long = 0b00000011L
+
+    object CompactGrid : LibraryDisplayMode(0b00000000)
+    object ComfortableGrid : LibraryDisplayMode(0b00000001)
+    object List : LibraryDisplayMode(0b00000010)
+    object CoverOnlyGrid : LibraryDisplayMode(0b00000011)
+
+    object Serializer {
+        fun deserialize(serialized: String): LibraryDisplayMode {
+            return LibraryDisplayMode.deserialize(serialized)
+        }
+
+        fun serialize(value: LibraryDisplayMode): String {
+            return value.serialize()
+        }
+    }
+
+    companion object {
+        val values = setOf(CompactGrid, ComfortableGrid, List, CoverOnlyGrid)
+        val default = CompactGrid
+
+        fun valueOf(flag: Long?): LibraryDisplayMode {
+            if (flag == null) return default
+            return values
+                .find { mode -> mode.flag == flag and mode.mask }
+                ?: default
+        }
+
+        fun deserialize(serialized: String): LibraryDisplayMode {
+            return when (serialized) {
+                "COMFORTABLE_GRID" -> ComfortableGrid
+                "COMPACT_GRID" -> CompactGrid
+                "COVER_ONLY_GRID" -> CoverOnlyGrid
+                "LIST" -> List
+                else -> default
+            }
+        }
+    }
+
+    fun serialize(): String {
+        return when (this) {
+            ComfortableGrid -> "COMFORTABLE_GRID"
+            CompactGrid -> "COMPACT_GRID"
+            CoverOnlyGrid -> "COVER_ONLY_GRID"
+            List -> "LIST"
+        }
+    }
+}
+
+val Category.display: LibraryDisplayMode
+    get() = LibraryDisplayMode.valueOf(flags)
--- a/app/src/main/java/eu/kanade/domain/library/model/LibraryManga.kt
+++ b/app/src/main/java/eu/kanade/domain/library/model/LibraryManga.kt
@ -0,0 +1,24 @@
+package eu.kanade.domain.library.model
+
+import eu.kanade.domain.manga.model.Manga
+
+data class LibraryManga(
+    val manga: Manga,
+    val category: Long,
+    val totalChapters: Long,
+    val readCount: Long,
+    val bookmarkCount: Long,
+    val latestUpload: Long,
+    val chapterFetchedAt: Long,
+    val lastRead: Long,
+) {
+    val id: Long = manga.id
+
+    val unreadCount
+        get() = totalChapters - readCount
+
+    val hasBookmarks
+        get() = bookmarkCount > 0
+
+    val hasStarted = readCount > 0
+}
--- a/app/src/main/java/eu/kanade/domain/library/model/LibrarySort.kt
+++ b/app/src/main/java/eu/kanade/domain/library/model/LibrarySort.kt
@ -0,0 +1,121 @@
+package eu.kanade.domain.library.model
+
+import eu.kanade.domain.category.model.Category
+
+data class LibrarySort(
+    val type: Type,
+    val direction: Direction,
+) : FlagWithMask {
+
+    override val flag: Long
+        get() = type + direction
+
+    override val mask: Long
+        get() = type.mask or direction.mask
+
+    val isAscending: Boolean
+        get() = direction == Direction.Ascending
+
+    sealed class Type(
+        override val flag: Long,
+    ) : FlagWithMask {
+
+        override val mask: Long = 0b00111100L
+
+        object Alphabetical : Type(0b00000000)
+        object LastRead : Type(0b00000100)
+        object LastUpdate : Type(0b00001000)
+        object UnreadCount : Type(0b00001100)
+        object TotalChapters : Type(0b00010000)
+        object LatestChapter : Type(0b00010100)
+        object ChapterFetchDate : Type(0b00011000)
+        object DateAdded : Type(0b00011100)
+
+        companion object {
+
+            fun valueOf(flag: Long): Type {
+                return types.find { type -> type.flag == flag and type.mask } ?: default.type
+            }
+        }
+    }
+
+    sealed class Direction(
+        override val flag: Long,
+    ) : FlagWithMask {
+
+        override val mask: Long = 0b01000000L
+
+        object Ascending : Direction(0b01000000)
+        object Descending : Direction(0b00000000)
+
+        companion object {
+
+            fun valueOf(flag: Long): Direction {
+                return directions.find { direction -> direction.flag == flag and direction.mask } ?: default.direction
+            }
+        }
+    }
+
+    object Serializer {
+        fun deserialize(serialized: String): LibrarySort {
+            return LibrarySort.deserialize(serialized)
+        }
+
+        fun serialize(value: LibrarySort): String {
+            return value.serialize()
+        }
+    }
+
+    companion object {
+        val types = setOf(Type.Alphabetical, Type.LastRead, Type.LastUpdate, Type.UnreadCount, Type.TotalChapters, Type.LatestChapter, Type.ChapterFetchDate, Type.DateAdded)
+        val directions = setOf(Direction.Ascending, Direction.Descending)
+        val default = LibrarySort(Type.Alphabetical, Direction.Ascending)
+
+        fun valueOf(flag: Long): LibrarySort {
+            return LibrarySort(
+                Type.valueOf(flag),
+                Direction.valueOf(flag),
+            )
+        }
+
+        fun deserialize(serialized: String): LibrarySort {
+            if (serialized.isEmpty()) return default
+            return try {
+                val values = serialized.split(",")
+                val type = when (values[0]) {
+                    "ALPHABETICAL" -> Type.Alphabetical
+                    "LAST_READ" -> Type.LastRead
+                    "LAST_MANGA_UPDATE" -> Type.LastUpdate
+                    "UNREAD_COUNT" -> Type.UnreadCount
+                    "TOTAL_CHAPTERS" -> Type.TotalChapters
+                    "LATEST_CHAPTER" -> Type.LatestChapter
+                    "CHAPTER_FETCH_DATE" -> Type.ChapterFetchDate
+                    "DATE_ADDED" -> Type.DateAdded
+                    else -> Type.Alphabetical
+                }
+                val ascending = if (values[1] == "ASCENDING") Direction.Ascending else Direction.Descending
+                LibrarySort(type, ascending)
+            } catch (e: Exception) {
+                default
+            }
+        }
+    }
+
+    fun serialize(): String {
+        val type = when (type) {
+            Type.Alphabetical -> "ALPHABETICAL"
+            Type.LastRead -> "LAST_READ"
+            Type.LastUpdate -> "LAST_MANGA_UPDATE"
+            Type.UnreadCount -> "UNREAD_COUNT"
+            Type.TotalChapters -> "TOTAL_CHAPTERS"
+            Type.LatestChapter -> "LATEST_CHAPTER"
+            Type.ChapterFetchDate -> "CHAPTER_FETCH_DATE"
+            Type.DateAdded -> "DATE_ADDED"
+        }
+        val direction = if (direction == Direction.Ascending) "ASCENDING" else "DESCENDING"
+        return "$type,$direction"
+    }
+}
+
+val Category.sort: LibrarySort
+    get() = LibrarySort.valueOf(flags)
--- a/app/src/main/java/eu/kanade/domain/library/service/LibraryPreferences.kt
+++ b/app/src/main/java/eu/kanade/domain/library/service/LibraryPreferences.kt
@ -0,0 +1,111 @@
+package eu.kanade.domain.library.service
+
+import eu.kanade.domain.library.model.LibraryDisplayMode
+import eu.kanade.domain.library.model.LibrarySort
+import eu.kanade.domain.manga.model.Manga
+import eu.kanade.tachiyomi.core.preference.PreferenceStore
+import eu.kanade.tachiyomi.data.preference.DEVICE_ONLY_ON_WIFI
+import eu.kanade.tachiyomi.data.preference.MANGA_HAS_UNREAD
+import eu.kanade.tachiyomi.data.preference.MANGA_NON_COMPLETED
+import eu.kanade.tachiyomi.data.preference.MANGA_NON_READ
+import eu.kanade.tachiyomi.widget.ExtendedNavigationView
+
+class LibraryPreferences(
+    private val preferenceStore: PreferenceStore,
+) {
+
+    fun libraryDisplayMode() = preferenceStore.getObject("pref_display_mode_library", LibraryDisplayMode.default, LibraryDisplayMode.Serializer::serialize, LibraryDisplayMode.Serializer::deserialize)
+
+    fun librarySortingMode() = preferenceStore.getObject("library_sorting_mode", LibrarySort.default, LibrarySort.Serializer::serialize, LibrarySort.Serializer::deserialize)
+
+    fun portraitColumns() = preferenceStore.getInt("pref_library_columns_portrait_key", 0)
+
+    fun landscapeColumns() = preferenceStore.getInt("pref_library_columns_landscape_key", 0)
+
+    fun libraryUpdateInterval() = preferenceStore.getInt("pref_library_update_interval_key", 24)
+    fun libraryUpdateLastTimestamp() = preferenceStore.getLong("library_update_last_timestamp", 0L)
+
+    fun libraryUpdateDeviceRestriction() = preferenceStore.getStringSet("library_update_restriction", setOf(DEVICE_ONLY_ON_WIFI))
+    fun libraryUpdateMangaRestriction() = preferenceStore.getStringSet("library_update_manga_restriction", setOf(MANGA_HAS_UNREAD, MANGA_NON_COMPLETED, MANGA_NON_READ))
+
+    fun autoUpdateMetadata() = preferenceStore.getBoolean("auto_update_metadata", false)
+
+    fun autoUpdateTrackers() = preferenceStore.getBoolean("auto_update_trackers", false)
+
+    // region Filter
+
+    fun filterDownloaded() = preferenceStore.getInt("pref_filter_library_downloaded", ExtendedNavigationView.Item.TriStateGroup.State.IGNORE.value)
+
+    fun filterUnread() = preferenceStore.getInt("pref_filter_library_unread", ExtendedNavigationView.Item.TriStateGroup.State.IGNORE.value)
+
+    fun filterStarted() = preferenceStore.getInt("pref_filter_library_started", ExtendedNavigationView.Item.TriStateGroup.State.IGNORE.value)
+
+    fun filterBookmarked() = preferenceStore.getInt("pref_filter_library_bookmarked", ExtendedNavigationView.Item.TriStateGroup.State.IGNORE.value)
+
+    fun filterCompleted() = preferenceStore.getInt("pref_filter_library_completed", ExtendedNavigationView.Item.TriStateGroup.State.IGNORE.value)
+
+    fun filterTracking(name: Int) = preferenceStore.getInt("pref_filter_library_tracked_$name", ExtendedNavigationView.Item.TriStateGroup.State.IGNORE.value)
+
+    // endregion
+
+    // region Badges
+
+    fun downloadBadge() = preferenceStore.getBoolean("display_download_badge", false)
+
+    fun localBadge() = preferenceStore.getBoolean("display_local_badge", true)
+
+    fun unreadBadge() = preferenceStore.getBoolean("display_unread_badge", true)
+
+    fun languageBadge() = preferenceStore.getBoolean("display_language_badge", false)
+
+    fun showUpdatesNavBadge() = preferenceStore.getBoolean("library_update_show_tab_badge", false)
+    fun unreadUpdatesCount() = preferenceStore.getInt("library_unread_updates_count", 0)
+
+    // endregion
+
+    // region Category
+
+    fun defaultCategory() = preferenceStore.getInt("default_category", -1)
+
+    fun lastUsedCategory() = preferenceStore.getInt("last_used_category", 0)
+
+    fun categoryTabs() = preferenceStore.getBoolean("display_category_tabs", true)
+
+    fun categoryNumberOfItems() = preferenceStore.getBoolean("display_number_of_items", false)
+
+    fun categorizedDisplaySettings() = preferenceStore.getBoolean("categorized_display", false)
+
+    fun libraryUpdateCategories() = preferenceStore.getStringSet("library_update_categories", emptySet())
+
+    fun libraryUpdateCategoriesExclude() = preferenceStore.getStringSet("library_update_categories_exclude", emptySet())
+
+    // endregion
+
+    // region Chapter
+
+    fun filterChapterByRead() = preferenceStore.getLong("default_chapter_filter_by_read", Manga.SHOW_ALL)
+
+    fun filterChapterByDownloaded() = preferenceStore.getLong("default_chapter_filter_by_downloaded", Manga.SHOW_ALL)
+
+    fun filterChapterByBookmarked() = preferenceStore.getLong("default_chapter_filter_by_bookmarked", Manga.SHOW_ALL)
+
+    // and upload date
+    fun sortChapterBySourceOrNumber() = preferenceStore.getLong("default_chapter_sort_by_source_or_number", Manga.CHAPTER_SORTING_SOURCE)
+
+    fun displayChapterByNameOrNumber() = preferenceStore.getLong("default_chapter_display_by_name_or_number", Manga.CHAPTER_DISPLAY_NAME)
+
+    fun sortChapterByAscendingOrDescending() = preferenceStore.getLong("default_chapter_sort_by_ascending_or_descending", Manga.CHAPTER_SORT_DESC)
+
+    fun setChapterSettingsDefault(manga: Manga) {
+        filterChapterByRead().set(manga.unreadFilterRaw)
+        filterChapterByDownloaded().set(manga.downloadedFilterRaw)
+        filterChapterByBookmarked().set(manga.bookmarkedFilterRaw)
+        sortChapterBySourceOrNumber().set(manga.sorting)
+        displayChapterByNameOrNumber().set(manga.displayMode)
+        sortChapterByAscendingOrDescending().set(if (manga.sortDescending()) Manga.CHAPTER_SORT_DESC else Manga.CHAPTER_SORT_ASC)
+    }
+
+    fun autoClearChapterCache() = preferenceStore.getBoolean("auto_clear_chapter_cache", false)
+
+    // endregion
+}
--- a/app/src/main/java/eu/kanade/domain/manga/interactor/GetLibraryManga.kt
+++ b/app/src/main/java/eu/kanade/domain/manga/interactor/GetLibraryManga.kt
@ -1,7 +1,7 @@
 package eu.kanade.domain.manga.interactor

+import eu.kanade.domain.library.model.LibraryManga
 import eu.kanade.domain.manga.repository.MangaRepository
-import eu.kanade.tachiyomi.data.database.models.LibraryManga
 import kotlinx.coroutines.flow.Flow

 class GetLibraryManga(
--- a/app/src/main/java/eu/kanade/domain/manga/interactor/GetManga.kt
+++ b/app/src/main/java/eu/kanade/domain/manga/interactor/GetManga.kt
@ -23,7 +23,7 @@ class GetManga(
        return mangaRepository.getMangaByIdAsFlow(id)
    }

-    suspend fun await(url: String, sourceId: Long): Manga? {
-        return mangaRepository.getMangaByUrlAndSourceId(url, sourceId)
+    fun subscribe(url: String, sourceId: Long): Flow<Manga?> {
+        return mangaRepository.getMangaByUrlAndSourceIdAsFlow(url, sourceId)
    }
 }
--- a/app/src/main/java/eu/kanade/domain/manga/interactor/GetMangaWithChapters.kt
+++ b/app/src/main/java/eu/kanade/domain/manga/interactor/GetMangaWithChapters.kt
@ -24,4 +24,8 @@ class GetMangaWithChapters(
    suspend fun awaitManga(id: Long): Manga {
        return mangaRepository.getMangaById(id)
    }
+
+    suspend fun awaitChapters(id: Long): List<Chapter> {
+        return chapterRepository.getChapterByMangaId(id)
+    }
 }
--- a/app/src/main/java/eu/kanade/domain/manga/interactor/InsertManga.kt
+++ b/app/src/main/java/eu/kanade/domain/manga/interactor/InsertManga.kt
@ -1,13 +0,0 @@
-package eu.kanade.domain.manga.interactor
-
-import eu.kanade.domain.manga.model.Manga
-import eu.kanade.domain.manga.repository.MangaRepository
-
-class InsertManga(
-    private val mangaRepository: MangaRepository,
-) {
-
-    suspend fun await(manga: Manga): Long? {
-        return mangaRepository.insert(manga)
-    }
-}
--- a/app/src/main/java/eu/kanade/domain/manga/interactor/NetworkToLocalManga.kt
+++ b/app/src/main/java/eu/kanade/domain/manga/interactor/NetworkToLocalManga.kt
@ -0,0 +1,35 @@
+package eu.kanade.domain.manga.interactor
+
+import eu.kanade.domain.manga.model.Manga
+import eu.kanade.domain.manga.repository.MangaRepository
+
+class NetworkToLocalManga(
+    private val mangaRepository: MangaRepository,
+) {
+
+    suspend fun await(manga: Manga, sourceId: Long): Manga {
+        val localManga = getManga(manga.url, sourceId)
+        return when {
+            localManga == null -> {
+                val id = insertManga(manga.copy(source = sourceId))
+                manga.copy(id = id!!)
+            }
+            !localManga.favorite -> {
+                // if the manga isn't a favorite, set its display title from source
+                // if it later becomes a favorite, updated title will go to db
+                localManga.copy(title = manga.title)
+            }
+            else -> {
+                localManga
+            }
+        }
+    }
+
+    private suspend fun getManga(url: String, sourceId: Long): Manga? {
+        return mangaRepository.getMangaByUrlAndSourceId(url, sourceId)
+    }
+
+    private suspend fun insertManga(manga: Manga): Long? {
+        return mangaRepository.insert(manga)
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/manga/interactor/UpdateManga.kt
+++ b/app/src/main/java/eu/kanade/domain/manga/interactor/UpdateManga.kt
@ -7,7 +7,7 @@ import eu.kanade.domain.manga.model.isLocal
 import eu.kanade.domain.manga.model.toDbManga
 import eu.kanade.domain.manga.repository.MangaRepository
 import eu.kanade.tachiyomi.data.cache.CoverCache
-import tachiyomi.source.model.MangaInfo
+import eu.kanade.tachiyomi.source.model.SManga
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 import java.util.Date
@ -20,23 +20,30 @@ class UpdateManga(
        return mangaRepository.update(mangaUpdate)
    }

-    suspend fun awaitAll(values: List<MangaUpdate>): Boolean {
-        return mangaRepository.updateAll(values)
+    suspend fun awaitAll(mangaUpdates: List<MangaUpdate>): Boolean {
+        return mangaRepository.updateAll(mangaUpdates)
    }

    suspend fun awaitUpdateFromSource(
        localManga: Manga,
-        remoteManga: MangaInfo,
+        remoteManga: SManga,
        manualFetch: Boolean,
        coverCache: CoverCache = Injekt.get(),
    ): Boolean {
-        // if the manga isn't a favorite, set its title from source and update in db
-        val title = if (!localManga.favorite) remoteManga.title else null
+        val remoteTitle = try {
+            remoteManga.title
+        } catch (_: UninitializedPropertyAccessException) {
+            ""
+        }

-        // Never refresh covers if the url is empty to avoid "losing" existing covers
-        val updateCover = remoteManga.cover.isNotEmpty() && (manualFetch || localManga.thumbnailUrl != remoteManga.cover)
-        val coverLastModified = if (updateCover) {
+        // if the manga isn't a favorite, set its title from source and update in db
+        val title = if (remoteTitle.isEmpty() || localManga.favorite) null else remoteTitle
+
+        val coverLastModified =
            when {
+                // Never refresh covers if the url is empty to avoid "losing" existing covers
+                remoteManga.thumbnail_url.isNullOrEmpty() -> null
+                !manualFetch && localManga.thumbnailUrl == remoteManga.thumbnail_url -> null
                localManga.isLocal() -> Date().time
                localManga.hasCustomCover(coverCache) -> {
                    coverCache.deleteFromCache(localManga.toDbManga(), false)
@ -47,19 +54,21 @@ class UpdateManga(
                    Date().time
                }
            }
-        } else null
+
+        val thumbnailUrl = remoteManga.thumbnail_url?.takeIf { it.isNotEmpty() }

        return mangaRepository.update(
            MangaUpdate(
                id = localManga.id,
-                title = title?.takeIf { it.isNotEmpty() },
+                title = title,
                coverLastModified = coverLastModified,
                author = remoteManga.author,
                artist = remoteManga.artist,
                description = remoteManga.description,
-                genre = remoteManga.genres,
-                thumbnailUrl = remoteManga.cover.takeIf { it.isNotEmpty() },
+                genre = remoteManga.getGenres(),
+                thumbnailUrl = thumbnailUrl,
                status = remoteManga.status.toLong(),
+                updateStrategy = remoteManga.update_strategy,
                initialized = true,
            ),
        )
--- a/app/src/main/java/eu/kanade/domain/manga/model/ComicInfo.kt
+++ b/app/src/main/java/eu/kanade/domain/manga/model/ComicInfo.kt
@ -0,0 +1,60 @@
+package eu.kanade.domain.manga.model
+
+import kotlinx.serialization.Serializable
+import nl.adaptivity.xmlutil.serialization.XmlSerialName
+import nl.adaptivity.xmlutil.serialization.XmlValue
+
+@Serializable
+@XmlSerialName("ComicInfo", "", "")
+data class ComicInfo(
+    val series: ComicInfoSeries?,
+    val summary: ComicInfoSummary?,
+    val writer: ComicInfoWriter?,
+    val penciller: ComicInfoPenciller?,
+    val inker: ComicInfoInker?,
+    val colorist: ComicInfoColorist?,
+    val letterer: ComicInfoLetterer?,
+    val coverArtist: ComicInfoCoverArtist?,
+    val genre: ComicInfoGenre?,
+    val tags: ComicInfoTags?,
+)
+
+@Serializable
+@XmlSerialName("Series", "", "")
+data class ComicInfoSeries(@XmlValue(true) val value: String = "")
+
+@Serializable
+@XmlSerialName("Summary", "", "")
+data class ComicInfoSummary(@XmlValue(true) val value: String = "")
+
+@Serializable
+@XmlSerialName("Writer", "", "")
+data class ComicInfoWriter(@XmlValue(true) val value: String = "")
+
+@Serializable
+@XmlSerialName("Penciller", "", "")
+data class ComicInfoPenciller(@XmlValue(true) val value: String = "")
+
+@Serializable
+@XmlSerialName("Inker", "", "")
+data class ComicInfoInker(@XmlValue(true) val value: String = "")
+
+@Serializable
+@XmlSerialName("Colorist", "", "")
+data class ComicInfoColorist(@XmlValue(true) val value: String = "")
+
+@Serializable
+@XmlSerialName("Letterer", "", "")
+data class ComicInfoLetterer(@XmlValue(true) val value: String = "")
+
+@Serializable
+@XmlSerialName("CoverArtist", "", "")
+data class ComicInfoCoverArtist(@XmlValue(true) val value: String = "")
+
+@Serializable
+@XmlSerialName("Genre", "", "")
+data class ComicInfoGenre(@XmlValue(true) val value: String = "")
+
+@Serializable
+@XmlSerialName("Tags", "", "")
+data class ComicInfoTags(@XmlValue(true) val value: String = "")
--- a/app/src/main/java/eu/kanade/domain/manga/model/Manga.kt
+++ b/app/src/main/java/eu/kanade/domain/manga/model/Manga.kt
@ -1,13 +1,13 @@
 package eu.kanade.domain.manga.model

 import eu.kanade.data.listOfStringsAdapter
+import eu.kanade.domain.base.BasePreferences
 import eu.kanade.tachiyomi.data.cache.CoverCache
 import eu.kanade.tachiyomi.data.database.models.MangaImpl
-import eu.kanade.tachiyomi.data.preference.PreferencesHelper
 import eu.kanade.tachiyomi.source.LocalSource
 import eu.kanade.tachiyomi.source.model.SManga
+import eu.kanade.tachiyomi.source.model.UpdateStrategy
 import eu.kanade.tachiyomi.widget.ExtendedNavigationView
-import tachiyomi.source.model.MangaInfo
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 import java.io.Serializable
@ -30,6 +30,7 @@ data class Manga(
    val genre: List<String>?,
    val status: Long,
    val thumbnailUrl: String?,
+    val updateStrategy: UpdateStrategy,
    val initialized: Boolean,
 ) : Serializable {

@ -79,7 +80,7 @@ data class Manga(
    }

    fun forceDownloaded(): Boolean {
-        return favorite && Injekt.get<PreferencesHelper>().downloadedOnly().get()
+        return favorite && Injekt.get<BasePreferences>().downloadedOnly().get()
    }

    fun sortDescending(): Boolean {
@ -98,6 +99,28 @@ data class Manga(
        it.initialized = initialized
    }

+    fun copyFrom(other: SManga): Manga {
+        val author = other.author ?: author
+        val artist = other.artist ?: artist
+        val description = other.description ?: description
+        val genres = if (other.genre != null) {
+            other.getGenres()
+        } else {
+            genre
+        }
+        val thumbnailUrl = other.thumbnail_url ?: thumbnailUrl
+        return this.copy(
+            author = author,
+            artist = artist,
+            description = description,
+            genre = genres,
+            thumbnailUrl = thumbnailUrl,
+            status = other.status.toLong(),
+            updateStrategy = other.update_strategy,
+            initialized = other.initialized && initialized,
+        )
+    }
+
    companion object {
        // Generic filter that does not filter anything
        const val SHOW_ALL = 0x00000000L
@ -133,17 +156,18 @@ data class Manga(
            title = "",
            source = -1L,
            favorite = false,
-            lastUpdate = -1L,
-            dateAdded = -1L,
-            viewerFlags = -1L,
-            chapterFlags = -1L,
-            coverLastModified = -1L,
+            lastUpdate = 0L,
+            dateAdded = 0L,
+            viewerFlags = 0L,
+            chapterFlags = 0L,
+            coverLastModified = 0L,
            artist = null,
            author = null,
            description = null,
            genre = null,
            status = 0L,
            thumbnailUrl = null,
+            updateStrategy = UpdateStrategy.ALWAYS_UPDATE,
            initialized = false,
        )
    }
@ -181,20 +205,10 @@ fun Manga.toDbManga(): DbManga = MangaImpl().also {
    it.genre = genre?.let(listOfStringsAdapter::encode)
    it.status = status.toInt()
    it.thumbnail_url = thumbnailUrl
+    it.update_strategy = updateStrategy
    it.initialized = initialized
 }

-fun Manga.toMangaInfo(): MangaInfo = MangaInfo(
-    artist = artist ?: "",
-    author = author ?: "",
-    cover = thumbnailUrl ?: "",
-    description = description ?: "",
-    genres = genre ?: emptyList(),
-    key = url,
-    status = status.toInt(),
-    title = title,
-)
-
 fun Manga.toMangaUpdate(): MangaUpdate {
    return MangaUpdate(
        id = id,
@ -213,6 +227,22 @@ fun Manga.toMangaUpdate(): MangaUpdate {
        genre = genre,
        status = status,
        thumbnailUrl = thumbnailUrl,
+        updateStrategy = updateStrategy,
+        initialized = initialized,
+    )
+}
+
+fun SManga.toDomainManga(): Manga {
+    return Manga.create().copy(
+        url = url,
+        title = title,
+        artist = artist,
+        author = author,
+        description = description,
+        genre = getGenres(),
+        status = status.toLong(),
+        thumbnailUrl = thumbnail_url,
+        updateStrategy = update_strategy,
        initialized = initialized,
    )
 }
--- a/app/src/main/java/eu/kanade/domain/manga/model/MangaUpdate.kt
+++ b/app/src/main/java/eu/kanade/domain/manga/model/MangaUpdate.kt
@ -1,5 +1,7 @@
 package eu.kanade.domain.manga.model

+import eu.kanade.tachiyomi.source.model.UpdateStrategy
+
 data class MangaUpdate(
    val id: Long,
    val source: Long? = null,
@ -17,5 +19,6 @@ data class MangaUpdate(
    val genre: List<String>? = null,
    val status: Long? = null,
    val thumbnailUrl: String? = null,
+    val updateStrategy: UpdateStrategy? = null,
    val initialized: Boolean? = null,
 )
--- a/app/src/main/java/eu/kanade/domain/manga/repository/MangaRepository.kt
+++ b/app/src/main/java/eu/kanade/domain/manga/repository/MangaRepository.kt
@ -1,8 +1,8 @@
 package eu.kanade.domain.manga.repository

+import eu.kanade.domain.library.model.LibraryManga
 import eu.kanade.domain.manga.model.Manga
 import eu.kanade.domain.manga.model.MangaUpdate
-import eu.kanade.tachiyomi.data.database.models.LibraryManga
 import kotlinx.coroutines.flow.Flow

 interface MangaRepository {
@ -13,6 +13,8 @@ interface MangaRepository {

    suspend fun getMangaByUrlAndSourceId(url: String, sourceId: Long): Manga?

+    fun getMangaByUrlAndSourceIdAsFlow(url: String, sourceId: Long): Flow<Manga?>
+
    suspend fun getFavorites(): List<Manga>

    suspend fun getLibraryManga(): List<LibraryManga>
@ -31,5 +33,5 @@ interface MangaRepository {

    suspend fun update(update: MangaUpdate): Boolean

-    suspend fun updateAll(values: List<MangaUpdate>): Boolean
+    suspend fun updateAll(mangaUpdates: List<MangaUpdate>): Boolean
 }
--- a/app/src/main/java/eu/kanade/domain/source/interactor/GetEnabledSources.kt
+++ b/app/src/main/java/eu/kanade/domain/source/interactor/GetEnabledSources.kt
@ -4,7 +4,7 @@ import eu.kanade.domain.source.model.Pin
 import eu.kanade.domain.source.model.Pins
 import eu.kanade.domain.source.model.Source
 import eu.kanade.domain.source.repository.SourceRepository
-import eu.kanade.tachiyomi.data.preference.PreferencesHelper
+import eu.kanade.domain.source.service.SourcePreferences
 import eu.kanade.tachiyomi.source.LocalSource
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
@ -12,15 +12,15 @@ import kotlinx.coroutines.flow.distinctUntilChanged

 class GetEnabledSources(
    private val repository: SourceRepository,
-    private val preferences: PreferencesHelper,
+    private val preferences: SourcePreferences,
 ) {

    fun subscribe(): Flow<List<Source>> {
        return combine(
-            preferences.pinnedSources().asFlow(),
-            preferences.enabledLanguages().asFlow(),
-            preferences.disabledSources().asFlow(),
-            preferences.lastUsedSource().asFlow(),
+            preferences.pinnedSources().changes(),
+            preferences.enabledLanguages().changes(),
+            preferences.disabledSources().changes(),
+            preferences.lastUsedSource().changes(),
            repository.getSources(),
        ) { pinnedSourceIds, enabledLanguages, disabledSources, lastUsedSource, sources ->
            val duplicatePins = preferences.duplicatePinnedSources().get()
--- a/app/src/main/java/eu/kanade/domain/source/interactor/GetLanguagesWithSources.kt
+++ b/app/src/main/java/eu/kanade/domain/source/interactor/GetLanguagesWithSources.kt
@ -2,20 +2,20 @@ package eu.kanade.domain.source.interactor

 import eu.kanade.domain.source.model.Source
 import eu.kanade.domain.source.repository.SourceRepository
-import eu.kanade.tachiyomi.data.preference.PreferencesHelper
+import eu.kanade.domain.source.service.SourcePreferences
 import eu.kanade.tachiyomi.util.system.LocaleHelper
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine

 class GetLanguagesWithSources(
    private val repository: SourceRepository,
-    private val preferences: PreferencesHelper,
+    private val preferences: SourcePreferences,
 ) {

    fun subscribe(): Flow<Map<String, List<Source>>> {
        return combine(
-            preferences.enabledLanguages().asFlow(),
-            preferences.disabledSources().asFlow(),
+            preferences.enabledLanguages().changes(),
+            preferences.disabledSources().changes(),
            repository.getOnlineSources(),
        ) { enabledLanguage, disabledSource, onlineSources ->
            val sortedSources = onlineSources.sortedWith(
--- a/app/src/main/java/eu/kanade/domain/source/interactor/GetRemoteManga.kt
+++ b/app/src/main/java/eu/kanade/domain/source/interactor/GetRemoteManga.kt
@ -0,0 +1,23 @@
+package eu.kanade.domain.source.interactor
+
+import eu.kanade.domain.source.model.SourcePagingSourceType
+import eu.kanade.domain.source.repository.SourceRepository
+import eu.kanade.tachiyomi.source.model.FilterList
+
+class GetRemoteManga(
+    private val repository: SourceRepository,
+) {
+
+    fun subscribe(sourceId: Long, query: String, filterList: FilterList): SourcePagingSourceType {
+        return when (query) {
+            QUERY_POPULAR -> repository.getPopular(sourceId)
+            QUERY_LATEST -> repository.getLatest(sourceId)
+            else -> repository.search(sourceId, query, filterList)
+        }
+    }
+
+    companion object {
+        const val QUERY_POPULAR = "eu.kanade.domain.source.interactor.POPULAR"
+        const val QUERY_LATEST = "eu.kanade.domain.source.interactor.LATEST"
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/source/interactor/GetSourceData.kt
+++ b/app/src/main/java/eu/kanade/domain/source/interactor/GetSourceData.kt
@ -1,20 +0,0 @@
-package eu.kanade.domain.source.interactor
-
-import eu.kanade.domain.source.model.SourceData
-import eu.kanade.domain.source.repository.SourceRepository
-import eu.kanade.tachiyomi.util.system.logcat
-import logcat.LogPriority
-
-class GetSourceData(
-    private val repository: SourceRepository,
-) {
-
-    suspend fun await(id: Long): SourceData? {
-        return try {
-            repository.getSourceData(id)
-        } catch (e: Exception) {
-            logcat(LogPriority.ERROR, e)
-            null
-        }
-    }
-}
--- a/app/src/main/java/eu/kanade/domain/source/interactor/GetSourcesWithFavoriteCount.kt
+++ b/app/src/main/java/eu/kanade/domain/source/interactor/GetSourcesWithFavoriteCount.kt
@ -2,7 +2,7 @@ package eu.kanade.domain.source.interactor

 import eu.kanade.domain.source.model.Source
 import eu.kanade.domain.source.repository.SourceRepository
-import eu.kanade.tachiyomi.data.preference.PreferencesHelper
+import eu.kanade.domain.source.service.SourcePreferences
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
 import java.text.Collator
@ -11,13 +11,13 @@ import java.util.Locale

 class GetSourcesWithFavoriteCount(
    private val repository: SourceRepository,
-    private val preferences: PreferencesHelper,
+    private val preferences: SourcePreferences,
 ) {

    fun subscribe(): Flow<List<Pair<Source, Long>>> {
        return combine(
-            preferences.migrationSortingDirection().asFlow(),
-            preferences.migrationSortingMode().asFlow(),
+            preferences.migrationSortingDirection().changes(),
+            preferences.migrationSortingMode().changes(),
            repository.getSourcesWithFavoriteCount(),
        ) { direction, mode, list ->
            list.sortedWith(sortFn(direction, mode))
--- a/app/src/main/java/eu/kanade/domain/source/interactor/GetSourcesWithNonLibraryManga.kt
+++ b/app/src/main/java/eu/kanade/domain/source/interactor/GetSourcesWithNonLibraryManga.kt
@ -1,14 +1,14 @@
 package eu.kanade.domain.source.interactor

+import eu.kanade.domain.source.model.SourceWithCount
 import eu.kanade.domain.source.repository.SourceRepository
-import eu.kanade.tachiyomi.source.Source
 import kotlinx.coroutines.flow.Flow

 class GetSourcesWithNonLibraryManga(
    private val repository: SourceRepository,
 ) {

-    fun subscribe(): Flow<List<Pair<Source, Long>>> {
+    fun subscribe(): Flow<List<SourceWithCount>> {
        return repository.getSourcesWithNonLibraryManga()
    }
 }
--- a/app/src/main/java/eu/kanade/domain/source/interactor/SetMigrateSorting.kt
+++ b/app/src/main/java/eu/kanade/domain/source/interactor/SetMigrateSorting.kt
@ -1,24 +1,23 @@
 package eu.kanade.domain.source.interactor

-import eu.kanade.tachiyomi.data.preference.PreferencesHelper
+import eu.kanade.domain.source.service.SourcePreferences

 class SetMigrateSorting(
-    private val preferences: PreferencesHelper,
+    private val preferences: SourcePreferences,
 ) {

-    fun await(mode: Mode, isAscending: Boolean) {
-        val direction = if (isAscending) Direction.ASCENDING else Direction.DESCENDING
-        preferences.migrationSortingDirection().set(direction)
+    fun await(mode: Mode, direction: Direction) {
        preferences.migrationSortingMode().set(mode)
+        preferences.migrationSortingDirection().set(direction)
    }

    enum class Mode {
        ALPHABETICAL,
-        TOTAL;
+        TOTAL,
    }

    enum class Direction {
        ASCENDING,
-        DESCENDING;
+        DESCENDING,
    }
 }
--- a/app/src/main/java/eu/kanade/domain/source/interactor/ToggleLanguage.kt
+++ b/app/src/main/java/eu/kanade/domain/source/interactor/ToggleLanguage.kt
@ -1,19 +1,16 @@
 package eu.kanade.domain.source.interactor

-import eu.kanade.tachiyomi.data.preference.PreferencesHelper
-import eu.kanade.tachiyomi.util.preference.minusAssign
-import eu.kanade.tachiyomi.util.preference.plusAssign
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.core.preference.getAndSet

 class ToggleLanguage(
-    val preferences: PreferencesHelper,
+    val preferences: SourcePreferences,
 ) {

    fun await(language: String) {
-        val enabled = language in preferences.enabledLanguages().get()
-        if (enabled) {
-            preferences.enabledLanguages() -= language
-        } else {
-            preferences.enabledLanguages() += language
+        val isEnabled = language in preferences.enabledLanguages().get()
+        preferences.enabledLanguages().getAndSet { enabled ->
+            if (isEnabled) enabled.minus(language) else enabled.plus(language)
        }
    }
 }
--- a/app/src/main/java/eu/kanade/domain/source/interactor/ToggleSource.kt
+++ b/app/src/main/java/eu/kanade/domain/source/interactor/ToggleSource.kt
@ -1,23 +1,24 @@
 package eu.kanade.domain.source.interactor

 import eu.kanade.domain.source.model.Source
-import eu.kanade.tachiyomi.data.preference.PreferencesHelper
-import eu.kanade.tachiyomi.util.preference.minusAssign
-import eu.kanade.tachiyomi.util.preference.plusAssign
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.core.preference.getAndSet

 class ToggleSource(
-    private val preferences: PreferencesHelper,
+    private val preferences: SourcePreferences,
 ) {

-    fun await(source: Source, enable: Boolean = source.id.toString() in preferences.disabledSources().get()) {
+    fun await(source: Source, enable: Boolean = isEnabled(source.id)) {
        await(source.id, enable)
    }

-    fun await(sourceId: Long, enable: Boolean = sourceId.toString() in preferences.disabledSources().get()) {
-        if (enable) {
-            preferences.disabledSources() -= sourceId.toString()
-        } else {
-            preferences.disabledSources() += sourceId.toString()
+    fun await(sourceId: Long, enable: Boolean = isEnabled(sourceId)) {
+        preferences.disabledSources().getAndSet { disabled ->
+            if (enable) disabled.minus("$sourceId") else disabled.plus("$sourceId")
        }
    }
+
+    private fun isEnabled(sourceId: Long): Boolean {
+        return sourceId.toString() in preferences.disabledSources().get()
+    }
 }
--- a/app/src/main/java/eu/kanade/domain/source/interactor/ToggleSourcePin.kt
+++ b/app/src/main/java/eu/kanade/domain/source/interactor/ToggleSourcePin.kt
@ -1,20 +1,17 @@
 package eu.kanade.domain.source.interactor

 import eu.kanade.domain.source.model.Source
-import eu.kanade.tachiyomi.data.preference.PreferencesHelper
-import eu.kanade.tachiyomi.util.preference.minusAssign
-import eu.kanade.tachiyomi.util.preference.plusAssign
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.core.preference.getAndSet

 class ToggleSourcePin(
-    private val preferences: PreferencesHelper,
+    private val preferences: SourcePreferences,
 ) {

    fun await(source: Source) {
        val isPinned = source.id.toString() in preferences.pinnedSources().get()
-        if (isPinned) {
-            preferences.pinnedSources() -= source.id.toString()
-        } else {
-            preferences.pinnedSources() += source.id.toString()
+        preferences.pinnedSources().getAndSet { pinned ->
+            if (isPinned) pinned.minus("${source.id}") else pinned.plus("${source.id}")
        }
    }
 }
--- a/app/src/main/java/eu/kanade/domain/source/interactor/UpsertSourceData.kt
+++ b/app/src/main/java/eu/kanade/domain/source/interactor/UpsertSourceData.kt
@ -1,19 +0,0 @@
-package eu.kanade.domain.source.interactor
-
-import eu.kanade.domain.source.model.SourceData
-import eu.kanade.domain.source.repository.SourceRepository
-import eu.kanade.tachiyomi.util.system.logcat
-import logcat.LogPriority
-
-class UpsertSourceData(
-    private val repository: SourceRepository,
-) {
-
-    suspend fun await(sourceData: SourceData) {
-        try {
-            repository.upsertSourceData(sourceData.id, sourceData.lang, sourceData.name)
-        } catch (e: Exception) {
-            logcat(LogPriority.ERROR, e)
-        }
-    }
-}
--- a/app/src/main/java/eu/kanade/domain/source/model/Source.kt
+++ b/app/src/main/java/eu/kanade/domain/source/model/Source.kt
@ -17,8 +17,11 @@ data class Source(
    val isUsedLast: Boolean = false,
 ) {

-    val nameWithLanguage: String
-        get() = "$name (${lang.uppercase()})"
+    val visualName: String
+        get() = when {
+            lang.isEmpty() -> name
+            else -> "$name (${lang.uppercase()})"
+        }

    val icon: ImageBitmap?
        get() {
--- a/app/src/main/java/eu/kanade/domain/source/model/SourceData.kt
+++ b/app/src/main/java/eu/kanade/domain/source/model/SourceData.kt
@ -4,4 +4,7 @@ data class SourceData(
    val id: Long,
    val lang: String,
    val name: String,
-)
+) {
+
+    val isMissingInfo: Boolean = name.isBlank() || lang.isBlank()
+}
--- a/app/src/main/java/eu/kanade/domain/source/model/SourcePagingSourceType.kt
+++ b/app/src/main/java/eu/kanade/domain/source/model/SourcePagingSourceType.kt
@ -0,0 +1,6 @@
+package eu.kanade.domain.source.model
+
+import androidx.paging.PagingSource
+import eu.kanade.tachiyomi.source.model.SManga
+
+typealias SourcePagingSourceType = PagingSource<Long, SManga>
--- a/app/src/main/java/eu/kanade/domain/source/model/SourceWithCount.kt
+++ b/app/src/main/java/eu/kanade/domain/source/model/SourceWithCount.kt
@ -0,0 +1,13 @@
+package eu.kanade.domain.source.model
+
+data class SourceWithCount(
+    val source: Source,
+    val count: Long,
+) {
+
+    val id: Long
+        get() = source.id
+
+    val name: String
+        get() = source.name
+}
--- a/app/src/main/java/eu/kanade/domain/source/repository/SourceDataRepository.kt
+++ b/app/src/main/java/eu/kanade/domain/source/repository/SourceDataRepository.kt
@ -0,0 +1,12 @@
+package eu.kanade.domain.source.repository
+
+import eu.kanade.domain.source.model.SourceData
+import kotlinx.coroutines.flow.Flow
+
+interface SourceDataRepository {
+    fun subscribeAll(): Flow<List<SourceData>>
+
+    suspend fun getSourceData(id: Long): SourceData?
+
+    suspend fun upsertSourceData(id: Long, lang: String, name: String)
+}
--- a/app/src/main/java/eu/kanade/domain/source/repository/SourceRepository.kt
+++ b/app/src/main/java/eu/kanade/domain/source/repository/SourceRepository.kt
@ -1,9 +1,10 @@
 package eu.kanade.domain.source.repository

 import eu.kanade.domain.source.model.Source
-import eu.kanade.domain.source.model.SourceData
+import eu.kanade.domain.source.model.SourcePagingSourceType
+import eu.kanade.domain.source.model.SourceWithCount
+import eu.kanade.tachiyomi.source.model.FilterList
 import kotlinx.coroutines.flow.Flow
-import eu.kanade.tachiyomi.source.Source as LoadedSource

 interface SourceRepository {

@ -13,9 +14,11 @@ interface SourceRepository {

    fun getSourcesWithFavoriteCount(): Flow<List<Pair<Source, Long>>>

-    fun getSourcesWithNonLibraryManga(): Flow<List<Pair<LoadedSource, Long>>>
+    fun getSourcesWithNonLibraryManga(): Flow<List<SourceWithCount>>

-    suspend fun getSourceData(id: Long): SourceData?
+    fun search(sourceId: Long, query: String, filterList: FilterList): SourcePagingSourceType

-    suspend fun upsertSourceData(id: Long, lang: String, name: String)
+    fun getPopular(sourceId: Long): SourcePagingSourceType
+
+    fun getLatest(sourceId: Long): SourcePagingSourceType
 }
--- a/app/src/main/java/eu/kanade/domain/source/service/SourcePreferences.kt
+++ b/app/src/main/java/eu/kanade/domain/source/service/SourcePreferences.kt
@ -0,0 +1,36 @@
+package eu.kanade.domain.source.service
+
+import eu.kanade.domain.library.model.LibraryDisplayMode
+import eu.kanade.domain.source.interactor.SetMigrateSorting
+import eu.kanade.tachiyomi.core.preference.PreferenceStore
+import eu.kanade.tachiyomi.core.preference.getEnum
+import eu.kanade.tachiyomi.util.system.LocaleHelper
+
+class SourcePreferences(
+    private val preferenceStore: PreferenceStore,
+) {
+
+    fun sourceDisplayMode() = preferenceStore.getObject("pref_display_mode_catalogue", LibraryDisplayMode.default, LibraryDisplayMode.Serializer::serialize, LibraryDisplayMode.Serializer::deserialize)
+
+    fun enabledLanguages() = preferenceStore.getStringSet("source_languages", LocaleHelper.getDefaultEnabledLanguages())
+
+    fun disabledSources() = preferenceStore.getStringSet("hidden_catalogues", emptySet())
+
+    fun pinnedSources() = preferenceStore.getStringSet("pinned_catalogues", emptySet())
+
+    fun duplicatePinnedSources() = preferenceStore.getBoolean("duplicate_pinned_sources", false)
+
+    fun lastUsedSource() = preferenceStore.getLong("last_catalogue_source", -1)
+
+    fun showNsfwSource() = preferenceStore.getBoolean("show_nsfw_source", true)
+
+    fun migrationSortingMode() = preferenceStore.getEnum("pref_migration_sorting", SetMigrateSorting.Mode.ALPHABETICAL)
+
+    fun migrationSortingDirection() = preferenceStore.getEnum("pref_migration_direction", SetMigrateSorting.Direction.ASCENDING)
+
+    fun extensionUpdatesCount() = preferenceStore.getInt("ext_updates_count", 0)
+
+    fun trustedSignatures() = preferenceStore.getStringSet("trusted_signatures", emptySet())
+
+    fun searchPinnedSourcesOnly() = preferenceStore.getBoolean("search_pinned_sources_only", false)
+}
--- a/app/src/main/java/eu/kanade/domain/track/interactor/GetTracks.kt
+++ b/app/src/main/java/eu/kanade/domain/track/interactor/GetTracks.kt
@ -19,10 +19,6 @@ class GetTracks(
        }
    }

-    fun subscribe(): Flow<List<Track>> {
-        return trackRepository.getTracksAsFlow()
-    }
-
    fun subscribe(mangaId: Long): Flow<List<Track>> {
        return trackRepository.getTracksByMangaIdAsFlow(mangaId)
    }
--- a/app/src/main/java/eu/kanade/domain/track/interactor/GetTracksPerManga.kt
+++ b/app/src/main/java/eu/kanade/domain/track/interactor/GetTracksPerManga.kt
@ -0,0 +1,20 @@
+package eu.kanade.domain.track.interactor
+
+import eu.kanade.domain.track.repository.TrackRepository
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+
+class GetTracksPerManga(
+    private val trackRepository: TrackRepository,
+) {
+
+    fun subscribe(): Flow<Map<Long, List<Long>>> {
+        return trackRepository.getTracksAsFlow().map { tracks ->
+            tracks
+                .groupBy { it.mangaId }
+                .mapValues { entry ->
+                    entry.value.map { it.syncId }
+                }
+        }
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/track/service/TrackPreferences.kt
+++ b/app/src/main/java/eu/kanade/domain/track/service/TrackPreferences.kt
@ -0,0 +1,33 @@
+package eu.kanade.domain.track.service
+
+import eu.kanade.tachiyomi.core.preference.PreferenceStore
+import eu.kanade.tachiyomi.data.track.TrackService
+import eu.kanade.tachiyomi.data.track.anilist.Anilist
+
+class TrackPreferences(
+    private val preferenceStore: PreferenceStore,
+) {
+
+    fun trackUsername(sync: TrackService) = preferenceStore.getString(trackUsername(sync.id), "")
+
+    fun trackPassword(sync: TrackService) = preferenceStore.getString(trackPassword(sync.id), "")
+
+    fun setTrackCredentials(sync: TrackService, username: String, password: String) {
+        trackUsername(sync).set(username)
+        trackPassword(sync).set(password)
+    }
+
+    fun trackToken(sync: TrackService) = preferenceStore.getString(trackToken(sync.id), "")
+
+    fun anilistScoreType() = preferenceStore.getString("anilist_score_type", Anilist.POINT_10)
+
+    fun autoUpdateTrack() = preferenceStore.getBoolean("pref_auto_update_manga_sync_key", true)
+
+    companion object {
+        fun trackUsername(syncId: Long) = "pref_mangasync_username_$syncId"
+
+        private fun trackPassword(syncId: Long) = "pref_mangasync_password_$syncId"
+
+        private fun trackToken(syncId: Long) = "track_token_$syncId"
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/ui/UiPreferences.kt
+++ b/app/src/main/java/eu/kanade/domain/ui/UiPreferences.kt
@ -0,0 +1,43 @@
+package eu.kanade.domain.ui
+
+import android.os.Build
+import eu.kanade.domain.ui.model.AppTheme
+import eu.kanade.domain.ui.model.TabletUiMode
+import eu.kanade.domain.ui.model.ThemeMode
+import eu.kanade.tachiyomi.core.preference.PreferenceStore
+import eu.kanade.tachiyomi.core.preference.getEnum
+import eu.kanade.tachiyomi.util.system.DeviceUtil
+import eu.kanade.tachiyomi.util.system.isDynamicColorAvailable
+import java.text.DateFormat
+import java.text.SimpleDateFormat
+import java.util.Locale
+
+class UiPreferences(
+    private val preferenceStore: PreferenceStore,
+) {
+
+    fun themeMode() = preferenceStore.getEnum(
+        "pref_theme_mode_key",
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { ThemeMode.SYSTEM } else { ThemeMode.LIGHT },
+    )
+
+    fun appTheme() = preferenceStore.getEnum(
+        "pref_app_theme",
+        if (DeviceUtil.isDynamicColorAvailable) { AppTheme.MONET } else { AppTheme.DEFAULT },
+    )
+
+    fun themeDarkAmoled() = preferenceStore.getBoolean("pref_theme_dark_amoled_key", false)
+
+    fun relativeTime() = preferenceStore.getInt("relative_time", 7)
+
+    fun dateFormat() = preferenceStore.getString("app_date_format", "")
+
+    fun tabletUiMode() = preferenceStore.getEnum("tablet_ui_mode", TabletUiMode.AUTOMATIC)
+
+    companion object {
+        fun dateFormat(format: String): DateFormat = when (format) {
+            "" -> DateFormat.getDateInstance(DateFormat.SHORT)
+            else -> SimpleDateFormat(format, Locale.getDefault())
+        }
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/ui/model/AppTheme.kt
+++ b/app/src/main/java/eu/kanade/domain/ui/model/AppTheme.kt
@ -0,0 +1,22 @@
+package eu.kanade.domain.ui.model
+
+import eu.kanade.tachiyomi.R
+
+enum class AppTheme(val titleResId: Int?) {
+    DEFAULT(R.string.label_default),
+    MONET(R.string.theme_monet),
+    GREEN_APPLE(R.string.theme_greenapple),
+    LAVENDER(R.string.theme_lavender),
+    MIDNIGHT_DUSK(R.string.theme_midnightdusk),
+    STRAWBERRY_DAIQUIRI(R.string.theme_strawberrydaiquiri),
+    TAKO(R.string.theme_tako),
+    TEALTURQUOISE(R.string.theme_tealturquoise),
+    TIDAL_WAVE(R.string.theme_tidalwave),
+    YINYANG(R.string.theme_yinyang),
+    YOTSUBA(R.string.theme_yotsuba),
+
+    // Deprecated
+    DARK_BLUE(null),
+    HOT_PINK(null),
+    BLUE(null),
+}
--- a/app/src/main/java/eu/kanade/domain/ui/model/TabletUiMode.kt
+++ b/app/src/main/java/eu/kanade/domain/ui/model/TabletUiMode.kt
@ -0,0 +1,10 @@
+package eu.kanade.domain.ui.model
+
+import eu.kanade.tachiyomi.R
+
+enum class TabletUiMode(val titleResId: Int) {
+    AUTOMATIC(R.string.automatic_background),
+    ALWAYS(R.string.lock_always),
+    LANDSCAPE(R.string.landscape),
+    NEVER(R.string.lock_never),
+}
--- a/app/src/main/java/eu/kanade/domain/ui/model/ThemeMode.kt
+++ b/app/src/main/java/eu/kanade/domain/ui/model/ThemeMode.kt
@ -0,0 +1,19 @@
+package eu.kanade.domain.ui.model
+
+import androidx.appcompat.app.AppCompatDelegate
+
+enum class ThemeMode {
+    LIGHT,
+    DARK,
+    SYSTEM,
+}
+
+fun setAppCompatDelegateThemeMode(themeMode: ThemeMode) {
+    AppCompatDelegate.setDefaultNightMode(
+        when (themeMode) {
+            ThemeMode.LIGHT -> AppCompatDelegate.MODE_NIGHT_NO
+            ThemeMode.DARK -> AppCompatDelegate.MODE_NIGHT_YES
+            ThemeMode.SYSTEM -> AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM
+        },
+    )
+}
--- a/app/src/main/java/eu/kanade/domain/updates/interactor/GetUpdates.kt
+++ b/app/src/main/java/eu/kanade/domain/updates/interactor/GetUpdates.kt
@ -0,0 +1,24 @@
+package eu.kanade.domain.updates.interactor
+
+import eu.kanade.domain.library.service.LibraryPreferences
+import eu.kanade.domain.updates.model.UpdatesWithRelations
+import eu.kanade.domain.updates.repository.UpdatesRepository
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.onEach
+import java.util.Calendar
+
+class GetUpdates(
+    private val repository: UpdatesRepository,
+    private val preferences: LibraryPreferences,
+) {
+
+    fun subscribe(calendar: Calendar): Flow<List<UpdatesWithRelations>> = subscribe(calendar.time.time)
+
+    fun subscribe(after: Long): Flow<List<UpdatesWithRelations>> {
+        return repository.subscribeAll(after)
+            .onEach { updates ->
+                // Set unread chapter count for bottom bar badge
+                preferences.unreadUpdatesCount().set(updates.count { !it.read })
+            }
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/updates/model/UpdatesWithRelations.kt
+++ b/app/src/main/java/eu/kanade/domain/updates/model/UpdatesWithRelations.kt
@ -0,0 +1,16 @@
+package eu.kanade.domain.updates.model
+
+import eu.kanade.domain.manga.model.MangaCover
+
+data class UpdatesWithRelations(
+    val mangaId: Long,
+    val mangaTitle: String,
+    val chapterId: Long,
+    val chapterName: String,
+    val scanlator: String?,
+    val read: Boolean,
+    val bookmark: Boolean,
+    val sourceId: Long,
+    val dateFetch: Long,
+    val coverData: MangaCover,
+)
--- a/Show more
+++ b/Show more