Release v0.14.3

Update baseline profile
Translations update from Hosted Weblate (#8764 )
2025-06-26 11:07:51 +02:00 · 2023-01-07 12:09:27 -05:00 · 2023-01-07 12:03:17 -05:00 · 2023-01-07 11:54:23 -05:00 · 2023-01-07 11:51:36 -05:00 · 2023-01-07 11:51:00 -05:00
1268 changed files with 82205 additions and 45180 deletions
--- a/.editorconfig
+++ b/.editorconfig
@ -2,4 +2,6 @@
 indent_size=4
 insert_final_newline=true
 ij_kotlin_allow_trailing_comma=true
-ij_kotlin_allow_trailing_comma_on_call_site=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/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@ -3,11 +3,11 @@
 I acknowledge that:

 - I have updated:
-  - To the latest version of the app (stable is v0.13.3)
+  - To the latest version of the app (stable is v0.14.3)
  - All extensions
 - I have tried the troubleshooting guide: https://tachiyomi.org/help/guides/troubleshooting-problems/
 - If this is an issue with an extension, that I should be opening an issue in https://github.com/tachiyomiorg/tachiyomi-extensions
- I have searched the existing issues and this is new ticket **NOT** a duplicate or related to another open issue
+- I have searched the existing issues and this is new ticket **NOT** a duplicate or related to another open or closed issue
 - I will fill out the title and the information in this template

 Note that the issue will be automatically closed if you do not fill out the title or requested information.
--- a/.github/ISSUE_TEMPLATE/report_issue.yml
+++ b/.github/ISSUE_TEMPLATE/report_issue.yml
@ -45,7 +45,7 @@ body:
      description: |
        If you're experiencing crashes, share the crash logs from **More → Settings → Advanced** then press **Dump crash logs**.
      placeholder: |
-        You can paste the crash logs in pure text or upload it as an attachment.
+        You can paste the crash logs in plain text or upload it as an attachment.

  - type: input
    id: tachiyomi-version
@ -53,7 +53,7 @@ body:
      label: Tachiyomi version
      description: You can find your Tachiyomi version in **More → About**.
      placeholder: |
-        Example: "0.13.3"
+        Example: "0.14.3"
    validations:
      required: true

@ -90,7 +90,7 @@ body:
      label: Acknowledgements
      description: Read this carefully, we will close and ignore your issue if you skimmed through this.
      options:
-        - label: I have searched the existing issues and this is a new ticket, **NOT** a duplicate or related to another open issue.
+        - label: I have searched the existing issues and this is a new ticket, **NOT** a duplicate or related to another open or closed issue.
          required: true
        - label: I have written a short but informative title.
          required: true
@ -98,7 +98,7 @@ body:
          required: true
        - label: I have tried the [troubleshooting guide](https://tachiyomi.org/help/guides/troubleshooting/).
          required: true
-        - label: I have updated the app to version **[0.13.3](https://github.com/tachiyomiorg/tachiyomi/releases/latest)**.
+        - label: I have updated the app to version **[0.14.3](https://github.com/tachiyomiorg/tachiyomi/releases/latest)**.
          required: true
        - label: I have updated all installed extensions.
          required: true
--- a/.github/ISSUE_TEMPLATE/request_feature.yml
+++ b/.github/ISSUE_TEMPLATE/request_feature.yml
@ -27,13 +27,13 @@ body:
      label: Acknowledgements
      description: Read this carefully, we will close and ignore your issue if you skimmed through this.
      options:
-        - label: I have searched the existing issues and this is a new ticket, **NOT** a duplicate or related to another open issue.
+        - label: I have searched the existing issues and this is a new ticket, **NOT** a duplicate or related to another open or closed issue.
          required: true
        - label: I have written a short but informative title.
          required: true
        - label: If this is an issue with an extension, I should be opening an issue in the [extensions repository](https://github.com/tachiyomiorg/tachiyomi-extensions/issues/new/choose).
          required: true
-        - label: I have updated the app to version **[0.13.3](https://github.com/tachiyomiorg/tachiyomi/releases/latest)**.
+        - label: I have updated the app to version **[0.14.3](https://github.com/tachiyomiorg/tachiyomi/releases/latest)**.
          required: true
        - label: I will fill out all of the requested information in this form.
          required: true
--- a/.github/mergify.yml
+++ b/.github/mergify.yml
@ -0,0 +1,10 @@
+#pull_request_rules:
+#  - name: Automatically merge translations
+#    conditions:
+#      - "author = weblate"
+#      - "-conflict"
+#      - "current-day-of-week = Sat"
+#      - "created-at < 1 day ago"
+#    actions:
+#      merge:
+#        method: squash
--- a/.github/renovate.json
+++ b/.github/renovate.json
@ -0,0 +1,12 @@
+{
+  "extends": [
+    "config:base"
+  ],
+  "schedule": ["every sunday"],
+  "ignoreDeps": [
+    "androidx.core:core-splashscreen",
+    "com.android.tools:r8",
+    "com.google.guava:guava",
+    "com.github.commandiron:WheelPickerCompose"
+  ]
+}
--- a/.github/runner-files/ci-gradle.properties
+++ b/.github/runner-files/ci-gradle.properties
@ -1,5 +0,0 @@
-org.gradle.daemon=false
-org.gradle.jvmargs=-Xmx5120m
-org.gradle.workers.max=2
-
-kotlin.incremental=false
--- 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
@ -21,19 +25,15 @@ jobs:
        uses: gradle/wrapper-validation-action@v1

      - name: Dependency Review
-        uses: actions/dependency-review-action@v1
+        uses: actions/dependency-review-action@v3

      - name: Set up JDK 11
-        uses: actions/setup-java@v1
+        uses: actions/setup-java@v3
        with:
          java-version: 11
+          distribution: adopt

-      - name: Copy CI gradle.properties
-        run: |
-          mkdir -p ~/.gradle
-          cp .github/runner-files/ci-gradle.properties ~/.gradle/gradle.properties
-
-      - name: Build app
+      - name: Build app and run unit tests
        uses: gradle/gradle-command-action@v2
        with:
-          arguments: assembleStandardRelease
+          arguments: assembleStandardRelease testStandardReleaseUnitTest
--- a/.github/workflows/build_push.yml
+++ b/.github/workflows/build_push.yml
@ -6,18 +6,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.9.1
-        with:
-          access_token: ${{ github.token }}
-          all_but_latest: true
-
      - name: Clone repo
        uses: actions/checkout@v3

@ -25,19 +23,15 @@ jobs:
        uses: gradle/wrapper-validation-action@v1

      - name: Set up JDK 11
-        uses: actions/setup-java@v1
+        uses: actions/setup-java@v3
        with:
          java-version: 11
+          distribution: adopt

-      - name: Copy CI gradle.properties
-        run: |
-          mkdir -p ~/.gradle
-          cp .github/runner-files/ci-gradle.properties ~/.gradle/gradle.properties
-
-      - name: Build app
+      - name: Build app and run unit tests
        uses: gradle/gradle-command-action@v2
        with:
-          arguments: assembleStandardRelease
+          arguments: assembleStandardRelease testStandardReleaseUnitTest

      # Sign APK and create release for tags

@ -77,6 +71,10 @@ jobs:
          cp app/build/outputs/apk/standard/release/app-standard-x86-release-unsigned-signed.apk tachiyomi-x86-${{ env.VERSION_TAG }}.apk
          sha=`sha256sum tachiyomi-x86-${{ env.VERSION_TAG }}.apk | awk '{ print $1 }'`
          echo "APK_X86_SHA=$sha" >> $GITHUB_ENV
+          
+          cp app/build/outputs/apk/standard/release/app-standard-x86_64-release-unsigned-signed.apk tachiyomi-x86_64-${{ env.VERSION_TAG }}.apk
+          sha=`sha256sum tachiyomi-x86_64-${{ env.VERSION_TAG }}.apk | awk '{ print $1 }'`
+          echo "APK_X86_64_SHA=$sha" >> $GITHUB_ENV

      - name: Create Release
        if: startsWith(github.ref, 'refs/tags/') && github.repository == 'tachiyomiorg/tachiyomi'
@ -95,11 +93,13 @@ jobs:
            | arm64-v8a | ${{ env.APK_ARM64_V8A_SHA }}
            | armeabi-v7a | ${{ env.APK_ARMEABI_V7A_SHA }}
            | x86 | ${{ env.APK_X86_SHA }} |
+            | x86_64 | ${{ env.APK_X86_64_SHA }} |
          files: |
            tachiyomi-${{ env.VERSION_TAG }}.apk
            tachiyomi-arm64-v8a-${{ env.VERSION_TAG }}.apk
            tachiyomi-armeabi-v7a-${{ env.VERSION_TAG }}.apk
            tachiyomi-x86-${{ env.VERSION_TAG }}.apk
+            tachiyomi-x86_64-${{ env.VERSION_TAG }}.apk
          draft: true
          prerelease: false
        env:
--- 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.9.1
-      with:
-        all_but_latest: true
-        workflow_id: ${{ github.event.workflow.id }}
--- a/.github/workflows/lock.yml
+++ b/.github/workflows/lock.yml
@ -12,7 +12,7 @@ jobs:
  lock:
    runs-on: ubuntu-latest
    steps:
-      - uses: dessant/lock-threads@v3
+      - uses: dessant/lock-threads@v4
        with:
          github-token: ${{ github.token }}
          issue-inactive-days: '2'
--- a/.gitignore
+++ b/.gitignore
@ -12,5 +12,5 @@
 *.apk
 app/**/output.json

-# Hebrew assets are copied on build
-app/src/main/res/values-iw/
+# Unnecessary file
+*.swp
--- a/README.md
+++ b/README.md
@ -12,7 +12,7 @@ Features include:
 * Online reading from a variety of sources
 * Local reading of downloaded content
 * A configurable reader with multiple viewers, reading directions and other settings.
-* Tracker support: [MyAnimeList](https://myanimelist.net/), [AniList](https://anilist.co/), [Kitsu](https://kitsu.io/), [Shikimori](https://shikimori.one), and [Bangumi](https://bgm.tv/)
+* Tracker support: [MyAnimeList](https://myanimelist.net/), [AniList](https://anilist.co/), [Kitsu](https://kitsu.io/), [MangaUpdates](https://mangaupdates.com), [Shikimori](https://shikimori.one), and [Bangumi](https://bgm.tv/) support
 * Categories to organize your library
 * Light and dark themes
 * Schedule updating your library for new chapters
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@ -1,4 +1,6 @@
+import org.gradle.api.tasks.testing.logging.TestLogEvent
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.jmailen.gradle.kotlinter.tasks.LintTask

 plugins {
    id("com.android.application")
@ -6,6 +8,7 @@ plugins {
    kotlin("android")
    kotlin("plugin.serialization")
    id("com.github.zellius.shortcut-helper")
+    id("com.squareup.sqldelight")
 }

 if (gradle.startParameter.taskRequests.toString().contains("Standard")) {
@ -14,9 +17,10 @@ if (gradle.startParameter.taskRequests.toString().contains("Standard")) {

 shortcutHelper.setFilePath("./shortcuts.xml")

-val SUPPORTED_ABIS = setOf("armeabi-v7a", "arm64-v8a", "x86")
+val SUPPORTED_ABIS = setOf("armeabi-v7a", "arm64-v8a", "x86", "x86_64")

 android {
+    namespace = "eu.kanade.tachiyomi"
    compileSdk = AndroidConfig.compileSdk
    ndkVersion = AndroidConfig.ndk

@ -24,8 +28,8 @@ android {
        applicationId = "eu.kanade.tachiyomi"
        minSdk = AndroidConfig.minSdk
        targetSdk = AndroidConfig.targetSdk
-        versionCode = 79
-        versionName = "0.13.3"
+        versionCode = 93
+        versionName = "0.14.3"

        buildConfigField("String", "COMMIT_COUNT", "\"${getCommitCount()}\"")
        buildConfigField("String", "COMMIT_SHA", "\"${getGitSha()}\"")
@ -56,6 +60,7 @@ android {
        named("debug") {
            versionNameSuffix = "-${getCommitCount()}"
            applicationIdSuffix = ".debug"
+            isPseudoLocalesEnabled = true
        }
        named("release") {
            isShrinkResources = true
@ -70,11 +75,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")
@ -85,7 +101,8 @@ android {
            dimension = "default"
        }
        create("dev") {
-            resourceConfigurations.addAll(listOf("en", "xxhdpi"))
+            // Include pseudolocales: https://developer.android.com/guide/topics/resources/pseudolocales
+            resourceConfigurations.addAll(listOf("en", "en_XA", "ar_XB", "xxhdpi"))
            dimension = "default"
        }
    }
@ -99,7 +116,6 @@ android {
            "META-INF/README.md",
            "META-INF/NOTICE",
            "META-INF/*.kotlin_module",
-            "META-INF/*.version",
        ))
    }

@ -109,6 +125,7 @@ android {

    buildFeatures {
        viewBinding = true
+        compose = true

        // Disable some unused things
        aidl = false
@ -117,29 +134,70 @@ android {
    }

    lint {
-        disable.addAll(listOf("MissingTranslation", "ExtraTranslation"))
        abortOnError = false
        checkReleaseBuilds = false
    }

+    composeOptions {
+        kotlinCompilerExtensionVersion = compose.versions.compiler.get()
+    }
+
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
+
+        isCoreLibraryDesugaringEnabled = true
    }

    kotlinOptions {
        jvmTarget = JavaVersion.VERSION_1_8.toString()
    }
+
+    sqldelight {
+        database("Database") {
+            packageName = "eu.kanade.tachiyomi"
+            dialect = "sqlite:3.24"
+        }
+    }
 }

 dependencies {
+    implementation(project(":i18n"))
+    implementation(project(":core"))
+    implementation(project(":source-api"))
+
+    coreLibraryDesugaring(libs.desugar)
+
+    // Compose
+    implementation(platform(compose.bom))
+    implementation(compose.activity)
+    implementation(compose.foundation)
+    implementation(compose.material3.core)
+    implementation(compose.material.core)
+    implementation(compose.material.icons)
+    implementation(compose.animation)
+    implementation(compose.animation.graphics)
+    implementation(compose.ui.tooling)
+    implementation(compose.ui.util)
+    implementation(compose.accompanist.webview)
+    implementation(compose.accompanist.flowlayout)
+    implementation(compose.accompanist.permissions)
+    implementation(compose.accompanist.themeadapter)
+    implementation(compose.accompanist.systemuicontroller)
+
+    implementation(androidx.paging.runtime)
+    implementation(androidx.paging.compose)
+
+    implementation(libs.bundles.sqlite)
+    implementation(libs.sqldelight.android.driver)
+    implementation(libs.sqldelight.coroutines)
+    implementation(libs.sqldelight.android.paging)
+
    implementation(kotlinx.reflect)

+    implementation(platform(kotlinx.coroutines.bom))
    implementation(kotlinx.bundles.coroutines)

-    // Source models and interfaces from Tachiyomi 1.x
-    implementation(libs.tachiyomi.api)
-
    // AndroidX libraries
    implementation(androidx.annotation)
    implementation(androidx.appcompat)
@ -149,8 +207,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)

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

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

@ -182,24 +238,14 @@ dependencies {
    implementation(libs.unifile)
    implementation(libs.junrar)

-    // Database
-    implementation(libs.bundles.sqlite)
-    implementation("com.github.inorichi.storio:storio-common:8be19de@aar")
-    implementation("com.github.inorichi.storio:storio-sqlite:8be19de@aar")
-
    // Preferences
    implementation(libs.preferencektx)
-    implementation(libs.flowpreferences)
-
-    // Model View Presenter
-    implementation(libs.bundles.nucleus)

    // Dependency injection
    implementation(libs.injekt.core)

    // Image loading
    implementation(libs.bundles.coil)
-
    implementation(libs.subsamplingscaleimageview) {
        exclude(module = "image-decoder")
    }
@ -210,21 +256,19 @@ 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")
    }
    implementation(libs.insetter)
-
-    // Conductor
-    implementation(libs.bundles.conductor)
-
-    // FlowBinding
-    implementation(libs.bundles.flowbinding)
+    implementation(libs.bundles.richtext)
+    implementation(libs.aboutLibraries.compose)
+    implementation(libs.cascade)
+    implementation(libs.bundles.voyager)
+    implementation(libs.wheelpicker)
+    implementation(libs.materialmotion.core)

    // Logging
    implementation(libs.logcat)
@ -233,47 +277,79 @@ dependencies {
    implementation(libs.acra.http)
    "standardImplementation"(libs.firebase.analytics)

-    // Licenses
-    implementation(libs.aboutlibraries.core)
-
    // Shizuku
    implementation(libs.bundles.shizuku)

    // Tests
    testImplementation(libs.junit)
-    testImplementation(libs.assertj.core)
-    testImplementation(libs.mockito.core)
-
-    testImplementation(libs.bundles.robolectric)

    // For detecting memory leaks; see https://square.github.io/leakcanary/
    // debugImplementation(libs.leakcanary.android)
+    implementation(libs.leakcanary.plumber)
+}
+
+androidComponents {
+    beforeVariants { variantBuilder ->
+        // Disables standardBenchmark
+        if (variantBuilder.buildType == "benchmark") {
+            variantBuilder.enable = variantBuilder.productFlavors.containsAll(listOf("default" to "dev"))
+        }
+    }
+    onVariants(selector().withFlavor("default" to "standard")) {
+        // Only excluding in standard flavor because this breaks
+        // Layout Inspector's Compose tree
+        it.packaging.resources.excludes.add("META-INF/*.version")
+    }
 }

 tasks {
+    withType<Test> {
+        useJUnitPlatform()
+        testLogging {
+            events(TestLogEvent.PASSED, TestLogEvent.SKIPPED, TestLogEvent.FAILED)
+        }
+    }
+
+    withType<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(
-            "-Xopt-in=kotlin.Experimental",
-            "-Xopt-in=kotlin.RequiresOptIn",
-            "-Xopt-in=kotlin.ExperimentalStdlibApi",
-            "-Xopt-in=kotlinx.coroutines.FlowPreview",
-            "-Xopt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
-            "-Xopt-in=kotlinx.coroutines.InternalCoroutinesApi",
-            "-Xopt-in=kotlinx.serialization.ExperimentalSerializationApi",
-            "-Xopt-in=coil.annotation.ExperimentalCoilApi",
+            "-opt-in=coil.annotation.ExperimentalCoilApi",
+            "-opt-in=com.google.accompanist.permissions.ExperimentalPermissionsApi",
+            "-opt-in=androidx.compose.foundation.layout.ExperimentalLayoutApi",
+            "-opt-in=androidx.compose.material.ExperimentalMaterialApi",
+            "-opt-in=androidx.compose.material3.ExperimentalMaterial3Api",
+            "-opt-in=androidx.compose.material.ExperimentalMaterialApi",
+            "-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=kotlinx.coroutines.ExperimentalCoroutinesApi",
+            "-opt-in=kotlinx.coroutines.FlowPreview",
+            "-opt-in=kotlinx.coroutines.InternalCoroutinesApi",
+            "-opt-in=kotlinx.serialization.ExperimentalSerializationApi",
        )
-    }

-    // 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("**/*")
+        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"
+            )
+        }
    }

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

--- a/app/proguard-android-optimize.txt
+++ b/app/proguard-android-optimize.txt
@ -1,4 +1,3 @@
-allowaccessmodification
 -dontusemixedcaseclassnames
 -verbose

--- a/app/proguard-rules.pro
+++ b/app/proguard-rules.pro
@ -1,20 +1,25 @@
 -dontobfuscate

-# Keep extension's common dependencies
-keep,allowoptimization class eu.kanade.tachiyomi.** { public protected *; }
-keep,allowoptimization class androidx.preference.** { *; }
+# Keep common dependencies used in extensions
+-keep,allowoptimization class androidx.preference.** { public protected *; }
 -keep,allowoptimization class kotlin.** { public protected *; }
 -keep,allowoptimization class kotlinx.coroutines.** { public protected *; }
+-keep,allowoptimization class kotlinx.serialization.** { public protected *; }
 -keep,allowoptimization class okhttp3.** { public protected *; }
 -keep,allowoptimization class okio.** { public protected *; }
 -keep,allowoptimization class rx.** { public protected *; }
 -keep,allowoptimization class org.jsoup.** { public protected *; }
-keep,allowoptimization class com.google.gson.** { public protected *; }
-keep,allowoptimization class com.github.salomonbrys.kotson.** { 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 *; }

+# 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.**

@ -34,30 +39,6 @@
 -dontnote rx.internal.util.PlatformDependent
 ##---------------End: proguard configuration for RxJava 1.x  ----------

-##---------------Begin: proguard configuration for Gson  ----------
-# Gson uses generic type information stored in a class file when working with fields. Proguard
-# removes such information by default, so configure it to keep all of it.
-keepattributes Signature
-
-# For using GSON @Expose annotation
-keepattributes *Annotation*
-
-# Gson specific classes
-dontwarn sun.misc.**
-
-# Prevent proguard from stripping interface information from TypeAdapter, TypeAdapterFactory,
-# JsonSerializer, JsonDeserializer instances (so they can be used in @JsonAdapter)
-keep class * extends com.google.gson.TypeAdapter
-keep class * implements com.google.gson.TypeAdapterFactory
-keep class * implements com.google.gson.JsonSerializer
-keep class * implements com.google.gson.JsonDeserializer
-
-# Prevent R8 from leaving Data object members always null
-keepclassmembers,allowobfuscation class * {
-  @com.google.gson.annotations.SerializedName <fields>;
-}
-##---------------End: proguard configuration for Gson  ----------
-
 ##---------------Begin: proguard configuration for kotlinx.serialization  ----------
 -keepattributes *Annotation*, InnerClasses
 -dontnote kotlinx.serialization.AnnotationsKt # core serialization annotations
@ -70,11 +51,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(...);
 }

@ -83,3 +64,6 @@
    <methods>;
 }
 ##---------------End: proguard configuration for kotlinx.serialization  ----------
+
+# XmlUtil
+-keep public enum nl.adaptivity.xmlutil.EventType { *; }
--- a/app/src/debug/res/mipmap-anydpi-v26/ic_launcher.xml
+++ b/app/src/debug/res/mipmap-anydpi-v26/ic_launcher.xml
@ -2,4 +2,5 @@
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
    <background android:drawable="@android:color/transparent"/>
    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+    <monochrome android:drawable="@drawable/ic_tachi_monochrome_launcher" />
 </adaptive-icon>
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="eu.kanade.tachiyomi">
+    xmlns:tools="http://schemas.android.com/tools">

    <!-- Internet -->
    <uses-permission android:name="android.permission.INTERNET" />
@ -22,6 +22,13 @@
    <!-- To view extension packages in API 30+ -->
    <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES" />

+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.READ_APP_SPECIFIC_LOCALES" />
+
+    <!-- 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 +36,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 +62,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"
@ -168,6 +187,20 @@
            android:name=".data.notification.NotificationReceiver"
            android:exported="false" />

+        <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" />
@ -187,6 +220,15 @@
        <service android:name=".extension.util.ExtensionInstallService"
            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"
            android:authorities="${applicationId}.provider"
@ -205,11 +247,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
@ -0,0 +1,38 @@
+package eu.kanade.core.prefs
+
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import eu.kanade.tachiyomi.core.preference.Preference
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+
+class PreferenceMutableState<T>(
+    private val preference: Preference<T>,
+    scope: CoroutineScope,
+) : MutableState<T> {
+
+    private val state = mutableStateOf(preference.get())
+
+    init {
+        preference.changes()
+            .onEach { state.value = it }
+            .launchIn(scope)
+    }
+
+    override var value: T
+        get() = state.value
+        set(value) {
+            preference.set(value)
+        }
+
+    override fun component1(): T {
+        return state.value
+    }
+
+    override fun component2(): (T) -> Unit {
+        return { preference.set(it) }
+    }
+}
+
+fun <T> Preference<T>.asState(scope: CoroutineScope) = PreferenceMutableState(this, scope)
--- a/app/src/main/java/eu/kanade/core/util/CollectionUtils.kt
+++ b/app/src/main/java/eu/kanade/core/util/CollectionUtils.kt
@ -0,0 +1,148 @@
+package eu.kanade.core.util
+
+import androidx.compose.ui.util.fastForEach
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.contract
+
+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
+}
+
+/**
+ * Returns a new map containing only the key entries of [transform] that are not null.
+ */
+inline fun <K, V, R> Map<out K, V>.mapNotNullKeys(transform: (Map.Entry<K?, V>) -> R?): ConcurrentHashMap<R, V> {
+    val mutableMap = ConcurrentHashMap<R, V>()
+    forEach { element -> transform(element)?.let { mutableMap[it] = element.value } }
+    return mutableMap
+}
+
+fun <E> HashSet<E>.addOrRemove(value: E, shouldAdd: Boolean) {
+    if (shouldAdd) {
+        add(value)
+    } else {
+        remove(value)
+    }
+}
+
+/**
+ * Returns a list containing only elements matching the given [predicate].
+ *
+ * **Do not use for collections that come from public APIs**, since they may not support random
+ * access in an efficient way, and this method may actually be a lot slower. Only use for
+ * collections that are created by code we control and are known to support random access.
+ */
+@OptIn(ExperimentalContracts::class)
+inline fun <T> List<T>.fastFilter(predicate: (T) -> Boolean): List<T> {
+    contract { callsInPlace(predicate) }
+    val destination = ArrayList<T>()
+    fastForEach { if (predicate(it)) destination.add(it) }
+    return destination
+}
+
+/**
+ * Returns a list containing all elements not matching the given [predicate].
+ *
+ * **Do not use for collections that come from public APIs**, since they may not support random
+ * access in an efficient way, and this method may actually be a lot slower. Only use for
+ * collections that are created by code we control and are known to support random access.
+ */
+@OptIn(ExperimentalContracts::class)
+inline fun <T> List<T>.fastFilterNot(predicate: (T) -> Boolean): List<T> {
+    contract { callsInPlace(predicate) }
+    val destination = ArrayList<T>()
+    fastForEach { if (!predicate(it)) destination.add(it) }
+    return destination
+}
+
+/**
+ * Returns a list containing only the non-null results of applying the
+ * given [transform] function to each element in the original collection.
+ *
+ * **Do not use for collections that come from public APIs**, since they may not support random
+ * access in an efficient way, and this method may actually be a lot slower. Only use for
+ * collections that are created by code we control and are known to support random access.
+ */
+@OptIn(ExperimentalContracts::class)
+inline fun <T, R> List<T>.fastMapNotNull(transform: (T) -> R?): List<R> {
+    contract { callsInPlace(transform) }
+    val destination = ArrayList<R>()
+    fastForEach { element ->
+        transform(element)?.let { destination.add(it) }
+    }
+    return destination
+}
+
+/**
+ * Splits the original collection into pair of lists,
+ * where *first* list contains elements for which [predicate] yielded `true`,
+ * while *second* list contains elements for which [predicate] yielded `false`.
+ *
+ * **Do not use for collections that come from public APIs**, since they may not support random
+ * access in an efficient way, and this method may actually be a lot slower. Only use for
+ * collections that are created by code we control and are known to support random access.
+ */
+@OptIn(ExperimentalContracts::class)
+inline fun <T> List<T>.fastPartition(predicate: (T) -> Boolean): Pair<List<T>, List<T>> {
+    contract { callsInPlace(predicate) }
+    val first = ArrayList<T>()
+    val second = ArrayList<T>()
+    fastForEach {
+        if (predicate(it)) {
+            first.add(it)
+        } else {
+            second.add(it)
+        }
+    }
+    return Pair(first, second)
+}
+
+/**
+ * Returns the number of entries not matching the given [predicate].
+ *
+ * **Do not use for collections that come from public APIs**, since they may not support random
+ * access in an efficient way, and this method may actually be a lot slower. Only use for
+ * collections that are created by code we control and are known to support random access.
+ */
+@OptIn(ExperimentalContracts::class)
+inline fun <T> List<T>.fastCountNot(predicate: (T) -> Boolean): Int {
+    contract { callsInPlace(predicate) }
+    var count = size
+    fastForEach { if (predicate(it)) --count }
+    return count
+}
+
+/**
+ * Returns a list containing only elements from the given collection
+ * having distinct keys returned by the given [selector] function.
+ *
+ * Among elements of the given collection with equal keys, only the first one will be present in the resulting list.
+ * The elements in the resulting list are in the same order as they were in the source collection.
+ *
+ * **Do not use for collections that come from public APIs**, since they may not support random
+ * access in an efficient way, and this method may actually be a lot slower. Only use for
+ * collections that are created by code we control and are known to support random access.
+ */
+@OptIn(ExperimentalContracts::class)
+inline fun <T, K> List<T>.fastDistinctBy(selector: (T) -> K): List<T> {
+    contract { callsInPlace(selector) }
+    val set = HashSet<K>()
+    val list = ArrayList<T>()
+    fastForEach {
+        val key = selector(it)
+        if (set.add(key)) list.add(it)
+    }
+    return list
+}
--- a/app/src/main/java/eu/kanade/core/util/DurationUtils.kt
+++ b/app/src/main/java/eu/kanade/core/util/DurationUtils.kt
@ -0,0 +1,16 @@
+package eu.kanade.core.util
+
+import android.content.Context
+import eu.kanade.tachiyomi.R
+import kotlin.time.Duration
+
+fun Duration.toDurationString(context: Context, fallback: String): String {
+    return toComponents { days, hours, minutes, seconds, _ ->
+        buildList(4) {
+            if (days != 0L) add(context.getString(R.string.day_short, days))
+            if (hours != 0) add(context.getString(R.string.hour_short, hours))
+            if (minutes != 0 && (days == 0L || hours == 0)) add(context.getString(R.string.minute_short, minutes))
+            if (seconds != 0 && days == 0L && hours == 0) add(context.getString(R.string.seconds_short, seconds))
+        }.joinToString(" ").ifBlank { fallback }
+    }
+}
--- a/app/src/main/java/eu/kanade/core/util/RxJavaExtensions.kt
+++ b/app/src/main/java/eu/kanade/core/util/RxJavaExtensions.kt
@ -0,0 +1,61 @@
+package eu.kanade.core.util
+
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.launch
+import rx.Emitter
+import rx.Observable
+import rx.Observer
+import kotlin.coroutines.CoroutineContext
+
+fun <T : Any> Observable<T>.asFlow(): Flow<T> = callbackFlow {
+    val observer = object : Observer<T> {
+        override fun onNext(t: T) {
+            trySend(t)
+        }
+
+        override fun onError(e: Throwable) {
+            close(e)
+        }
+
+        override fun onCompleted() {
+            close()
+        }
+    }
+    val subscription = subscribe(observer)
+    awaitClose { subscription.unsubscribe() }
+}
+
+fun <T : Any> Flow<T>.asObservable(
+    context: CoroutineContext = Dispatchers.Unconfined,
+    backpressureMode: Emitter.BackpressureMode = Emitter.BackpressureMode.NONE,
+): Observable<T> {
+    return Observable.create(
+        { emitter ->
+            /*
+             * ATOMIC is used here to provide stable behaviour of subscribe+dispose pair even if
+             * asObservable is already invoked from unconfined
+             */
+            val job = GlobalScope.launch(context = context, start = CoroutineStart.ATOMIC) {
+                try {
+                    collect { emitter.onNext(it) }
+                    emitter.onCompleted()
+                } catch (e: Throwable) {
+                    // Ignore `CancellationException` as error, since it indicates "normal cancellation"
+                    if (e !is CancellationException) {
+                        emitter.onError(e)
+                    } else {
+                        emitter.onCompleted()
+                    }
+                }
+            }
+            emitter.setCancellation { job.cancel() }
+        },
+        backpressureMode,
+    )
+}
--- a/app/src/main/java/eu/kanade/data/AndroidDatabaseHandler.kt
+++ b/app/src/main/java/eu/kanade/data/AndroidDatabaseHandler.kt
@ -0,0 +1,90 @@
+package eu.kanade.data
+
+import androidx.paging.PagingSource
+import com.squareup.sqldelight.Query
+import com.squareup.sqldelight.db.SqlDriver
+import com.squareup.sqldelight.runtime.coroutines.asFlow
+import com.squareup.sqldelight.runtime.coroutines.mapToList
+import com.squareup.sqldelight.runtime.coroutines.mapToOne
+import com.squareup.sqldelight.runtime.coroutines.mapToOneOrNull
+import eu.kanade.tachiyomi.Database
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.withContext
+
+class AndroidDatabaseHandler(
+    val db: Database,
+    private val driver: SqlDriver,
+    val queryDispatcher: CoroutineDispatcher = Dispatchers.IO,
+    val transactionDispatcher: CoroutineDispatcher = queryDispatcher,
+) : DatabaseHandler {
+
+    val suspendingTransactionId = ThreadLocal<Int>()
+
+    override suspend fun <T> await(inTransaction: Boolean, block: suspend Database.() -> T): T {
+        return dispatch(inTransaction, block)
+    }
+
+    override suspend fun <T : Any> awaitList(
+        inTransaction: Boolean,
+        block: suspend Database.() -> Query<T>,
+    ): List<T> {
+        return dispatch(inTransaction) { block(db).executeAsList() }
+    }
+
+    override suspend fun <T : Any> awaitOne(
+        inTransaction: Boolean,
+        block: suspend Database.() -> Query<T>,
+    ): T {
+        return dispatch(inTransaction) { block(db).executeAsOne() }
+    }
+
+    override suspend fun <T : Any> awaitOneOrNull(
+        inTransaction: Boolean,
+        block: suspend Database.() -> Query<T>,
+    ): T? {
+        return dispatch(inTransaction) { block(db).executeAsOneOrNull() }
+    }
+
+    override fun <T : Any> subscribeToList(block: Database.() -> Query<T>): Flow<List<T>> {
+        return block(db).asFlow().mapToList(queryDispatcher)
+    }
+
+    override fun <T : Any> subscribeToOne(block: Database.() -> Query<T>): Flow<T> {
+        return block(db).asFlow().mapToOne(queryDispatcher)
+    }
+
+    override fun <T : Any> subscribeToOneOrNull(block: Database.() -> Query<T>): Flow<T?> {
+        return block(db).asFlow().mapToOneOrNull(queryDispatcher)
+    }
+
+    override fun <T : Any> subscribeToPagingSource(
+        countQuery: Database.() -> Query<Long>,
+        queryProvider: Database.(Long, Long) -> Query<T>,
+    ): PagingSource<Long, T> {
+        return QueryPagingSource(
+            handler = this,
+            countQuery = countQuery,
+            queryProvider = { limit, offset ->
+                queryProvider.invoke(db, limit, offset)
+            },
+        )
+    }
+
+    private suspend fun <T> dispatch(inTransaction: Boolean, block: suspend Database.() -> T): T {
+        // Create a transaction if needed and run the calling block inside it.
+        if (inTransaction) {
+            return withTransaction { block(db) }
+        }
+
+        // If we're currently in the transaction thread, there's no need to dispatch our query.
+        if (driver.currentTransaction() != null) {
+            return block(db)
+        }
+
+        // Get the current database context and run the calling block.
+        val context = getCurrentDatabaseContext()
+        return withContext(context) { block(db) }
+    }
+}
--- a/app/src/main/java/eu/kanade/data/DatabaseAdapter.kt
+++ b/app/src/main/java/eu/kanade/data/DatabaseAdapter.kt
@ -0,0 +1,30 @@
+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> {
+    override fun decode(databaseValue: Long): Date = Date(databaseValue)
+    override fun encode(value: Date): Long = value.time
+}
+
+private const val listOfStringsSeparator = ", "
+val listOfStringsAdapter = object : ColumnAdapter<List<String>, String> {
+    override fun decode(databaseValue: String) =
+        if (databaseValue.isEmpty()) {
+            emptyList()
+        } else {
+            databaseValue.split(listOfStringsSeparator)
+        }
+    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/DatabaseHandler.kt
+++ b/app/src/main/java/eu/kanade/data/DatabaseHandler.kt
@ -0,0 +1,37 @@
+package eu.kanade.data
+
+import androidx.paging.PagingSource
+import com.squareup.sqldelight.Query
+import eu.kanade.tachiyomi.Database
+import kotlinx.coroutines.flow.Flow
+
+interface DatabaseHandler {
+
+    suspend fun <T> await(inTransaction: Boolean = false, block: suspend Database.() -> T): T
+
+    suspend fun <T : Any> awaitList(
+        inTransaction: Boolean = false,
+        block: suspend Database.() -> Query<T>,
+    ): List<T>
+
+    suspend fun <T : Any> awaitOne(
+        inTransaction: Boolean = false,
+        block: suspend Database.() -> Query<T>,
+    ): T
+
+    suspend fun <T : Any> awaitOneOrNull(
+        inTransaction: Boolean = false,
+        block: suspend Database.() -> Query<T>,
+    ): T?
+
+    fun <T : Any> subscribeToList(block: Database.() -> Query<T>): Flow<List<T>>
+
+    fun <T : Any> subscribeToOne(block: Database.() -> Query<T>): Flow<T>
+
+    fun <T : Any> subscribeToOneOrNull(block: Database.() -> Query<T>): Flow<T?>
+
+    fun <T : Any> subscribeToPagingSource(
+        countQuery: Database.() -> Query<Long>,
+        queryProvider: Database.(Long, Long) -> Query<T>,
+    ): PagingSource<Long, T>
+}
--- a/app/src/main/java/eu/kanade/data/QueryPagingSource.kt
+++ b/app/src/main/java/eu/kanade/data/QueryPagingSource.kt
@ -0,0 +1,72 @@
+package eu.kanade.data
+
+import androidx.paging.PagingSource
+import androidx.paging.PagingState
+import com.squareup.sqldelight.Query
+import eu.kanade.tachiyomi.Database
+import kotlin.properties.Delegates
+
+class QueryPagingSource<RowType : Any>(
+    val handler: DatabaseHandler,
+    val countQuery: Database.() -> Query<Long>,
+    val queryProvider: Database.(Long, Long) -> Query<RowType>,
+) : PagingSource<Long, RowType>(), Query.Listener {
+
+    override val jumpingSupported: Boolean = true
+
+    private var currentQuery: Query<RowType>? by Delegates.observable(null) { _, old, new ->
+        old?.removeListener(this)
+        new?.addListener(this)
+    }
+
+    init {
+        registerInvalidatedCallback {
+            currentQuery?.removeListener(this)
+            currentQuery = null
+        }
+    }
+
+    override suspend fun load(params: LoadParams<Long>): LoadResult<Long, RowType> {
+        try {
+            val key = params.key ?: 0L
+            val loadSize = params.loadSize
+            val count = handler.awaitOne { countQuery() }
+
+            val (offset, limit) = when (params) {
+                is LoadParams.Prepend -> key - loadSize to loadSize.toLong()
+                else -> key to loadSize.toLong()
+            }
+
+            val data = handler.awaitList {
+                queryProvider(limit, offset)
+                    .also { currentQuery = it }
+            }
+
+            val (prevKey, nextKey) = when (params) {
+                is LoadParams.Append -> { offset - loadSize to offset + loadSize }
+                else -> { offset to offset + loadSize }
+            }
+
+            return LoadResult.Page(
+                data = data,
+                prevKey = if (offset <= 0L || prevKey < 0L) null else prevKey,
+                nextKey = if (offset + loadSize >= count) null else nextKey,
+                itemsBefore = maxOf(0L, offset).toInt(),
+                itemsAfter = maxOf(0L, count - (offset + loadSize)).toInt(),
+            )
+        } catch (e: Exception) {
+            return LoadResult.Error(throwable = e)
+        }
+    }
+
+    override fun getRefreshKey(state: PagingState<Long, RowType>): Long? {
+        return state.anchorPosition?.let { anchorPosition ->
+            val anchorPage = state.closestPageToPosition(anchorPosition)
+            anchorPage?.prevKey ?: anchorPage?.nextKey
+        }
+    }
+
+    override fun queryResultsChanged() {
+        invalidate()
+    }
+}
--- a/app/src/main/java/eu/kanade/data/TransactionContext.kt
+++ b/app/src/main/java/eu/kanade/data/TransactionContext.kt
@ -0,0 +1,161 @@
+package eu.kanade.data
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.asContextElement
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+import java.util.concurrent.RejectedExecutionException
+import java.util.concurrent.atomic.AtomicInteger
+import kotlin.coroutines.ContinuationInterceptor
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.EmptyCoroutineContext
+import kotlin.coroutines.coroutineContext
+import kotlin.coroutines.resume
+
+/**
+ * Returns the transaction dispatcher if we are on a transaction, or the database dispatchers.
+ */
+internal suspend fun AndroidDatabaseHandler.getCurrentDatabaseContext(): CoroutineContext {
+    return coroutineContext[TransactionElement]?.transactionDispatcher ?: queryDispatcher
+}
+
+/**
+ * Calls the specified suspending [block] in a database transaction. The transaction will be
+ * marked as successful unless an exception is thrown in the suspending [block] or the coroutine
+ * is cancelled.
+ *
+ * SQLDelight will only perform at most one transaction at a time, additional transactions are queued
+ * and executed on a first come, first serve order.
+ *
+ * Performing blocking database operations is not permitted in a coroutine scope other than the
+ * one received by the suspending block. It is recommended that all [Dao] function invoked within
+ * the [block] be suspending functions.
+ *
+ * The dispatcher used to execute the given [block] will utilize threads from SQLDelight's query executor.
+ */
+internal suspend fun <T> AndroidDatabaseHandler.withTransaction(block: suspend () -> T): T {
+    // Use inherited transaction context if available, this allows nested suspending transactions.
+    val transactionContext =
+        coroutineContext[TransactionElement]?.transactionDispatcher ?: createTransactionContext()
+    return withContext(transactionContext) {
+        val transactionElement = coroutineContext[TransactionElement]!!
+        transactionElement.acquire()
+        try {
+            db.transactionWithResult {
+                runBlocking(transactionContext) {
+                    block()
+                }
+            }
+        } finally {
+            transactionElement.release()
+        }
+    }
+}
+
+/**
+ * Creates a [CoroutineContext] for performing database operations within a coroutine transaction.
+ *
+ * The context is a combination of a dispatcher, a [TransactionElement] and a thread local element.
+ *
+ * * The dispatcher will dispatch coroutines to a single thread that is taken over from the SQLDelight
+ * query executor. If the coroutine context is switched, suspending DAO functions will be able to
+ * dispatch to the transaction thread.
+ *
+ * * The [TransactionElement] serves as an indicator for inherited context, meaning, if there is a
+ * switch of context, suspending DAO methods will be able to use the indicator to dispatch the
+ * database operation to the transaction thread.
+ *
+ * * The thread local element serves as a second indicator and marks threads that are used to
+ * execute coroutines within the coroutine transaction, more specifically it allows us to identify
+ * if a blocking DAO method is invoked within the transaction coroutine. Never assign meaning to
+ * this value, for now all we care is if its present or not.
+ */
+private suspend fun AndroidDatabaseHandler.createTransactionContext(): CoroutineContext {
+    val controlJob = Job()
+    // make sure to tie the control job to this context to avoid blocking the transaction if
+    // context get cancelled before we can even start using this job. Otherwise, the acquired
+    // transaction thread will forever wait for the controlJob to be cancelled.
+    // see b/148181325
+    coroutineContext[Job]?.invokeOnCompletion {
+        controlJob.cancel()
+    }
+
+    val dispatcher = transactionDispatcher.acquireTransactionThread(controlJob)
+    val transactionElement = TransactionElement(controlJob, dispatcher)
+    val threadLocalElement =
+        suspendingTransactionId.asContextElement(System.identityHashCode(controlJob))
+    return dispatcher + transactionElement + threadLocalElement
+}
+
+/**
+ * Acquires a thread from the executor and returns a [ContinuationInterceptor] to dispatch
+ * coroutines to the acquired thread. The [controlJob] is used to control the release of the
+ * thread by cancelling the job.
+ */
+private suspend fun CoroutineDispatcher.acquireTransactionThread(
+    controlJob: Job,
+): ContinuationInterceptor {
+    return suspendCancellableCoroutine { continuation ->
+        continuation.invokeOnCancellation {
+            // We got cancelled while waiting to acquire a thread, we can't stop our attempt to
+            // acquire a thread, but we can cancel the controlling job so once it gets acquired it
+            // is quickly released.
+            controlJob.cancel()
+        }
+        try {
+            dispatch(EmptyCoroutineContext) {
+                runBlocking {
+                    // Thread acquired, resume coroutine
+                    continuation.resume(coroutineContext[ContinuationInterceptor]!!)
+                    controlJob.join()
+                }
+            }
+        } catch (ex: RejectedExecutionException) {
+            // Couldn't acquire a thread, cancel coroutine
+            continuation.cancel(
+                IllegalStateException(
+                    "Unable to acquire a thread to perform the database transaction",
+                    ex,
+                ),
+            )
+        }
+    }
+}
+
+/**
+ * A [CoroutineContext.Element] that indicates there is an on-going database transaction.
+ */
+private class TransactionElement(
+    private val transactionThreadControlJob: Job,
+    val transactionDispatcher: ContinuationInterceptor,
+) : CoroutineContext.Element {
+
+    companion object Key : CoroutineContext.Key<TransactionElement>
+
+    override val key: CoroutineContext.Key<TransactionElement>
+        get() = TransactionElement
+
+    /**
+     * Number of transactions (including nested ones) started with this element.
+     * Call [acquire] to increase the count and [release] to decrease it. If the count reaches zero
+     * when [release] is invoked then the transaction job is cancelled and the transaction thread
+     * is released.
+     */
+    private val referenceCount = AtomicInteger(0)
+
+    fun acquire() {
+        referenceCount.incrementAndGet()
+    }
+
+    fun release() {
+        val count = referenceCount.decrementAndGet()
+        if (count < 0) {
+            throw IllegalStateException("Transaction was never started or was already released")
+        } else if (count == 0) {
+            // Cancel the job that controls the transaction thread, causing it to be released.
+            transactionThreadControlJob.cancel()
+        }
+    }
+}
--- a/app/src/main/java/eu/kanade/data/category/CategoryMapper.kt
+++ b/app/src/main/java/eu/kanade/data/category/CategoryMapper.kt
@ -0,0 +1,12 @@
+package eu.kanade.data.category
+
+import eu.kanade.domain.category.model.Category
+
+val categoryMapper: (Long, String, Long, Long) -> Category = { id, name, order, flags ->
+    Category(
+        id = id,
+        name = name,
+        order = order,
+        flags = flags,
+    )
+}
--- a/app/src/main/java/eu/kanade/data/category/CategoryRepositoryImpl.kt
+++ b/app/src/main/java/eu/kanade/data/category/CategoryRepositoryImpl.kt
@ -0,0 +1,84 @@
+package eu.kanade.data.category
+
+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.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) }
+    }
+
+    override fun getAllAsFlow(): Flow<List<Category>> {
+        return handler.subscribeToList { categoriesQueries.getCategories(categoryMapper) }
+    }
+
+    override suspend fun getCategoriesByMangaId(mangaId: Long): List<Category> {
+        return handler.awaitList {
+            categoriesQueries.getCategoriesByMangaId(mangaId, categoryMapper)
+        }
+    }
+
+    override fun getCategoriesByMangaIdAsFlow(mangaId: Long): Flow<List<Category>> {
+        return handler.subscribeToList {
+            categoriesQueries.getCategoriesByMangaId(mangaId, categoryMapper)
+        }
+    }
+
+    override suspend fun insert(category: Category) {
+        handler.await {
+            categoriesQueries.insert(
+                name = category.name,
+                order = category.order,
+                flags = category.flags,
+            )
+        }
+    }
+
+    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 = 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) {
+        handler.await {
+            categoriesQueries.delete(
+                categoryId = categoryId,
+            )
+        }
+    }
+}
--- a/app/src/main/java/eu/kanade/data/chapter/ChapterMapper.kt
+++ b/app/src/main/java/eu/kanade/data/chapter/ChapterMapper.kt
@ -0,0 +1,21 @@
+package eu.kanade.data.chapter
+
+import eu.kanade.domain.chapter.model.Chapter
+
+val chapterMapper: (Long, Long, String, String, String?, Boolean, Boolean, Long, Float, Long, Long, Long) -> Chapter =
+    { id, mangaId, url, name, scanlator, read, bookmark, lastPageRead, chapterNumber, sourceOrder, dateFetch, dateUpload ->
+        Chapter(
+            id = id,
+            mangaId = mangaId,
+            read = read,
+            bookmark = bookmark,
+            lastPageRead = lastPageRead,
+            dateFetch = dateFetch,
+            sourceOrder = sourceOrder,
+            url = url,
+            name = name,
+            dateUpload = dateUpload,
+            chapterNumber = chapterNumber,
+            scanlator = scanlator,
+        )
+    }
--- a/app/src/main/java/eu/kanade/data/chapter/ChapterRepositoryImpl.kt
+++ b/app/src/main/java/eu/kanade/data/chapter/ChapterRepositoryImpl.kt
@ -0,0 +1,99 @@
+package eu.kanade.data.chapter
+
+import eu.kanade.data.DatabaseHandler
+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
+
+class ChapterRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : ChapterRepository {
+
+    override suspend fun addAll(chapters: List<Chapter>): List<Chapter> {
+        return try {
+            handler.await(inTransaction = true) {
+                chapters.map { chapter ->
+                    chaptersQueries.insert(
+                        chapter.mangaId,
+                        chapter.url,
+                        chapter.name,
+                        chapter.scanlator,
+                        chapter.read,
+                        chapter.bookmark,
+                        chapter.lastPageRead,
+                        chapter.chapterNumber,
+                        chapter.sourceOrder,
+                        chapter.dateFetch,
+                        chapter.dateUpload,
+                    )
+                    val lastInsertId = chaptersQueries.selectLastInsertedRowId().executeAsOne()
+                    chapter.copy(id = lastInsertId)
+                }
+            }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            emptyList()
+        }
+    }
+
+    override suspend fun update(chapterUpdate: ChapterUpdate) {
+        partialUpdate(chapterUpdate)
+    }
+
+    override suspend fun updateAll(chapterUpdates: List<ChapterUpdate>) {
+        partialUpdate(*chapterUpdates.toTypedArray())
+    }
+
+    private suspend fun partialUpdate(vararg chapterUpdates: ChapterUpdate) {
+        handler.await(inTransaction = true) {
+            chapterUpdates.forEach { chapterUpdate ->
+                chaptersQueries.update(
+                    mangaId = chapterUpdate.mangaId,
+                    url = chapterUpdate.url,
+                    name = chapterUpdate.name,
+                    scanlator = chapterUpdate.scanlator,
+                    read = chapterUpdate.read?.toLong(),
+                    bookmark = chapterUpdate.bookmark?.toLong(),
+                    lastPageRead = chapterUpdate.lastPageRead,
+                    chapterNumber = chapterUpdate.chapterNumber?.toDouble(),
+                    sourceOrder = chapterUpdate.sourceOrder,
+                    dateFetch = chapterUpdate.dateFetch,
+                    dateUpload = chapterUpdate.dateUpload,
+                    chapterId = chapterUpdate.id,
+                )
+            }
+        }
+    }
+
+    override suspend fun removeChaptersWithIds(chapterIds: List<Long>) {
+        try {
+            handler.await { chaptersQueries.removeChaptersWithIds(chapterIds) }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+        }
+    }
+
+    override suspend fun getChapterByMangaId(mangaId: Long): List<Chapter> {
+        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) }
+    }
+
+    override suspend fun getChapterByMangaIdAsFlow(mangaId: Long): Flow<List<Chapter>> {
+        return handler.subscribeToList { chaptersQueries.getChaptersByMangaId(mangaId, chapterMapper) }
+    }
+
+    override suspend fun getChapterByUrlAndMangaId(url: String, mangaId: Long): Chapter? {
+        return handler.awaitOneOrNull { chaptersQueries.getChapterByUrlAndMangaId(url, mangaId, 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/chapter/NoChaptersException.kt
+++ b/app/src/main/java/eu/kanade/data/chapter/NoChaptersException.kt
@ -0,0 +1,3 @@
+package eu.kanade.data.chapter
+
+class NoChaptersException : Exception()
--- a/app/src/main/java/eu/kanade/data/history/HistoryMapper.kt
+++ b/app/src/main/java/eu/kanade/data/history/HistoryMapper.kt
@ -0,0 +1,35 @@
+package eu.kanade.data.history
+
+import eu.kanade.domain.history.model.History
+import eu.kanade.domain.history.model.HistoryWithRelations
+import eu.kanade.domain.manga.model.MangaCover
+import java.util.Date
+
+val historyMapper: (Long, Long, Date?, Long) -> History = { id, chapterId, readAt, readDuration ->
+    History(
+        id = id,
+        chapterId = chapterId,
+        readAt = readAt,
+        readDuration = readDuration,
+    )
+}
+
+val historyWithRelationsMapper: (Long, Long, Long, String, String?, Long, Boolean, Long, Float, Date?, Long) -> HistoryWithRelations = {
+        historyId, mangaId, chapterId, title, thumbnailUrl, sourceId, isFavorite, coverLastModified, chapterNumber, readAt, readDuration ->
+    HistoryWithRelations(
+        id = historyId,
+        chapterId = chapterId,
+        mangaId = mangaId,
+        title = title,
+        chapterNumber = chapterNumber,
+        readAt = readAt,
+        readDuration = readDuration,
+        coverData = MangaCover(
+            mangaId = mangaId,
+            sourceId = sourceId,
+            isMangaFavorite = isFavorite,
+            url = thumbnailUrl,
+            lastModified = coverLastModified,
+        ),
+    )
+}
--- a/app/src/main/java/eu/kanade/data/history/HistoryRepositoryImpl.kt
+++ b/app/src/main/java/eu/kanade/data/history/HistoryRepositoryImpl.kt
@ -0,0 +1,70 @@
+package eu.kanade.data.history
+
+import eu.kanade.data.DatabaseHandler
+import eu.kanade.domain.history.model.HistoryUpdate
+import eu.kanade.domain.history.model.HistoryWithRelations
+import eu.kanade.domain.history.repository.HistoryRepository
+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): Flow<List<HistoryWithRelations>> {
+        return handler.subscribeToList {
+            historyViewQueries.history(query, historyWithRelationsMapper)
+        }
+    }
+
+    override suspend fun getLastHistory(): HistoryWithRelations? {
+        return handler.awaitOneOrNull {
+            historyViewQueries.getLatestHistory(historyWithRelationsMapper)
+        }
+    }
+
+    override suspend fun getTotalReadDuration(): Long {
+        return handler.awaitOne { historyQueries.getReadDuration() }
+    }
+
+    override suspend fun resetHistory(historyId: Long) {
+        try {
+            handler.await { historyQueries.resetHistoryById(historyId) }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, throwable = e)
+        }
+    }
+
+    override suspend fun resetHistoryByMangaId(mangaId: Long) {
+        try {
+            handler.await { historyQueries.resetHistoryByMangaId(mangaId) }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, throwable = e)
+        }
+    }
+
+    override suspend fun deleteAllHistory(): Boolean {
+        return try {
+            handler.await { historyQueries.removeAllHistory() }
+            true
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, throwable = e)
+            false
+        }
+    }
+
+    override suspend fun upsertHistory(historyUpdate: HistoryUpdate) {
+        try {
+            handler.await {
+                historyQueries.upsert(
+                    historyUpdate.chapterId,
+                    historyUpdate.readAt,
+                    historyUpdate.sessionReadDuration,
+                )
+            }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, throwable = e)
+        }
+    }
+}
--- a/app/src/main/java/eu/kanade/data/manga/MangaMapper.kt
+++ b/app/src/main/java/eu/kanade/data/manga/MangaMapper.kt
@ -0,0 +1,63 @@
+package eu.kanade.data.manga
+
+import eu.kanade.domain.library.model.LibraryManga
+import eu.kanade.domain.manga.model.Manga
+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, 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 = viewerFlags,
+            chapterFlags = chapterFlags,
+            coverLastModified = coverLastModified,
+            url = url,
+            title = title,
+            artist = artist,
+            author = author,
+            description = description,
+            genre = genre,
+            status = status,
+            thumbnailUrl = thumbnailUrl,
+            updateStrategy = updateStrategy,
+            initialized = initialized,
+        )
+    }
+
+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
@ -0,0 +1,148 @@
+package eu.kanade.data.manga
+
+import eu.kanade.data.DatabaseHandler
+import eu.kanade.data.listOfStringsAdapter
+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.util.system.logcat
+import eu.kanade.tachiyomi.util.system.toLong
+import kotlinx.coroutines.flow.Flow
+import logcat.LogPriority
+
+class MangaRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : MangaRepository {
+
+    override suspend fun getMangaById(id: Long): Manga {
+        return handler.awaitOne { mangasQueries.getMangaById(id, mangaMapper) }
+    }
+
+    override suspend fun getMangaByIdAsFlow(id: Long): Flow<Manga> {
+        return handler.subscribeToOne { mangasQueries.getMangaById(id, mangaMapper) }
+    }
+
+    override suspend fun getMangaByUrlAndSourceId(url: String, sourceId: Long): Manga? {
+        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> {
+        return handler.awaitList { mangasQueries.getFavorites(mangaMapper) }
+    }
+
+    override suspend fun getLibraryManga(): List<LibraryManga> {
+        return handler.awaitList { libraryViewQueries.library(libraryManga) }
+    }
+
+    override fun getLibraryMangaAsFlow(): Flow<List<LibraryManga>> {
+        return handler.subscribeToList { libraryViewQueries.library(libraryManga) }
+    }
+
+    override fun getFavoritesBySourceId(sourceId: Long): Flow<List<Manga>> {
+        return handler.subscribeToList { mangasQueries.getFavoriteBySourceId(sourceId, mangaMapper) }
+    }
+
+    override suspend fun getDuplicateLibraryManga(title: String, sourceId: Long): Manga? {
+        return handler.awaitOneOrNull {
+            mangasQueries.getDuplicateLibraryManga(title, sourceId, mangaMapper)
+        }
+    }
+
+    override suspend fun resetViewerFlags(): Boolean {
+        return try {
+            handler.await { mangasQueries.resetViewerFlags() }
+            true
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            false
+        }
+    }
+
+    override suspend fun setMangaCategories(mangaId: Long, categoryIds: List<Long>) {
+        handler.await(inTransaction = true) {
+            mangas_categoriesQueries.deleteMangaCategoryByMangaId(mangaId)
+            categoryIds.map { categoryId ->
+                mangas_categoriesQueries.insert(mangaId, categoryId)
+            }
+        }
+    }
+
+    override suspend fun insert(manga: Manga): Long? {
+        return handler.awaitOneOrNull(inTransaction = true) {
+            mangasQueries.insert(
+                source = manga.source,
+                url = manga.url,
+                artist = manga.artist,
+                author = manga.author,
+                description = manga.description,
+                genre = manga.genre,
+                title = manga.title,
+                status = manga.status,
+                thumbnailUrl = manga.thumbnailUrl,
+                favorite = manga.favorite,
+                lastUpdate = manga.lastUpdate,
+                nextUpdate = null,
+                initialized = manga.initialized,
+                viewerFlags = manga.viewerFlags,
+                chapterFlags = manga.chapterFlags,
+                coverLastModified = manga.coverLastModified,
+                dateAdded = manga.dateAdded,
+                updateStrategy = manga.updateStrategy,
+            )
+            mangasQueries.selectLastInsertedRowId()
+        }
+    }
+
+    override suspend fun update(update: MangaUpdate): Boolean {
+        return try {
+            partialUpdate(update)
+            true
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            false
+        }
+    }
+
+    override suspend fun updateAll(mangaUpdates: List<MangaUpdate>): Boolean {
+        return try {
+            partialUpdate(*mangaUpdates.toTypedArray())
+            true
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            false
+        }
+    }
+
+    private suspend fun partialUpdate(vararg mangaUpdates: MangaUpdate) {
+        handler.await(inTransaction = true) {
+            mangaUpdates.forEach { value ->
+                mangasQueries.update(
+                    source = value.source,
+                    url = value.url,
+                    artist = value.artist,
+                    author = value.author,
+                    description = value.description,
+                    genre = value.genre?.let(listOfStringsAdapter::encode),
+                    title = value.title,
+                    status = value.status,
+                    thumbnailUrl = value.thumbnailUrl,
+                    favorite = value.favorite?.toLong(),
+                    lastUpdate = value.lastUpdate,
+                    initialized = value.initialized?.toLong(),
+                    viewer = value.viewerFlags,
+                    chapterFlags = value.chapterFlags,
+                    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/SourceMapper.kt
+++ b/app/src/main/java/eu/kanade/data/source/SourceMapper.kt
@ -0,0 +1,24 @@
+package eu.kanade.data.source
+
+import eu.kanade.domain.source.model.Source
+import eu.kanade.domain.source.model.SourceData
+import eu.kanade.tachiyomi.source.CatalogueSource
+import eu.kanade.tachiyomi.source.SourceManager
+
+val sourceMapper: (eu.kanade.tachiyomi.source.Source) -> Source = { source ->
+    Source(
+        source.id,
+        source.lang,
+        source.name,
+        supportsLatest = false,
+        isStub = source is SourceManager.StubSource,
+    )
+}
+
+val catalogueSourceMapper: (CatalogueSource) -> Source = { source ->
+    sourceMapper(source).copy(supportsLatest = source.supportsLatest)
+}
+
+val sourceDataMapper: (Long, String, String) -> SourceData = { id, lang, name ->
+    SourceData(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
@ -0,0 +1,74 @@
+package eu.kanade.data.source
+
+import eu.kanade.data.DatabaseHandler
+import eu.kanade.domain.source.model.Source
+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
+
+class SourceRepositoryImpl(
+    private val sourceManager: SourceManager,
+    private val handler: DatabaseHandler,
+) : SourceRepository {
+
+    override fun getSources(): Flow<List<Source>> {
+        return sourceManager.catalogueSources.map { sources ->
+            sources.map(catalogueSourceMapper)
+        }
+    }
+
+    override fun getOnlineSources(): Flow<List<Source>> {
+        return sourceManager.onlineSources.map { sources ->
+            sources.map(sourceMapper)
+        }
+    }
+
+    override fun getSourcesWithFavoriteCount(): Flow<List<Pair<Source, Long>>> {
+        val sourceIdWithFavoriteCount = handler.subscribeToList { mangasQueries.getSourceIdWithFavoriteCount() }
+        return sourceIdWithFavoriteCount.map { sourceIdsWithCount ->
+            sourceIdsWithCount
+                .filterNot { it.source == LocalSource.ID }
+                .map { (sourceId, count) ->
+                    val source = sourceManager.getOrStub(sourceId).run {
+                        sourceMapper(this)
+                    }
+                    source to count
+                }
+        }
+    }
+
+    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)
+                SourceWithCount(sourceMapper(source), count)
+            }
+        }
+    }
+
+    override fun search(
+        sourceId: Long,
+        query: String,
+        filterList: FilterList,
+    ): SourcePagingSourceType {
+        val source = sourceManager.get(sourceId) as CatalogueSource
+        return SourceSearchPagingSource(source, query, filterList)
+    }
+
+    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/TrackMapper.kt
+++ b/app/src/main/java/eu/kanade/data/track/TrackMapper.kt
@ -0,0 +1,22 @@
+package eu.kanade.data.track
+
+import eu.kanade.domain.track.model.Track
+
+val trackMapper: (Long, Long, Long, Long, Long?, String, Double, Long, Long, Float, String, Long, Long) -> Track =
+    { id, mangaId, syncId, remoteId, libraryId, title, lastChapterRead, totalChapters, status, score, remoteUrl, startDate, finishDate ->
+        Track(
+            id = id,
+            mangaId = mangaId,
+            syncId = syncId,
+            remoteId = remoteId,
+            libraryId = libraryId,
+            title = title,
+            lastChapterRead = lastChapterRead,
+            totalChapters = totalChapters,
+            status = status,
+            score = score,
+            remoteUrl = remoteUrl,
+            startDate = startDate,
+            finishDate = finishDate,
+        )
+    }
--- a/app/src/main/java/eu/kanade/data/track/TrackRepositoryImpl.kt
+++ b/app/src/main/java/eu/kanade/data/track/TrackRepositoryImpl.kt
@ -0,0 +1,71 @@
+package eu.kanade.data.track
+
+import eu.kanade.data.DatabaseHandler
+import eu.kanade.domain.track.model.Track
+import eu.kanade.domain.track.repository.TrackRepository
+import kotlinx.coroutines.flow.Flow
+
+class TrackRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : TrackRepository {
+
+    override suspend fun getTrackById(id: Long): Track? {
+        return handler.awaitOneOrNull { manga_syncQueries.getTrackById(id, trackMapper) }
+    }
+
+    override suspend fun getTracksByMangaId(mangaId: Long): List<Track> {
+        return handler.awaitList {
+            manga_syncQueries.getTracksByMangaId(mangaId, trackMapper)
+        }
+    }
+
+    override fun getTracksAsFlow(): Flow<List<Track>> {
+        return handler.subscribeToList {
+            manga_syncQueries.getTracks(trackMapper)
+        }
+    }
+
+    override fun getTracksByMangaIdAsFlow(mangaId: Long): Flow<List<Track>> {
+        return handler.subscribeToList {
+            manga_syncQueries.getTracksByMangaId(mangaId, trackMapper)
+        }
+    }
+
+    override suspend fun delete(mangaId: Long, syncId: Long) {
+        handler.await {
+            manga_syncQueries.delete(
+                mangaId = mangaId,
+                syncId = syncId,
+            )
+        }
+    }
+
+    override suspend fun insert(track: Track) {
+        insertValues(track)
+    }
+
+    override suspend fun insertAll(tracks: List<Track>) {
+        insertValues(*tracks.toTypedArray())
+    }
+
+    private suspend fun insertValues(vararg tracks: Track) {
+        handler.await(inTransaction = true) {
+            tracks.forEach { mangaTrack ->
+                manga_syncQueries.insert(
+                    mangaId = mangaTrack.mangaId,
+                    syncId = mangaTrack.syncId,
+                    remoteId = mangaTrack.remoteId,
+                    libraryId = mangaTrack.libraryId,
+                    title = mangaTrack.title,
+                    lastChapterRead = mangaTrack.lastChapterRead,
+                    totalChapters = mangaTrack.totalChapters,
+                    status = mangaTrack.status,
+                    score = mangaTrack.score,
+                    remoteUrl = mangaTrack.remoteUrl,
+                    startDate = mangaTrack.startDate,
+                    finishDate = mangaTrack.finishDate,
+                )
+            }
+        }
+    }
+}
--- 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
@ -0,0 +1,147 @@
+package eu.kanade.domain
+
+import eu.kanade.data.category.CategoryRepositoryImpl
+import eu.kanade.data.chapter.ChapterRepositoryImpl
+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.data.updates.UpdatesRepositoryImpl
+import eu.kanade.domain.category.interactor.CreateCategoryWithName
+import eu.kanade.domain.category.interactor.DeleteCategory
+import eu.kanade.domain.category.interactor.GetCategories
+import eu.kanade.domain.category.interactor.RenameCategory
+import eu.kanade.domain.category.interactor.ReorderCategory
+import eu.kanade.domain.category.interactor.ResetCategoryFlags
+import eu.kanade.domain.category.interactor.SetDisplayModeForCategory
+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.repository.CategoryRepository
+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
+import eu.kanade.domain.chapter.interactor.SyncChaptersWithTrackServiceTwoWay
+import eu.kanade.domain.chapter.interactor.UpdateChapter
+import eu.kanade.domain.chapter.repository.ChapterRepository
+import eu.kanade.domain.download.interactor.DeleteDownload
+import eu.kanade.domain.extension.interactor.GetExtensionLanguages
+import eu.kanade.domain.extension.interactor.GetExtensionSources
+import eu.kanade.domain.extension.interactor.GetExtensionsByType
+import eu.kanade.domain.history.interactor.GetHistory
+import eu.kanade.domain.history.interactor.GetNextChapters
+import eu.kanade.domain.history.interactor.GetTotalReadDuration
+import eu.kanade.domain.history.interactor.RemoveHistory
+import eu.kanade.domain.history.interactor.UpsertHistory
+import eu.kanade.domain.history.repository.HistoryRepository
+import eu.kanade.domain.manga.interactor.GetDuplicateLibraryManga
+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.NetworkToLocalManga
+import eu.kanade.domain.manga.interactor.ResetViewerFlags
+import eu.kanade.domain.manga.interactor.SetMangaChapterFlags
+import eu.kanade.domain.manga.interactor.SetMangaViewerFlags
+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.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.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
+import uy.kohesive.injekt.api.addSingletonFactory
+import uy.kohesive.injekt.api.get
+
+class DomainModule : InjektModule {
+
+    override fun InjektRegistrar.registerInjectables() {
+        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<MangaRepository> { MangaRepositoryImpl(get()) }
+        addFactory { GetDuplicateLibraryManga(get()) }
+        addFactory { GetFavorites(get()) }
+        addFactory { GetLibraryManga(get()) }
+        addFactory { GetMangaWithChapters(get(), get()) }
+        addFactory { GetManga(get()) }
+        addFactory { GetNextChapters(get(), get(), get()) }
+        addFactory { ResetViewerFlags(get()) }
+        addFactory { SetMangaChapterFlags(get()) }
+        addFactory { SetMangaDefaultChapterFlags(get(), get(), get()) }
+        addFactory { SetMangaViewerFlags(get()) }
+        addFactory { NetworkToLocalManga(get()) }
+        addFactory { UpdateManga(get()) }
+        addFactory { SetMangaCategories(get()) }
+
+        addSingletonFactory<TrackRepository> { TrackRepositoryImpl(get()) }
+        addFactory { DeleteTrack(get()) }
+        addFactory { GetTracksPerManga(get()) }
+        addFactory { GetTracks(get()) }
+        addFactory { InsertTrack(get()) }
+
+        addSingletonFactory<ChapterRepository> { ChapterRepositoryImpl(get()) }
+        addFactory { GetChapter(get()) }
+        addFactory { GetChapterByMangaId(get()) }
+        addFactory { UpdateChapter(get()) }
+        addFactory { SetReadStatus(get(), get(), get(), get()) }
+        addFactory { ShouldUpdateDbChapter() }
+        addFactory { SyncChaptersWithSource(get(), get(), get(), get()) }
+        addFactory { SyncChaptersWithTrackServiceTwoWay(get(), get()) }
+
+        addSingletonFactory<HistoryRepository> { HistoryRepositoryImpl(get()) }
+        addFactory { GetHistory(get()) }
+        addFactory { UpsertHistory(get()) }
+        addFactory { RemoveHistory(get()) }
+        addFactory { GetTotalReadDuration(get()) }
+
+        addFactory { DeleteDownload(get(), get()) }
+
+        addFactory { GetExtensionsByType(get(), get()) }
+        addFactory { GetExtensionSources(get()) }
+        addFactory { GetExtensionLanguages(get(), get()) }
+
+        addSingletonFactory<UpdatesRepository> { UpdatesRepositoryImpl(get()) }
+        addFactory { GetUpdates(get()) }
+
+        addSingletonFactory<SourceRepository> { SourceRepositoryImpl(get(), get()) }
+        addSingletonFactory<SourceDataRepository> { SourceDataRepositoryImpl(get()) }
+        addFactory { GetEnabledSources(get(), get()) }
+        addFactory { GetLanguagesWithSources(get(), get()) }
+        addFactory { GetRemoteManga(get()) }
+        addFactory { GetSourcesWithFavoriteCount(get(), get()) }
+        addFactory { GetSourcesWithNonLibraryManga(get()) }
+        addFactory { SetMigrateSorting(get()) }
+        addFactory { ToggleLanguage(get()) }
+        addFactory { ToggleSource(get()) }
+        addFactory { ToggleSourcePin(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
@ -0,0 +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) = 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/GetCategories.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/GetCategories.kt
@ -0,0 +1,26 @@
+package eu.kanade.domain.category.interactor
+
+import eu.kanade.domain.category.model.Category
+import eu.kanade.domain.category.repository.CategoryRepository
+import kotlinx.coroutines.flow.Flow
+
+class GetCategories(
+    private val categoryRepository: CategoryRepository,
+) {
+
+    fun subscribe(): Flow<List<Category>> {
+        return categoryRepository.getAllAsFlow()
+    }
+
+    fun subscribe(mangaId: Long): Flow<List<Category>> {
+        return categoryRepository.getCategoriesByMangaIdAsFlow(mangaId)
+    }
+
+    suspend fun await(): List<Category> {
+        return categoryRepository.getAll()
+    }
+
+    suspend fun await(mangaId: Long): List<Category> {
+        return categoryRepository.getCategoriesByMangaId(mangaId)
+    }
+}
--- 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,70 @@
+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 kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import logcat.LogPriority
+import java.util.Collections
+
+class ReorderCategory(
+    private val categoryRepository: CategoryRepository,
+) {
+
+    private val mutex = Mutex()
+
+    suspend fun moveUp(category: Category): Result =
+        await(category, MoveTo.UP)
+
+    suspend fun moveDown(category: Category): Result =
+        await(category, MoveTo.DOWN)
+
+    private suspend fun await(category: Category, moveTo: MoveTo) = withNonCancellableContext {
+        mutex.withLock {
+            val categories = categoryRepository.getAll()
+                .filterNot(Category::isSystemCategory)
+                .toMutableList()
+
+            val currentIndex = categories.indexOfFirst { it.id == category.id }
+            if (currentIndex == -1) {
+                return@withNonCancellableContext Result.Unchanged
+            }
+
+            val newPosition = when (moveTo) {
+                MoveTo.UP -> currentIndex - 1
+                MoveTo.DOWN -> currentIndex + 1
+            }.toInt()
+
+            try {
+                Collections.swap(categories, currentIndex, newPosition)
+
+                val updates = categories.mapIndexed { index, category ->
+                    CategoryUpdate(
+                        id = category.id,
+                        order = index.toLong(),
+                    )
+                }
+
+                categoryRepository.updatePartial(updates)
+                Result.Success
+            } catch (e: Exception) {
+                logcat(LogPriority.ERROR, e)
+                Result.InternalError(e)
+            }
+        }
+    }
+
+    sealed class Result {
+        object Success : Result()
+        object Unchanged : Result()
+        data class InternalError(val error: Throwable) : Result()
+    }
+
+    private enum class MoveTo {
+        UP,
+        DOWN,
+    }
+}
--- 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/SetMangaCategories.kt
+++ b/app/src/main/java/eu/kanade/domain/category/interactor/SetMangaCategories.kt
@ -0,0 +1,18 @@
+package eu.kanade.domain.category.interactor
+
+import eu.kanade.domain.manga.repository.MangaRepository
+import eu.kanade.tachiyomi.util.system.logcat
+import logcat.LogPriority
+
+class SetMangaCategories(
+    private val mangaRepository: MangaRepository,
+) {
+
+    suspend fun await(mangaId: Long, categoryIds: List<Long>) {
+        try {
+            mangaRepository.setMangaCategories(mangaId, categoryIds)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+        }
+    }
+}
--- 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
@ -0,0 +1,24 @@
+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 = withNonCancellableContext {
+        try {
+            categoryRepository.updatePartial(payload)
+            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/model/Category.kt
+++ b/app/src/main/java/eu/kanade/domain/category/model/Category.kt
@ -0,0 +1,21 @@
+package eu.kanade.domain.category.model
+
+import java.io.Serializable
+
+data class Category(
+    val id: Long,
+    val name: String,
+    val order: Long,
+    val flags: Long,
+) : Serializable {
+
+    val isSystemCategory: Boolean = id == UNCATEGORIZED_ID
+
+    companion object {
+        const val UNCATEGORIZED_ID = 0L
+    }
+}
+
+internal fun List<Category>.anyWithName(name: String): Boolean {
+    return any { name == it.name }
+}
--- a/app/src/main/java/eu/kanade/domain/category/model/CategoryUpdate.kt
+++ b/app/src/main/java/eu/kanade/domain/category/model/CategoryUpdate.kt
@ -0,0 +1,8 @@
+package eu.kanade.domain.category.model
+
+data class CategoryUpdate(
+    val id: Long,
+    val name: String? = null,
+    val order: Long? = null,
+    val flags: Long? = null,
+)
--- a/app/src/main/java/eu/kanade/domain/category/repository/CategoryRepository.kt
+++ b/app/src/main/java/eu/kanade/domain/category/repository/CategoryRepository.kt
@ -0,0 +1,28 @@
+package eu.kanade.domain.category.repository
+
+import eu.kanade.domain.category.model.Category
+import eu.kanade.domain.category.model.CategoryUpdate
+import kotlinx.coroutines.flow.Flow
+
+interface CategoryRepository {
+
+    suspend fun get(id: Long): Category?
+
+    suspend fun getAll(): List<Category>
+
+    fun getAllAsFlow(): Flow<List<Category>>
+
+    suspend fun getCategoriesByMangaId(mangaId: Long): List<Category>
+
+    fun getCategoriesByMangaIdAsFlow(mangaId: Long): Flow<List<Category>>
+
+    suspend fun insert(category: Category)
+
+    suspend fun updatePartial(update: CategoryUpdate)
+
+    suspend fun updatePartial(updates: List<CategoryUpdate>)
+
+    suspend fun updateAllFlags(flags: Long?)
+
+    suspend fun delete(categoryId: Long)
+}
--- a/app/src/main/java/eu/kanade/domain/chapter/interactor/GetChapter.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/interactor/GetChapter.kt
@ -0,0 +1,29 @@
+package eu.kanade.domain.chapter.interactor
+
+import eu.kanade.domain.chapter.model.Chapter
+import eu.kanade.domain.chapter.repository.ChapterRepository
+import eu.kanade.tachiyomi.util.system.logcat
+import logcat.LogPriority
+
+class GetChapter(
+    private val chapterRepository: ChapterRepository,
+) {
+
+    suspend fun await(id: Long): Chapter? {
+        return try {
+            chapterRepository.getChapterById(id)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            null
+        }
+    }
+
+    suspend fun await(url: String, mangaId: Long): Chapter? {
+        return try {
+            chapterRepository.getChapterByUrlAndMangaId(url, mangaId)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            null
+        }
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/chapter/interactor/GetChapterByMangaId.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/interactor/GetChapterByMangaId.kt
@ -0,0 +1,20 @@
+package eu.kanade.domain.chapter.interactor
+
+import eu.kanade.domain.chapter.model.Chapter
+import eu.kanade.domain.chapter.repository.ChapterRepository
+import eu.kanade.tachiyomi.util.system.logcat
+import logcat.LogPriority
+
+class GetChapterByMangaId(
+    private val chapterRepository: ChapterRepository,
+) {
+
+    suspend fun await(mangaId: Long): List<Chapter> {
+        return try {
+            chapterRepository.getChapterByMangaId(mangaId)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            emptyList()
+        }
+    }
+}
--- 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
@ -0,0 +1,80 @@
+package eu.kanade.domain.chapter.interactor
+
+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.util.lang.withNonCancellableContext
+import eu.kanade.tachiyomi.util.system.logcat
+import logcat.LogPriority
+
+class SetReadStatus(
+    private val downloadPreferences: DownloadPreferences,
+    private val deleteDownload: DeleteDownload,
+    private val mangaRepository: MangaRepository,
+    private val chapterRepository: ChapterRepository,
+) {
+
+    private val mapper = { chapter: Chapter, read: Boolean ->
+        ChapterUpdate(
+            read = read,
+            lastPageRead = if (!read) 0 else null,
+            id = chapter.id,
+        )
+    }
+
+    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
+            }
+        }
+        if (chaptersToUpdate.isEmpty()) {
+            return@withNonCancellableContext Result.NoChapters
+        }
+
+        try {
+            chapterRepository.updateAll(
+                chaptersToUpdate.map { mapper(it, read) },
+            )
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            return@withNonCancellableContext Result.InternalError(e)
+        }
+
+        if (read && downloadPreferences.removeAfterMarkedAsRead().get()) {
+            chaptersToUpdate
+                .groupBy { it.mangaId }
+                .forEach { (mangaId, chapters) ->
+                    deleteDownload.awaitAll(
+                        manga = mangaRepository.getMangaById(mangaId),
+                        chapters = chapters.toTypedArray(),
+                    )
+                }
+        }
+
+        Result.Success
+    }
+
+    suspend fun await(mangaId: Long, read: Boolean): Result = withNonCancellableContext {
+        await(
+            read = read,
+            chapters = chapterRepository
+                .getChapterByMangaId(mangaId)
+                .toTypedArray(),
+        )
+    }
+
+    suspend fun await(manga: Manga, read: Boolean) =
+        await(manga.id, read)
+
+    sealed class Result {
+        object Success : Result()
+        object NoChapters : Result()
+        data class InternalError(val error: Throwable) : Result()
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/chapter/interactor/ShouldUpdateDbChapter.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/interactor/ShouldUpdateDbChapter.kt
@ -0,0 +1,13 @@
+package eu.kanade.domain.chapter.interactor
+
+import eu.kanade.domain.chapter.model.Chapter
+
+class ShouldUpdateDbChapter {
+
+    fun await(dbChapter: Chapter, sourceChapter: Chapter): Boolean {
+        return dbChapter.scanlator != sourceChapter.scanlator || dbChapter.name != sourceChapter.name ||
+            dbChapter.dateUpload != sourceChapter.dateUpload ||
+            dbChapter.chapterNumber != sourceChapter.chapterNumber ||
+            dbChapter.sourceOrder != sourceChapter.sourceOrder
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/chapter/interactor/SyncChaptersWithSource.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/interactor/SyncChaptersWithSource.kt
@ -0,0 +1,194 @@
+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
+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.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
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.lang.Long.max
+import java.util.Date
+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(),
+    private val updateChapter: UpdateChapter = Injekt.get(),
+    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,
+    ): List<Chapter> {
+        if (rawSourceChapters.isEmpty() && !source.isLocal()) {
+            throw NoChaptersException()
+        }
+
+        val sourceChapters = rawSourceChapters
+            .distinctBy { it.url }
+            .mapIndexed { i, sChapter ->
+                Chapter.create()
+                    .copyFromSChapter(sChapter)
+                    .copy(name = CleanupChapterName.await(sChapter.name, manga.title))
+                    .copy(mangaId = manga.id, sourceOrder = i.toLong())
+            }
+
+        // Chapters from db.
+        val dbChapters = getChapterByMangaId.await(manga.id)
+
+        // Chapters from the source not in db.
+        val toAdd = mutableListOf<Chapter>()
+
+        // Chapters whose metadata have changed.
+        val toChange = mutableListOf<Chapter>()
+
+        // Chapters from the db not in source.
+        val toDelete = dbChapters.filterNot { dbChapter ->
+            sourceChapters.any { sourceChapter ->
+                dbChapter.url == sourceChapter.url
+            }
+        }
+
+        val rightNow = Date().time
+
+        // Used to not set upload date of older chapters
+        // to a higher value than newer chapters
+        var maxSeenUploadDate = 0L
+
+        val sManga = manga.toSManga()
+        for (sourceChapter in sourceChapters) {
+            var chapter = sourceChapter
+
+            // Update metadata from source if necessary.
+            if (source is HttpSource) {
+                val sChapter = chapter.toSChapter()
+                source.prepareNewChapter(sChapter, sManga)
+                chapter = chapter.copyFromSChapter(sChapter)
+            }
+
+            // Recognize chapter number for the chapter.
+            val chapterNumber = ChapterRecognition.parseChapterNumber(manga.title, chapter.name, chapter.chapterNumber)
+            chapter = chapter.copy(chapterNumber = chapterNumber)
+
+            val dbChapter = dbChapters.find { it.url == chapter.url }
+
+            if (dbChapter == null) {
+                val toAddChapter = if (chapter.dateUpload == 0L) {
+                    val altDateUpload = if (maxSeenUploadDate == 0L) rightNow else maxSeenUploadDate
+                    chapter.copy(dateUpload = altDateUpload)
+                } else {
+                    maxSeenUploadDate = max(maxSeenUploadDate, sourceChapter.dateUpload)
+                    chapter
+                }
+                toAdd.add(toAddChapter)
+            } else {
+                if (shouldUpdateDbChapter.await(dbChapter, chapter)) {
+                    val shouldRenameChapter = downloadProvider.isChapterDirNameChanged(dbChapter, chapter) &&
+                        downloadManager.isChapterDownloaded(dbChapter.name, dbChapter.scanlator, manga.title, manga.source)
+
+                    if (shouldRenameChapter) {
+                        downloadManager.renameChapter(source, manga, dbChapter, chapter)
+                    }
+                    var toChangeChapter = dbChapter.copy(
+                        name = chapter.name,
+                        chapterNumber = chapter.chapterNumber,
+                        scanlator = chapter.scanlator,
+                        sourceOrder = chapter.sourceOrder,
+                    )
+                    if (chapter.dateUpload != 0L) {
+                        toChangeChapter = toChangeChapter.copy(dateUpload = chapter.dateUpload)
+                    }
+                    toChange.add(toChangeChapter)
+                }
+            }
+        }
+
+        // Return if there's nothing to add, delete or change, avoiding unnecessary db transactions.
+        if (toAdd.isEmpty() && toDelete.isEmpty() && toChange.isEmpty()) {
+            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.bookmark) deletedBookmarkedChapterNumbers.add(chapter.chapterNumber)
+            deletedChapterNumbers.add(chapter.chapterNumber)
+        }
+
+        val deletedChapterNumberDateFetchMap = toDelete.sortedByDescending { it.dateFetch }
+            .associate { it.chapterNumber to it.dateFetch }
+
+        // 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
+
+            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
+            deletedChapterNumberDateFetchMap[chapter.chapterNumber]?.let {
+                chapter = chapter.copy(dateFetch = it)
+            }
+
+            reAdded.add(chapter)
+
+            chapter
+        }
+
+        if (toDelete.isNotEmpty()) {
+            val toDeleteIds = toDelete.map { it.id }
+            chapterRepository.removeChaptersWithIds(toDeleteIds)
+        }
+
+        if (updatedToAdd.isNotEmpty()) {
+            updatedToAdd = chapterRepository.addAll(updatedToAdd)
+        }
+
+        if (toChange.isNotEmpty()) {
+            val chapterUpdates = toChange.map { it.toChapterUpdate() }
+            updateChapter.awaitAll(chapterUpdates)
+        }
+
+        // Set this manga as updated since chapters were changed
+        // Note that last_update actually represents last time the chapter list changed at all
+        updateManga.awaitUpdateLastUpdate(manga.id)
+
+        val reAddedUrls = reAdded.map { it.url }.toHashSet()
+
+        return updatedToAdd.filterNot { it.url in reAddedUrls }
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/chapter/interactor/SyncChaptersWithTrackServiceTwoWay.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/interactor/SyncChaptersWithTrackServiceTwoWay.kt
@ -0,0 +1,41 @@
+package eu.kanade.domain.chapter.interactor
+
+import eu.kanade.domain.chapter.model.Chapter
+import eu.kanade.domain.chapter.model.toChapterUpdate
+import eu.kanade.domain.track.interactor.InsertTrack
+import eu.kanade.domain.track.model.Track
+import eu.kanade.domain.track.model.toDbTrack
+import eu.kanade.tachiyomi.data.track.TrackService
+import eu.kanade.tachiyomi.util.system.logcat
+import logcat.LogPriority
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class SyncChaptersWithTrackServiceTwoWay(
+    private val updateChapter: UpdateChapter = Injekt.get(),
+    private val insertTrack: InsertTrack = Injekt.get(),
+) {
+
+    suspend fun await(
+        chapters: List<Chapter>,
+        remoteTrack: Track,
+        service: TrackService,
+    ) {
+        val sortedChapters = chapters.sortedBy { it.chapterNumber }
+        val chapterUpdates = sortedChapters
+            .filter { chapter -> chapter.chapterNumber <= remoteTrack.lastChapterRead && !chapter.read }
+            .map { it.copy(read = true).toChapterUpdate() }
+
+        // only take into account continuous reading
+        val localLastRead = sortedChapters.takeWhile { it.read }.lastOrNull()?.chapterNumber ?: 0F
+        val updatedTrack = remoteTrack.copy(lastChapterRead = localLastRead.toDouble())
+
+        try {
+            service.update(updatedTrack.toDbTrack())
+            updateChapter.awaitAll(chapterUpdates)
+            insertTrack.await(updatedTrack)
+        } catch (e: Throwable) {
+            logcat(LogPriority.WARN, e)
+        }
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/chapter/interactor/UpdateChapter.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/interactor/UpdateChapter.kt
@ -0,0 +1,27 @@
+package eu.kanade.domain.chapter.interactor
+
+import eu.kanade.domain.chapter.model.ChapterUpdate
+import eu.kanade.domain.chapter.repository.ChapterRepository
+import eu.kanade.tachiyomi.util.system.logcat
+import logcat.LogPriority
+
+class UpdateChapter(
+    private val chapterRepository: ChapterRepository,
+) {
+
+    suspend fun await(chapterUpdate: ChapterUpdate) {
+        try {
+            chapterRepository.update(chapterUpdate)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+        }
+    }
+
+    suspend fun awaitAll(chapterUpdates: List<ChapterUpdate>) {
+        try {
+            chapterRepository.updateAll(chapterUpdates)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+        }
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/chapter/model/Chapter.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/model/Chapter.kt
@ -0,0 +1,76 @@
+package eu.kanade.domain.chapter.model
+
+import eu.kanade.tachiyomi.data.database.models.ChapterImpl
+import eu.kanade.tachiyomi.source.model.SChapter
+import eu.kanade.tachiyomi.data.database.models.Chapter as DbChapter
+
+data class Chapter(
+    val id: Long,
+    val mangaId: Long,
+    val read: Boolean,
+    val bookmark: Boolean,
+    val lastPageRead: Long,
+    val dateFetch: Long,
+    val sourceOrder: Long,
+    val url: String,
+    val name: String,
+    val dateUpload: Long,
+    val chapterNumber: Float,
+    val scanlator: String?,
+) {
+    val isRecognizedNumber: Boolean
+        get() = chapterNumber >= 0f
+
+    fun toSChapter(): SChapter {
+        return SChapter.create().also {
+            it.url = url
+            it.name = name
+            it.date_upload = dateUpload
+            it.chapter_number = chapterNumber
+            it.scanlator = scanlator
+        }
+    }
+
+    fun copyFromSChapter(sChapter: SChapter): Chapter {
+        return this.copy(
+            name = sChapter.name,
+            url = sChapter.url,
+            dateUpload = sChapter.date_upload,
+            chapterNumber = sChapter.chapter_number,
+            scanlator = sChapter.scanlator?.ifBlank { null },
+        )
+    }
+
+    companion object {
+        fun create() = Chapter(
+            id = -1,
+            mangaId = -1,
+            read = false,
+            bookmark = false,
+            lastPageRead = 0,
+            dateFetch = 0,
+            sourceOrder = 0,
+            url = "",
+            name = "",
+            dateUpload = -1,
+            chapterNumber = -1f,
+            scanlator = null,
+        )
+    }
+}
+
+// TODO: Remove when all deps are migrated
+fun Chapter.toDbChapter(): DbChapter = ChapterImpl().also {
+    it.id = id
+    it.manga_id = mangaId
+    it.url = url
+    it.name = name
+    it.scanlator = scanlator
+    it.read = read
+    it.bookmark = bookmark
+    it.last_page_read = lastPageRead.toInt()
+    it.date_fetch = dateFetch
+    it.date_upload = dateUpload
+    it.chapter_number = chapterNumber
+    it.source_order = sourceOrder.toInt()
+}
--- a/app/src/main/java/eu/kanade/domain/chapter/model/ChapterFilter.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/model/ChapterFilter.kt
@ -0,0 +1,82 @@
+package eu.kanade.domain.chapter.model
+
+import eu.kanade.domain.manga.model.Manga
+import eu.kanade.domain.manga.model.TriStateFilter
+import eu.kanade.domain.manga.model.isLocal
+import eu.kanade.tachiyomi.data.download.DownloadManager
+import eu.kanade.tachiyomi.data.download.model.Download
+import eu.kanade.tachiyomi.ui.manga.ChapterItem
+import eu.kanade.tachiyomi.util.chapter.getChapterSort
+
+/**
+ * Applies the view filters to the list of chapters obtained from the database.
+ * @return an observable of the list of chapters filtered and sorted.
+ */
+fun List<Chapter>.applyFilters(manga: Manga, downloadManager: DownloadManager): List<Chapter> {
+    val isLocalManga = manga.isLocal()
+    val unreadFilter = manga.unreadFilter
+    val downloadedFilter = manga.downloadedFilter
+    val bookmarkedFilter = manga.bookmarkedFilter
+
+    return filter { chapter ->
+        when (unreadFilter) {
+            TriStateFilter.DISABLED -> true
+            TriStateFilter.ENABLED_IS -> !chapter.read
+            TriStateFilter.ENABLED_NOT -> chapter.read
+        }
+    }
+        .filter { chapter ->
+            when (bookmarkedFilter) {
+                TriStateFilter.DISABLED -> true
+                TriStateFilter.ENABLED_IS -> chapter.bookmark
+                TriStateFilter.ENABLED_NOT -> !chapter.bookmark
+            }
+        }
+        .filter { chapter ->
+            val downloaded = downloadManager.isChapterDownloaded(chapter.name, chapter.scanlator, manga.title, manga.source)
+            val downloadState = when {
+                downloaded -> Download.State.DOWNLOADED
+                else -> Download.State.NOT_DOWNLOADED
+            }
+            when (downloadedFilter) {
+                TriStateFilter.DISABLED -> true
+                TriStateFilter.ENABLED_IS -> downloadState == Download.State.DOWNLOADED || isLocalManga
+                TriStateFilter.ENABLED_NOT -> downloadState != Download.State.DOWNLOADED && !isLocalManga
+            }
+        }
+        .sortedWith(getChapterSort(manga))
+}
+
+/**
+ * Applies the view filters to the list of chapters obtained from the database.
+ * @return an observable of the list of chapters filtered and sorted.
+ */
+fun List<ChapterItem>.applyFilters(manga: Manga): Sequence<ChapterItem> {
+    val isLocalManga = manga.isLocal()
+    val unreadFilter = manga.unreadFilter
+    val downloadedFilter = manga.downloadedFilter
+    val bookmarkedFilter = manga.bookmarkedFilter
+    return asSequence()
+        .filter { (chapter) ->
+            when (unreadFilter) {
+                TriStateFilter.DISABLED -> true
+                TriStateFilter.ENABLED_IS -> !chapter.read
+                TriStateFilter.ENABLED_NOT -> chapter.read
+            }
+        }
+        .filter { (chapter) ->
+            when (bookmarkedFilter) {
+                TriStateFilter.DISABLED -> true
+                TriStateFilter.ENABLED_IS -> chapter.bookmark
+                TriStateFilter.ENABLED_NOT -> !chapter.bookmark
+            }
+        }
+        .filter {
+            when (downloadedFilter) {
+                TriStateFilter.DISABLED -> true
+                TriStateFilter.ENABLED_IS -> it.isDownloaded || isLocalManga
+                TriStateFilter.ENABLED_NOT -> !it.isDownloaded && !isLocalManga
+            }
+        }
+        .sortedWith { (chapter1), (chapter2) -> getChapterSort(manga).invoke(chapter1, chapter2) }
+}
--- a/app/src/main/java/eu/kanade/domain/chapter/model/ChapterUpdate.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/model/ChapterUpdate.kt
@ -0,0 +1,20 @@
+package eu.kanade.domain.chapter.model
+
+data class ChapterUpdate(
+    val id: Long,
+    val mangaId: Long? = null,
+    val read: Boolean? = null,
+    val bookmark: Boolean? = null,
+    val lastPageRead: Long? = null,
+    val dateFetch: Long? = null,
+    val sourceOrder: Long? = null,
+    val url: String? = null,
+    val name: String? = null,
+    val dateUpload: Long? = null,
+    val chapterNumber: Float? = null,
+    val scanlator: String? = null,
+)
+
+fun Chapter.toChapterUpdate(): ChapterUpdate {
+    return ChapterUpdate(id, mangaId, read, bookmark, lastPageRead, dateFetch, sourceOrder, url, name, dateUpload, chapterNumber, scanlator)
+}
--- a/app/src/main/java/eu/kanade/domain/chapter/repository/ChapterRepository.kt
+++ b/app/src/main/java/eu/kanade/domain/chapter/repository/ChapterRepository.kt
@ -0,0 +1,26 @@
+package eu.kanade.domain.chapter.repository
+
+import eu.kanade.domain.chapter.model.Chapter
+import eu.kanade.domain.chapter.model.ChapterUpdate
+import kotlinx.coroutines.flow.Flow
+
+interface ChapterRepository {
+
+    suspend fun addAll(chapters: List<Chapter>): List<Chapter>
+
+    suspend fun update(chapterUpdate: ChapterUpdate)
+
+    suspend fun updateAll(chapterUpdates: List<ChapterUpdate>)
+
+    suspend fun removeChaptersWithIds(chapterIds: List<Long>)
+
+    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>>
+
+    suspend fun getChapterByUrlAndMangaId(url: String, mangaId: Long): 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
@ -0,0 +1,19 @@
+package eu.kanade.domain.download.interactor
+
+import eu.kanade.domain.chapter.model.Chapter
+import eu.kanade.domain.manga.model.Manga
+import eu.kanade.tachiyomi.data.download.DownloadManager
+import eu.kanade.tachiyomi.source.SourceManager
+import eu.kanade.tachiyomi.util.lang.withNonCancellableContext
+
+class DeleteDownload(
+    private val sourceManager: SourceManager,
+    private val downloadManager: DownloadManager,
+) {
+
+    suspend fun awaitAll(manga: Manga, vararg chapters: Chapter) = withNonCancellableContext {
+        sourceManager.get(manga.source)?.let { source ->
+            downloadManager.deleteChapters(chapters.toList(), 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
@ -0,0 +1,32 @@
+package eu.kanade.domain.extension.interactor
+
+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: SourcePreferences,
+    private val extensionManager: ExtensionManager,
+) {
+    fun subscribe(): Flow<List<String>> {
+        return combine(
+            preferences.enabledLanguages().changes(),
+            extensionManager.availableExtensionsFlow,
+        ) { enabledLanguage, availableExtensions ->
+            availableExtensions
+                .flatMap { ext ->
+                    if (ext.sources.isEmpty()) {
+                        listOf(ext.lang)
+                    } else {
+                        ext.sources.map { it.lang }
+                    }
+                }
+                .distinct()
+                .sortedWith(
+                    compareBy<String> { it !in enabledLanguage }.then(LocaleHelper.comparator),
+                )
+        }
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/extension/interactor/GetExtensionSources.kt
+++ b/app/src/main/java/eu/kanade/domain/extension/interactor/GetExtensionSources.kt
@ -0,0 +1,37 @@
+package eu.kanade.domain.extension.interactor
+
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.extension.model.Extension
+import eu.kanade.tachiyomi.source.Source
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+
+class GetExtensionSources(
+    private val preferences: SourcePreferences,
+) {
+
+    fun subscribe(extension: Extension.Installed): Flow<List<ExtensionSourceItem>> {
+        val isMultiSource = extension.sources.size > 1
+        val isMultiLangSingleSource =
+            isMultiSource && extension.sources.map { it.name }.distinct().size == 1
+
+        return preferences.disabledSources().changes().map { disabledSources ->
+            fun Source.isEnabled() = id.toString() !in disabledSources
+
+            extension.sources
+                .map { source ->
+                    ExtensionSourceItem(
+                        source = source,
+                        enabled = source.isEnabled(),
+                        labelAsName = isMultiSource && isMultiLangSingleSource.not(),
+                    )
+                }
+        }
+    }
+}
+
+data class ExtensionSourceItem(
+    val source: Source,
+    val enabled: Boolean,
+    val labelAsName: Boolean,
+)
--- 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/GetHistory.kt
+++ b/app/src/main/java/eu/kanade/domain/history/interactor/GetHistory.kt
@ -0,0 +1,14 @@
+package eu.kanade.domain.history.interactor
+
+import eu.kanade.domain.history.model.HistoryWithRelations
+import eu.kanade.domain.history.repository.HistoryRepository
+import kotlinx.coroutines.flow.Flow
+
+class GetHistory(
+    private val repository: HistoryRepository,
+) {
+
+    fun subscribe(query: String): Flow<List<HistoryWithRelations>> {
+        return repository.getHistory(query)
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/history/interactor/GetNextChapters.kt
+++ b/app/src/main/java/eu/kanade/domain/history/interactor/GetNextChapters.kt
@ -0,0 +1,52 @@
+package eu.kanade.domain.history.interactor
+
+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.tachiyomi.util.chapter.getChapterSort
+import kotlin.math.max
+
+class GetNextChapters(
+    private val getChapterByMangaId: GetChapterByMangaId,
+    private val getManga: GetManga,
+    private val historyRepository: HistoryRepository,
+) {
+
+    suspend fun await(onlyUnread: Boolean = true): List<Chapter> {
+        val history = historyRepository.getLastHistory() ?: return emptyList()
+        return await(history.mangaId, history.chapterId, onlyUnread)
+    }
+
+    suspend fun await(mangaId: Long, onlyUnread: Boolean = true): List<Chapter> {
+        val manga = getManga.await(mangaId) ?: return emptyList()
+        val chapters = getChapterByMangaId.await(mangaId)
+            .sortedWith(getChapterSort(manga, sortDescending = false))
+
+        return if (onlyUnread) {
+            chapters.filterNot { it.read }
+        } else {
+            chapters
+        }
+    }
+
+    suspend fun await(mangaId: Long, fromChapterId: Long, onlyUnread: Boolean = true): List<Chapter> {
+        val chapters = await(mangaId, onlyUnread)
+        val currChapterIndex = chapters.indexOfFirst { it.id == fromChapterId }
+        val nextChapters = chapters.subList(max(0, currChapterIndex), chapters.size)
+
+        if (onlyUnread) {
+            return nextChapters
+        }
+
+        // The "next chapter" is either:
+        // - The current chapter if it isn't completely read
+        // - The chapters after the current chapter if the current one is completely read
+        val fromChapter = chapters.getOrNull(currChapterIndex)
+        return if (fromChapter != null && !fromChapter.read) {
+            nextChapters
+        } else {
+            nextChapters.drop(1)
+        }
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/history/interactor/GetTotalReadDuration.kt
+++ b/app/src/main/java/eu/kanade/domain/history/interactor/GetTotalReadDuration.kt
@ -0,0 +1,12 @@
+package eu.kanade.domain.history.interactor
+
+import eu.kanade.domain.history.repository.HistoryRepository
+
+class GetTotalReadDuration(
+    private val repository: HistoryRepository,
+) {
+
+    suspend fun await(): Long {
+        return repository.getTotalReadDuration()
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/history/interactor/RemoveHistory.kt
+++ b/app/src/main/java/eu/kanade/domain/history/interactor/RemoveHistory.kt
@ -0,0 +1,21 @@
+package eu.kanade.domain.history.interactor
+
+import eu.kanade.domain.history.model.HistoryWithRelations
+import eu.kanade.domain.history.repository.HistoryRepository
+
+class RemoveHistory(
+    private val repository: HistoryRepository,
+) {
+
+    suspend fun awaitAll(): Boolean {
+        return repository.deleteAllHistory()
+    }
+
+    suspend fun await(history: HistoryWithRelations) {
+        repository.resetHistory(history.id)
+    }
+
+    suspend fun await(mangaId: Long) {
+        repository.resetHistoryByMangaId(mangaId)
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/history/interactor/UpsertHistory.kt
+++ b/app/src/main/java/eu/kanade/domain/history/interactor/UpsertHistory.kt
@ -0,0 +1,13 @@
+package eu.kanade.domain.history.interactor
+
+import eu.kanade.domain.history.model.HistoryUpdate
+import eu.kanade.domain.history.repository.HistoryRepository
+
+class UpsertHistory(
+    private val historyRepository: HistoryRepository,
+) {
+
+    suspend fun await(historyUpdate: HistoryUpdate) {
+        historyRepository.upsertHistory(historyUpdate)
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/history/model/History.kt
+++ b/app/src/main/java/eu/kanade/domain/history/model/History.kt
@ -0,0 +1,10 @@
+package eu.kanade.domain.history.model
+
+import java.util.Date
+
+data class History(
+    val id: Long,
+    val chapterId: Long,
+    val readAt: Date?,
+    val readDuration: Long,
+)
--- a/app/src/main/java/eu/kanade/domain/history/model/HistoryUpdate.kt
+++ b/app/src/main/java/eu/kanade/domain/history/model/HistoryUpdate.kt
@ -0,0 +1,9 @@
+package eu.kanade.domain.history.model
+
+import java.util.Date
+
+data class HistoryUpdate(
+    val chapterId: Long,
+    val readAt: Date,
+    val sessionReadDuration: Long,
+)
--- a/app/src/main/java/eu/kanade/domain/history/model/HistoryWithRelations.kt
+++ b/app/src/main/java/eu/kanade/domain/history/model/HistoryWithRelations.kt
@ -0,0 +1,15 @@
+package eu.kanade.domain.history.model
+
+import eu.kanade.domain.manga.model.MangaCover
+import java.util.Date
+
+data class HistoryWithRelations(
+    val id: Long,
+    val chapterId: Long,
+    val mangaId: Long,
+    val title: String,
+    val chapterNumber: Float,
+    val readAt: Date?,
+    val readDuration: Long,
+    val coverData: MangaCover,
+)
--- a/app/src/main/java/eu/kanade/domain/history/repository/HistoryRepository.kt
+++ b/app/src/main/java/eu/kanade/domain/history/repository/HistoryRepository.kt
@ -0,0 +1,22 @@
+package eu.kanade.domain.history.repository
+
+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): Flow<List<HistoryWithRelations>>
+
+    suspend fun getLastHistory(): HistoryWithRelations?
+
+    suspend fun getTotalReadDuration(): Long
+
+    suspend fun resetHistory(historyId: Long)
+
+    suspend fun resetHistoryByMangaId(mangaId: Long)
+
+    suspend fun deleteAllHistory(): Boolean
+
+    suspend fun upsertHistory(historyUpdate: HistoryUpdate)
+}
--- 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,119 @@
+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,113 @@
+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)
+
+    fun showContinueReadingButton() = preferenceStore.getBoolean("display_continue_reading_button", 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 newShowUpdatesCount() = preferenceStore.getBoolean("library_show_updates_count", true)
+    fun newUpdatesCount() = preferenceStore.getInt("library_unseen_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/GetDuplicateLibraryManga.kt
+++ b/app/src/main/java/eu/kanade/domain/manga/interactor/GetDuplicateLibraryManga.kt
@ -0,0 +1,13 @@
+package eu.kanade.domain.manga.interactor
+
+import eu.kanade.domain.manga.model.Manga
+import eu.kanade.domain.manga.repository.MangaRepository
+
+class GetDuplicateLibraryManga(
+    private val mangaRepository: MangaRepository,
+) {
+
+    suspend fun await(title: String, sourceId: Long): Manga? {
+        return mangaRepository.getDuplicateLibraryManga(title.lowercase(), sourceId)
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/manga/interactor/GetFavorites.kt
+++ b/app/src/main/java/eu/kanade/domain/manga/interactor/GetFavorites.kt
@ -0,0 +1,18 @@
+package eu.kanade.domain.manga.interactor
+
+import eu.kanade.domain.manga.model.Manga
+import eu.kanade.domain.manga.repository.MangaRepository
+import kotlinx.coroutines.flow.Flow
+
+class GetFavorites(
+    private val mangaRepository: MangaRepository,
+) {
+
+    suspend fun await(): List<Manga> {
+        return mangaRepository.getFavorites()
+    }
+
+    fun subscribe(sourceId: Long): Flow<List<Manga>> {
+        return mangaRepository.getFavoritesBySourceId(sourceId)
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/manga/interactor/GetLibraryManga.kt
+++ b/app/src/main/java/eu/kanade/domain/manga/interactor/GetLibraryManga.kt
@ -0,0 +1,18 @@
+package eu.kanade.domain.manga.interactor
+
+import eu.kanade.domain.library.model.LibraryManga
+import eu.kanade.domain.manga.repository.MangaRepository
+import kotlinx.coroutines.flow.Flow
+
+class GetLibraryManga(
+    private val mangaRepository: MangaRepository,
+) {
+
+    suspend fun await(): List<LibraryManga> {
+        return mangaRepository.getLibraryManga()
+    }
+
+    fun subscribe(): Flow<List<LibraryManga>> {
+        return mangaRepository.getLibraryMangaAsFlow()
+    }
+}
--- a/app/src/main/java/eu/kanade/domain/manga/interactor/GetManga.kt
+++ b/app/src/main/java/eu/kanade/domain/manga/interactor/GetManga.kt
@ -0,0 +1,29 @@
+package eu.kanade.domain.manga.interactor
+
+import eu.kanade.domain.manga.model.Manga
+import eu.kanade.domain.manga.repository.MangaRepository
+import eu.kanade.tachiyomi.util.system.logcat
+import kotlinx.coroutines.flow.Flow
+import logcat.LogPriority
+
+class GetManga(
+    private val mangaRepository: MangaRepository,
+) {
+
+    suspend fun await(id: Long): Manga? {
+        return try {
+            mangaRepository.getMangaById(id)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            null
+        }
+    }
+
+    suspend fun subscribe(id: Long): Flow<Manga> {
+        return mangaRepository.getMangaByIdAsFlow(id)
+    }
+
+    fun subscribe(url: String, sourceId: Long): Flow<Manga?> {
+        return mangaRepository.getMangaByUrlAndSourceIdAsFlow(url, sourceId)
+    }
+}
--- a/Show More
+++ b/Show More