Release v1.9.0

(cherry picked from commit 4eb2cd85b2dc3c3eb519211c54bbfa5fdd3c6325)

.github/ISSUE_TEMPLATE.md

@@ -3,11 +3,11 @@
 I acknowledge that:
 
 - I have updated:
-  - To the latest version of the app (stable is v1.8.5)
+  - To the latest version of the app (stable is v1.9.0)
   - 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.

.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: "1.8.5"
+        Example: "1.9.0"
     validations:
       required: true
 
@@ -90,7 +90,9 @@ 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: This is a TachiyomiSY specific issue that does not happen in [Tachiyomi Preview](https://github.com/tachiyomiorg/tachiyomi/).
+          required: true
+        - 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 +100,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 **[1.8.5](https://github.com/jobobby04/tachiyomisy/releases/latest)**.
+        - label: I have updated the app to version **[1.9.0](https://github.com/jobobby04/tachiyomisy/releases/latest)**.
           required: true
         - label: I have updated all installed extensions.
           required: true

.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 **[1.8.5](https://github.com/jobobby04/tachiyomisy/releases/latest)**.
+        - label: I have updated the app to version **[1.9.0](https://github.com/jobobby04/tachiyomisy/releases/latest)**.
           required: true
         - label: I will fill out all of the requested information in this form.
           required: true

.github/workflows/TachiyomiSY-Release-Builder.yml

@@ -1,83 +0,0 @@
-name: Release Builder
- 
-on:
-  push:
-   branches: 
-    - 'release'
- 
-jobs:
-  check_wrapper:
-    name: Validate Gradle Wrapper
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Clone repo
-        uses: actions/checkout@v2
-
-      - name: Validate Gradle Wrapper
-        uses: gradle/wrapper-validation-action@v1
-
-  build:
-    name: Build app
-    needs: check_wrapper
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Cancel previous runs
-        uses: styfle/cancel-workflow-action@0.5.0
-        with:
-          access_token: ${{ github.token }}
-
-      - name: Clone repo
-        uses: actions/checkout@v2
-
-      - name: Set up JDK 11
-        uses: actions/setup-java@v3
-        with:
-          java-version: 11
-          distribution: adopt
-
-      - name: Write google-services.json
-        uses: DamianReeves/write-file-action@v1.0
-        with:
-          # The path to the file to write
-          path: app/google-services.json
-          # The contents of the file
-          contents: ${{ secrets.GOOGLE_SERVICES_TEXT }}
-          # The mode of writing to use: `overwrite`, `append`, or `preserve`.
-          write-mode: overwrite # optional, default is preserve
-
-      - name: Build app
-        uses: gradle/gradle-command-action@v2
-        with:
-          arguments: assembleStandardRelease --stacktrace
-
-      - name: Sign APK
-        uses: r0adkll/sign-android-release@v1
-        with:
-          releaseDirectory: app/build/outputs/apk/standard/release
-          signingKeyBase64: ${{ secrets.SIGNING_KEY }}
-          alias: ${{ secrets.ALIAS }}
-          keyStorePassword: ${{ secrets.KEY_STORE_PASSWORD }}
-          keyPassword: ${{ secrets.KEY_PASSWORD }}
-
-      - name: Create release
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          tag_name: ${{ github.run_number }}
-          release_name: TachiyomiSY
-          draft: true
-          prerelease: false
-
-      - name: Upload APK to release
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: ${{ env.SIGNED_RELEASE_FILE }}
-          asset_name: TachiyomiSY.apk
-          asset_content_type: application/vnd.android.package-archive

.github/workflows/build_check.yml

@@ -1,6 +1,10 @@
 name: CI
 on: [pull_request]
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   check_wrapper:
     name: Validate Gradle Wrapper
@@ -8,7 +12,7 @@ jobs:
 
     steps:
       - name: Clone repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Validate Gradle Wrapper
         uses: gradle/wrapper-validation-action@v1
@@ -19,13 +23,8 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - name: Cancel previous runs
-        uses: styfle/cancel-workflow-action@0.5.0
-        with:
-          access_token: ${{ github.token }}
-
       - name: Clone repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Set up JDK 11
         uses: actions/setup-java@v3
@@ -39,7 +38,7 @@ jobs:
           arguments: assembleDevDebug
 
       - name: Upload APK
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v3
         with:
           name: TachiyomiSY-${{ github.sha }}.apk
           path: app/build/outputs/apk/dev/debug/app-dev-debug.apk

.github/workflows/build_push.yml

@@ -0,0 +1,102 @@
+name: Release Builder
+on:
+  push:
+   branches: 
+    - 'release'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+ 
+jobs:
+  build:
+    name: Build release app
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Clone repo
+        uses: actions/checkout@v3
+
+      - name: Validate Gradle Wrapper
+        uses: gradle/wrapper-validation-action@v1
+
+      - name: Set up JDK 11
+        uses: actions/setup-java@v3
+        with:
+          java-version: 11
+          distribution: adopt
+
+      # SY <--
+      - name: Write google-services.json
+        uses: DamianReeves/write-file-action@v1.2
+        with:
+          path: app/google-services.json
+          contents: ${{ secrets.GOOGLE_SERVICES_TEXT }}
+          write-mode: overwrite
+      # SY -->
+
+      - name: Build app and run unit tests
+        uses: gradle/gradle-command-action@v2
+        with:
+          arguments: assembleStandardRelease testStandardReleaseUnitTest --stacktrace
+
+      - name: Sign APK
+        uses: r0adkll/sign-android-release@v1
+        with:
+          releaseDirectory: app/build/outputs/apk/standard/release
+          signingKeyBase64: ${{ secrets.SIGNING_KEY }}
+          alias: ${{ secrets.ALIAS }}
+          keyStorePassword: ${{ secrets.KEY_STORE_PASSWORD }}
+          keyPassword: ${{ secrets.KEY_PASSWORD }}
+
+      - name: Clean up build artifacts
+        run: |
+          set -e
+
+          mv app/build/outputs/apk/standard/release/app-standard-universal-release-unsigned-signed.apk TachiyomiSY.apk
+          sha=`sha256sum TachiyomiSY.apk | awk '{ print $1 }'`
+          echo "APK_UNIVERSAL_SHA=$sha" >> $GITHUB_ENV
+
+          cp app/build/outputs/apk/standard/release/app-standard-arm64-v8a-release-unsigned-signed.apk TachiyomiSY-arm64-v8a.apk
+          sha=`sha256sum TachiyomiSY-arm64-v8a.apk | awk '{ print $1 }'`
+          echo "APK_ARM64_V8A_SHA=$sha" >> $GITHUB_ENV
+
+          cp app/build/outputs/apk/standard/release/app-standard-armeabi-v7a-release-unsigned-signed.apk TachiyomiSY-armeabi-v7a.apk
+          sha=`sha256sum TachiyomiSY-armeabi-v7a.apk | awk '{ print $1 }'`
+          echo "APK_ARMEABI_V7A_SHA=$sha" >> $GITHUB_ENV
+
+          cp app/build/outputs/apk/standard/release/app-standard-x86-release-unsigned-signed.apk TachiyomiSY-x86.apk
+          sha=`sha256sum TachiyomiSY-x86.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 TachiyomiSY-x86_64.apk
+          sha=`sha256sum TachiyomiSY-x86_64.apk | awk '{ print $1 }'`
+          echo "APK_X86_64_SHA=$sha" >> $GITHUB_ENV
+
+      - name: Create release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: ${{ github.run_number }}
+          name: TachiyomiSY
+          body: |
+            ---
+
+            ### Checksums
+
+            | Variant | SHA-256 |
+            | ------- | ------- |
+            | Universal | ${{ env.APK_UNIVERSAL_SHA }} |
+            | 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: |
+            TachiyomiSY.apk
+            TachiyomiSY-arm64-v8a.apk
+            TachiyomiSY-armeabi-v7a.apk
+            TachiyomiSY-x86.apk
+            TachiyomiSY-x86_64.apk
+          draft: true
+          prerelease: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/build_push_preview.yml

@@ -6,26 +6,18 @@ on:
     - 'master'
  
 jobs:
-  check_wrapper:
+  trigger_preview_build:
-    name: Validate Gradle Wrapper
+    name: Trigger preview build
+    if: ${{ github.ref == 'refs/heads/master' }}
     runs-on: ubuntu-latest
 
     steps:
       - name: Clone repo
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Validate Gradle Wrapper
         uses: gradle/wrapper-validation-action@v1
 
-  preview:
-    name: Build app preview
-    needs: check_wrapper
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Clone repo
-        uses: actions/checkout@v2
-
       - name: TAG - Bump version and push tag
         uses: anothrNick/github-tag-action@1.39.0
         env:

.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'

.gitignore

@@ -14,8 +14,8 @@
 *.apk
 app/**/output.json
 
-# Hebrew assets are copied on build
+# Unnecessary file
-app/src/main/res/values-iw/
+*.swp
 
 TODO.md
 CHANGELOG.md

README.md

@@ -14,7 +14,7 @@ Features of Tachiyomi(original) 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
@@ -58,11 +58,8 @@ Custom sources:
 Additional features for some extensions, features include custom description, opening in app, batch add to library, and a bunch of other things based on the source:
 * 8Muses (EroMuse)
 * HBrowse
-* HentaiCafe (inside Foolside)
-* Hitomi.la
 * Mangadex
 * NHentai
-* PervEden (EN and IT)
 * Puruin
 * Tsumino
 
@@ -85,8 +82,8 @@ Please make sure to read the full guidelines. Your issue may be closed without w
 <details><summary>Bugs</summary>
 
 * Include version (More → About → Version)
- * If not latest, try updating, it may have already been solved
+* If not latest, try updating, it may have already been solved
- * Preview version is equal to the number of commits as seen in the main page
+* Preview version is equal to the number of commits as seen in the main page
 * Include steps to reproduce (if not obvious from description)
 * Include screenshot (if needed)
 * If it could be device-dependent, try reproducing on another device (if possible)

app/build.gradle.kts

@@ -1,5 +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")
@@ -8,6 +9,7 @@ plugins {
     kotlin("plugin.parcelize")
     kotlin("plugin.serialization")
     id("com.github.zellius.shortcut-helper")
+    id("com.squareup.sqldelight")
 }
 
 if (gradle.startParameter.taskRequests.toString().contains("Standard")) {
@@ -18,6 +20,8 @@ if (gradle.startParameter.taskRequests.toString().contains("Standard")) {
 
 shortcutHelper.setFilePath("./shortcuts.xml")
 
+val SUPPORTED_ABIS = setOf("armeabi-v7a", "arm64-v8a", "x86", "x86_64")
+
 android {
     namespace = "eu.kanade.tachiyomi"
     compileSdk = AndroidConfig.compileSdk
@@ -27,8 +31,8 @@ android {
         applicationId = "eu.kanade.tachiyomi.sy"
         minSdk = AndroidConfig.minSdk
         targetSdk = AndroidConfig.targetSdk
-        versionCode = 36
+        versionCode = 46
-        versionName = "1.8.5"
+        versionName = "1.9.0"
 
         buildConfigField("String", "COMMIT_COUNT", "\"${getCommitCount()}\"")
         buildConfigField("String", "COMMIT_SHA", "\"${getGitSha()}\"")
@@ -36,30 +40,54 @@ android {
         buildConfigField("boolean", "INCLUDE_UPDATER", "false")
 
         ndk {
-            abiFilters += setOf("armeabi-v7a", "arm64-v8a", "x86")
+            abiFilters += SUPPORTED_ABIS
         }
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
 
+    splits {
+        abi {
+            isEnable = true
+            reset()
+            include(*SUPPORTED_ABIS.toTypedArray())
+            isUniversalApk = true
+        }
+    }
+
     buildTypes {
         named("debug") {
             versionNameSuffix = "-${getCommitCount()}"
             applicationIdSuffix = ".debug"
+            isPseudoLocalesEnabled = true
         }
         create("releaseTest") {
             applicationIdSuffix = ".rt"
             //isMinifyEnabled = true
             //isShrinkResources = true
             setProguardFiles(listOf(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro"))
+            matchingFallbacks.add("release")
         }
         named("release") {
             isMinifyEnabled = true
             isShrinkResources = true
             setProguardFiles(listOf(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro"))
         }
+        create("benchmark") {
+            initWith(getByName("release"))
+
+            signingConfig = signingConfigs.getByName("debug")
+            matchingFallbacks.add("release")
+            isDebuggable = false
+            versionNameSuffix = "-benchmark"
+            applicationIdSuffix = ".benchmark"
+        }
     }
 
-    flavorDimensions += "default"
+    sourceSets {
+        getByName("benchmark").res.srcDirs("src/debug/res")
+    }
+
+    flavorDimensions.add("default")
 
     productFlavors {
         create("standard") {
@@ -70,7 +98,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"
         }
     }
@@ -84,7 +113,6 @@ android {
             "META-INF/README.md",
             "META-INF/NOTICE",
             "META-INF/*.kotlin_module",
-            "META-INF/*.version",
         ))
     }
 
@@ -94,6 +122,7 @@ android {
 
     buildFeatures {
         viewBinding = true
+        compose = true
 
         // Disable some unused things
         aidl = false
@@ -102,29 +131,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)
@@ -134,8 +204,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)
 
@@ -156,9 +227,6 @@ dependencies {
     // Data serialization (JSON, protobuf)
     implementation(kotlinx.bundles.serialization)
 
-    // JavaScript engine
-    implementation(libs.bundles.js.engine)
-
     // HTML parser
     implementation(libs.jsoup)
 
@@ -167,24 +235,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")
     }
@@ -195,22 +253,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)
-    implementation(libs.markwon)
+    implementation(libs.bundles.richtext)
-
+    implementation(libs.aboutLibraries.compose)
-    // Conductor
+    implementation(libs.cascade)
-    implementation(libs.bundles.conductor)
+    implementation(libs.bundles.voyager)
-
+    implementation(libs.wheelpicker)
-    // FlowBinding
+    implementation(libs.materialmotion.core)
-    implementation(libs.bundles.flowbinding)
 
     // Logging
     implementation(libs.logcat)
@@ -219,9 +274,6 @@ dependencies {
     // implementation(libs.acra.http)
     // "standardImplementation"(libs.firebase.analytics)
 
-    // Licenses
-    implementation(libs.aboutlibraries.core)
-
     // Shizuku
     implementation(libs.bundles.shizuku)
 
@@ -233,9 +285,6 @@ dependencies {
     implementation(libs.leakcanary.plumber)
 
     // SY -->
-    // Changelog
-    implementation(sylibs.changelog)
-
     // Text distance (EH)
     implementation (sylibs.simularity)
 
@@ -246,14 +295,23 @@ dependencies {
     // Better logging (EH)
     implementation(sylibs.xlog)
 
-    // Debug utils (EH)
-    debugImplementation(sylibs.debugOverlay.standard)
-    "releaseTestImplementation"(sylibs.debugOverlay.noop)
-    releaseImplementation(sylibs.debugOverlay.noop)
-    testImplementation(sylibs.debugOverlay.noop)
-
     // RatingBar (SY)
     implementation(sylibs.ratingbar)
+    implementation(sylibs.composeRatingbar)
+}
+
+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 {
@@ -264,30 +322,46 @@ tasks {
         }
     }
 
+    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(
-            "-opt-in=kotlin.Experimental",
+            "-opt-in=coil.annotation.ExperimentalCoilApi",
-            "-opt-in=kotlin.RequiresOptIn",
+            "-opt-in=com.google.accompanist.permissions.ExperimentalPermissionsApi",
-            "-opt-in=kotlin.ExperimentalStdlibApi",
+            "-opt-in=androidx.compose.foundation.layout.ExperimentalLayoutApi",
-            "-opt-in=kotlinx.coroutines.FlowPreview",
+            "-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",
-            "-opt-in=coil.annotation.ExperimentalCoilApi",
-            "-opt-in=kotlin.time.ExperimentalTime",
         )
-    }
 
-    // Duplicating Hebrew string assets due to some locale code issues on different devices
+        if (project.findProperty("tachiyomi.enableComposeCompilerMetrics") == "true") {
-    val copyHebrewStrings by registering(Copy::class) {
+            kotlinOptions.freeCompilerArgs += listOf(
-        from("./src/main/res/values-he")
+                "-P",
-        into("./src/main/res/values-iw")
+                "plugin:androidx.compose.compiler.plugins.kotlin:reportsDestination=" +
-        include("**/*")
+                    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)
     }
 }
 

app/proguard-rules.pro

@@ -1,36 +1,48 @@
 -dontobfuscate
 
-# Extensions may require methods unused in the core app
+# Keep common dependencies used in extensions
--dontwarn eu.kanade.tachiyomi.**
+-keep,allowoptimization class androidx.preference.** { public protected *; }
--keep class eu.kanade.tachiyomi.** { public protected private *; }
+-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 app.cash.quickjs.** { public protected *; }
+-keep,allowoptimization class uy.kohesive.injekt.** { public protected *; }
 
--keep class org.jsoup.** { *; }
+# From extensions-lib
--keep class kotlin.** { *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.network.interceptor.RateLimitInterceptorKt { public protected *; }
--keep class okhttp3.** { *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.network.interceptor.SpecificHostRateLimitInterceptorKt { public protected *; }
--keep class com.google.gson.** { *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.network.NetworkHelper { public protected *; }
--keep class com.github.salomonbrys.kotson.** { *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.network.OkHttpExtensionsKt { public protected *; }
--keep class com.squareup.duktape.** { *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.network.RequestsKt { public protected *; }
+-keep,allowoptimization class eu.kanade.tachiyomi.AppInfo { public protected *; }
 
-# === Keep EH classes
+# Debug functions
--keep class exh.** { *; }
+-keep,allowoptimization class exh.debug.DebugFunctions { public *; }
--keep class xyz.nulldev.** { *; }
 
-# === Keep RxAndroid, https://github.com/ReactiveX/RxAndroid/issues/350
+##---------------Begin: proguard configuration for RxJava 1.x  ----------
--keep class rx.android.** { *; }
+-dontwarn sun.misc.**
 
-# Design library
+-keepclassmembers class rx.internal.util.unsafe.*ArrayQueue*Field* {
--dontwarn com.google.android.material.**
+   long producerIndex;
--keep class com.google.android.material.** { *; }
+   long consumerIndex;
--keep interface com.google.android.material.** { *; }
--keep public class com.google.android.material.R$* { *; }
-
--keep class com.hippo.image.** { *; }
--keep interface com.hippo.image.** { *; }
--keepclassmembers class * extends nucleus.presenter.Presenter {
-    <init>();
 }
 
-# Kotlin Serialization
+-keepclassmembers class rx.internal.util.unsafe.BaseLinkedQueueProducerNodeRef {
+    rx.internal.util.atomic.LinkedQueueNode producerNode;
+}
+
+-keepclassmembers class rx.internal.util.unsafe.BaseLinkedQueueConsumerNodeRef {
+    rx.internal.util.atomic.LinkedQueueNode consumerNode;
+}
+
+-dontnote rx.internal.util.PlatformDependent
+##---------------End: proguard configuration for RxJava 1.x  ----------
+
+##---------------Begin: proguard configuration for kotlinx.serialization  ----------
 -keepattributes *Annotation*, InnerClasses
 -dontnote kotlinx.serialization.AnnotationsKt # core serialization annotations
 
@@ -42,11 +54,11 @@
     kotlinx.serialization.KSerializer serializer(...);
 }
 
--keep,includedescriptorclasses class eu.kanade.tachiyomi.**$$serializer { *; }
+-keep,includedescriptorclasses class eu.kanade.**$$serializer { *; }
--keepclassmembers class eu.kanade.tachiyomi.** {
+-keepclassmembers class eu.kanade.** {
     *** Companion;
 }
--keepclasseswithmembers class eu.kanade.tachiyomi.** {
+-keepclasseswithmembers class eu.kanade.** {
     kotlinx.serialization.KSerializer serializer(...);
 }
 
@@ -67,26 +79,11 @@
     kotlinx.serialization.KSerializer serializer(...);
 }
 
-# Keep extension's common dependencies
+-keep class kotlinx.serialization.**
--keep,allowoptimization class eu.kanade.tachiyomi.** { public protected *; }
+-keepclassmembers class kotlinx.serialization.** {
--keep,allowoptimization class androidx.preference.** { *; }
+    <methods>;
--keep,allowoptimization class kotlin.** { public protected *; }
+}
--keep,allowoptimization class kotlinx.coroutines.** { public protected *; }
+##---------------End: proguard configuration for kotlinx.serialization  ----------
--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 *; }
--keep,allowoptimization class kotlinx.serialization.** { public protected *; }
-
-# RxJava 1.1.0
--dontwarn sun.misc.**
-
--dontnote rx.internal.util.PlatformDependent
 
 # === Reactive network: https://github.com/pwittchen/ReactiveNetwork/tree/v0.12.4#proguard-configuration
 -dontwarn com.github.pwittchen.reactivenetwork.library.rx2.ReactiveNetwork
@@ -107,6 +104,21 @@
 # === Okio: https://github.com/square/okio/tree/9b8545e7fa267c9d89753283990f24a35cd69cd6#proguard
 -dontwarn okio.**
 
+# === Keep RxAndroid, https://github.com/ReactiveX/RxAndroid/issues/350
+-keep class rx.android.** { *; }
+
+# XmlUtil
+-keep public enum nl.adaptivity.xmlutil.EventType { *; }
+
+# Design library
+-dontwarn com.google.android.material.**
+-keep class com.google.android.material.** { *; }
+-keep interface com.google.android.material.** { *; }
+-keep public class com.google.android.material.R$* { *; }
+
+-keep class com.hippo.image.** { *; }
+-keep interface com.hippo.image.** { *; }
+
 # == Nucleus
 -keepclassmembers class * extends nucleus.presenter.Presenter {
     <init>();
@@ -118,12 +130,6 @@
 ## From original config: "Attempt to fix: java.lang.NoClassDefFoundError: uy.kohesive.injekt.registry.default.DefaultRegistrar$NOKEY$1"
 -keep class uy.kohesive.injekt.** { *; }
 
-# === Conductor
-# This isn't in the consumer proguard rules yet: https://github.com/bluelinelabs/Conductor/pull/550/files
--keepclassmembers public class * extends com.bluelinelabs.conductor.ControllerChangeHandler {
-   public <init>();
-}
-
 # === RxBinding
 -dontwarn com.google.auto.value.AutoValue
 

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="@color/ic_launcher_background"/>
     <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+    <monochrome android:drawable="@drawable/ic_tachi_monochrome_launcher" />
 </adaptive-icon>

app/src/main/AndroidManifest.xml

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
 
     <!-- Internet -->
     <uses-permission android:name="android.permission.INTERNET" />
@@ -22,6 +23,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 +37,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 +63,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"
@@ -173,6 +193,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" />
@@ -192,6 +226,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"
@@ -210,11 +253,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" />
+
         <!-- EH -->
         <activity
             android:name="exh.ui.intercept.InterceptActivity"
@@ -267,21 +317,6 @@
 
                 <data android:pathPattern="/g/..*" />
             </intent-filter>
-            <!-- Perv Eden -->
-            <intent-filter>
-                <action android:name="android.intent.action.VIEW" />
-
-                <category android:name="android.intent.category.DEFAULT" />
-                <category android:name="android.intent.category.BROWSABLE" />
-
-                <data android:scheme="https" />
-                <data android:scheme="http" />
-
-                <data android:host="perveden.com" />
-                <data android:host="www.perveden.com" />
-
-                <data android:pathPattern="/.*/.*-manga/.*" />
-            </intent-filter>
             <!-- Tsumino -->
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
@@ -298,22 +333,6 @@
                 <data android:pathPattern="/Read/View/..*" />
                 <data android:pathPattern="/Book/Info/..*" />
             </intent-filter>
-            <!-- Hitomi.la -->
-            <intent-filter>
-                <action android:name="android.intent.action.VIEW" />
-
-                <category android:name="android.intent.category.DEFAULT" />
-                <category android:name="android.intent.category.BROWSABLE" />
-
-                <data android:scheme="https" />
-                <data android:scheme="http" />
-
-                <data android:host="hitomi.la" />
-                <data android:host="www.hitomi.la" />
-
-                <data android:pathPattern="/reader/..*" />
-                <data android:pathPattern="/galleries/..*" />
-            </intent-filter>
             <!-- Pururin -->
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
@@ -362,10 +381,22 @@
                 <data android:pathPattern="/chapter/..*" />
             </intent-filter>
         </activity>
+
         <activity
-            android:name="exh.ui.captcha.BrowserActionActivity"
+            android:name="exh.md.MangaDexLoginActivity"
-            android:theme="@style/Theme.Tachiyomi"
+            android:label="MangaDexLogin"
-            android:exported="false"/>
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data
+                    android:host="mangadex-auth"
+                    android:scheme="tachiyomisy" />
+            </intent-filter>
+        </activity>
     </application>
 
 </manifest>

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) }
+}

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)

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
+}

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 }
+    }
+}

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,
+    )
+}

app/src/main/java/eu/kanade/data/AndroidDatabaseHandler.kt

@@ -0,0 +1,98 @@
+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.data.manga.LibraryQuery
+import eu.kanade.data.updates.UpdatesQuery
+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) }
+    }
+
+    // SY -->
+    fun getLibraryQuery() = LibraryQuery(driver)
+
+    fun getUpdatesQuery(after: Long) = UpdatesQuery(driver, after)
+    // SY <--
+}

app/src/main/java/eu/kanade/data/DatabaseAdapter.kt

@@ -0,0 +1,54 @@
+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()
+}
+
+// SY -->
+private const val listOfStringsAndSeparator = " & "
+val listOfStringsAndAdapter = object : ColumnAdapter<List<String>, String> {
+    override fun decode(databaseValue: String) =
+        if (databaseValue.isEmpty()) {
+            emptyList()
+        } else {
+            databaseValue.split(listOfStringsAndSeparator)
+        }
+    override fun encode(value: List<String>) = value.joinToString(separator = listOfStringsAndSeparator)
+}
+
+private const val listOfLongsSeparator = "/"
+val listOfLongsAdapter = object : ColumnAdapter<List<Long>, String> {
+    override fun decode(databaseValue: String) =
+        if (databaseValue.isEmpty()) {
+            emptyList()
+        } else {
+            databaseValue.split(listOfLongsSeparator).mapNotNull { it.toLongOrNull() }
+        }
+    override fun encode(value: List<Long>) = value.joinToString(separator = listOfLongsSeparator)
+}
+// SY <--

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>
+}

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

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

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,
+    )
+}

app/src/main/java/eu/kanade/data/category/CategoryRepositoryImpl.kt

@@ -0,0 +1,87 @@
+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)
+        }
+    }
+
+    // SY -->
+    override suspend fun insert(category: Category): Long {
+        return handler.awaitOne(true) {
+            categoriesQueries.insert(
+                name = category.name,
+                order = category.order,
+                flags = category.flags,
+            )
+            categoriesQueries.selectLastInsertedRowId()
+        }
+    }
+    // SY <--
+
+    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,
+            )
+        }
+    }
+}

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,
+        )
+    }

app/src/main/java/eu/kanade/data/chapter/ChapterRepositoryImpl.kt

@@ -0,0 +1,113 @@
+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) }
+    }
+
+    // SY -->
+    override suspend fun getChapterByUrl(url: String): List<Chapter> {
+        return handler.awaitList { chaptersQueries.getChapterByUrl(url, chapterMapper) }
+    }
+
+    override suspend fun getMergedChapterByMangaId(mangaId: Long): List<Chapter> {
+        return handler.awaitList { chaptersQueries.getMergedChaptersByMangaId(mangaId, chapterMapper) }
+    }
+
+    override suspend fun getMergedChapterByMangaIdAsFlow(mangaId: Long): Flow<List<Chapter>> {
+        return handler.subscribeToList { chaptersQueries.getMergedChaptersByMangaId(mangaId, chapterMapper) }
+    }
+    // SY <--
+}

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

app/src/main/java/eu/kanade/data/chapter/NoChaptersException.kt

@@ -0,0 +1,3 @@
+package eu.kanade.data.chapter
+
+class NoChaptersException : Exception()

app/src/main/java/eu/kanade/data/exh/FavoriteEntry.kt

@@ -0,0 +1,14 @@
+package eu.kanade.data.exh
+
+import exh.favorites.sql.models.FavoriteEntry
+
+val favoriteEntryMapper: (Long, String, String, String, Long) -> FavoriteEntry =
+    { id, title, gid, token, category ->
+        FavoriteEntry(
+            id = id,
+            title = title,
+            gid = gid,
+            token = token,
+            category = category.toInt(),
+        )
+    }

app/src/main/java/eu/kanade/data/exh/FeedSavedSearch.kt

@@ -0,0 +1,13 @@
+package eu.kanade.data.exh
+
+import exh.savedsearches.models.FeedSavedSearch
+
+val feedSavedSearchMapper: (Long, Long, Long?, Boolean) -> FeedSavedSearch =
+    { id, source, savedSearch, global ->
+        FeedSavedSearch(
+            id = id,
+            source = source,
+            savedSearch = savedSearch,
+            global = global,
+        )
+    }

app/src/main/java/eu/kanade/data/exh/MergedMangaReferenceMapper.kt

@@ -0,0 +1,20 @@
+package eu.kanade.data.exh
+
+import exh.merged.sql.models.MergedMangaReference
+
+val mergedMangaReferenceMapper =
+    { id: Long, isInfoManga: Boolean, getChapterUpdates: Boolean, chapterSortMode: Long, chapterPriority: Long, downloadChapters: Boolean, mergeId: Long, mergeUrl: String, mangaId: Long?, mangaUrl: String, mangaSourceId: Long ->
+        MergedMangaReference(
+            id = id,
+            isInfoManga = isInfoManga,
+            getChapterUpdates = getChapterUpdates,
+            chapterSortMode = chapterSortMode.toInt(),
+            chapterPriority = chapterPriority.toInt(),
+            downloadChapters = downloadChapters,
+            mergeId = mergeId,
+            mergeUrl = mergeUrl,
+            mangaId = mangaId,
+            mangaUrl = mangaUrl,
+            mangaSourceId = mangaSourceId,
+        )
+    }

app/src/main/java/eu/kanade/data/exh/SavedSearch.kt

@@ -0,0 +1,14 @@
+package eu.kanade.data.exh
+
+import exh.savedsearches.models.SavedSearch
+
+val savedSearchMapper: (Long, Long, String, String?, String?) -> SavedSearch =
+    { id, source, name, query, filtersJson ->
+        SavedSearch(
+            id = id,
+            source = source,
+            name = name,
+            query = query,
+            filtersJson = filtersJson,
+        )
+    }

app/src/main/java/eu/kanade/data/exh/SearchMetadataMapper.kt

@@ -0,0 +1,14 @@
+package eu.kanade.data.exh
+
+import exh.metadata.sql.models.SearchMetadata
+
+val searchMetadataMapper: (Long, String?, String, String?, Int) -> SearchMetadata =
+    { mangaId, uploader, extra, indexedExtra, extraVersion ->
+        SearchMetadata(
+            mangaId = mangaId,
+            uploader = uploader,
+            extra = extra,
+            indexedExtra = indexedExtra,
+            extraVersion = extraVersion,
+        )
+    }

app/src/main/java/eu/kanade/data/exh/SearchTag.kt

@@ -0,0 +1,14 @@
+package eu.kanade.data.exh
+
+import exh.metadata.sql.models.SearchTag
+
+val searchTagMapper: (Long, Long, String?, String, Int) -> SearchTag =
+    { id, mangaId, namespace, name, type ->
+        SearchTag(
+            id = id,
+            mangaId = mangaId,
+            namespace = namespace,
+            name = name,
+            type = type,
+        )
+    }

app/src/main/java/eu/kanade/data/exh/SearchTitle.kt

@@ -0,0 +1,13 @@
+package eu.kanade.data.exh
+
+import exh.metadata.sql.models.SearchTitle
+
+val searchTitleMapper: (Long, Long, String, Int) -> SearchTitle =
+    { id, mangaId, title, type ->
+        SearchTitle(
+            id = id,
+            mangaId = mangaId,
+            title = title,
+            type = type,
+        )
+    }

app/src/main/java/eu/kanade/data/history/HistoryMapper.kt

@@ -0,0 +1,37 @@
+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,
+        // SY -->
+        ogTitle = title,
+        // SY <--
+        chapterNumber = chapterNumber,
+        readAt = readAt,
+        readDuration = readDuration,
+        coverData = MangaCover(
+            mangaId = mangaId,
+            sourceId = sourceId,
+            isMangaFavorite = isFavorite,
+            url = thumbnailUrl,
+            lastModified = coverLastModified,
+        ),
+    )
+}

app/src/main/java/eu/kanade/data/history/HistoryRepositoryImpl.kt

@@ -0,0 +1,77 @@
+package eu.kanade.data.history
+
+import eu.kanade.data.DatabaseHandler
+import eu.kanade.domain.history.model.History
+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)
+        }
+    }
+
+    // SY -->
+    override suspend fun getByMangaId(mangaId: Long): List<History> {
+        return handler.awaitList { historyQueries.getHistoryByMangaId(mangaId, historyMapper) }
+    }
+    // SY <--
+}

app/src/main/java/eu/kanade/data/manga/FavoritesEntryRepositoryImpl.kt

@@ -0,0 +1,26 @@
+package eu.kanade.data.manga
+
+import eu.kanade.data.DatabaseHandler
+import eu.kanade.data.exh.favoriteEntryMapper
+import eu.kanade.domain.manga.repository.FavoritesEntryRepository
+import exh.favorites.sql.models.FavoriteEntry
+
+class FavoritesEntryRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : FavoritesEntryRepository {
+    override suspend fun deleteAll() {
+        handler.await { eh_favoritesQueries.deleteAll() }
+    }
+
+    override suspend fun insertAll(favoriteEntries: List<FavoriteEntry>) {
+        handler.await(true) {
+            favoriteEntries.forEach {
+                eh_favoritesQueries.insertEhFavorites(it.id, it.title, it.gid, it.token, it.category.toLong())
+            }
+        }
+    }
+
+    override suspend fun selectAll(): List<FavoriteEntry> {
+        return handler.awaitList { eh_favoritesQueries.selectAll(favoriteEntryMapper) }
+    }
+}

app/src/main/java/eu/kanade/data/manga/LibraryQuery.kt

@@ -0,0 +1,123 @@
+package eu.kanade.data.manga
+
+import com.squareup.sqldelight.Query
+import com.squareup.sqldelight.db.SqlCursor
+import com.squareup.sqldelight.db.SqlDriver
+import com.squareup.sqldelight.internal.copyOnWriteList
+import eu.kanade.data.listOfStringsAdapter
+import eu.kanade.data.listOfStringsAndAdapter
+import eu.kanade.data.updateStrategyAdapter
+import eu.kanade.domain.library.model.LibraryManga
+import exh.source.MERGED_SOURCE_ID
+
+private val mapper = { cursor: SqlCursor ->
+    LibraryManga(
+        manga = mangaMapper(
+            cursor.getLong(0)!!,
+            cursor.getLong(1)!!,
+            cursor.getString(2)!!,
+            cursor.getString(3),
+            cursor.getString(4),
+            cursor.getString(5),
+            cursor.getString(6)?.let(listOfStringsAdapter::decode),
+            cursor.getString(7)!!,
+            cursor.getLong(8)!!,
+            cursor.getString(9),
+            cursor.getLong(10)!! == 1L,
+            cursor.getLong(11) ?: 0,
+            null,
+            cursor.getLong(13)!! == 1L,
+            cursor.getLong(14)!!,
+            cursor.getLong(15)!!,
+            cursor.getLong(16)!!,
+            cursor.getLong(17)!!,
+            cursor.getString(18)?.let(listOfStringsAndAdapter::decode),
+            updateStrategyAdapter.decode(cursor.getLong(19)!!),
+        ),
+        totalChapters = cursor.getLong(20)!!,
+        readCount = cursor.getLong(21)!!,
+        latestUpload = cursor.getLong(22)!!,
+        chapterFetchedAt = cursor.getLong(23)!!,
+        lastRead = cursor.getLong(24)!!,
+        bookmarkCount = cursor.getLong(25)!!,
+        category = cursor.getLong(26)!!,
+    )
+}
+
+class LibraryQuery(val driver: SqlDriver) : Query<LibraryManga>(copyOnWriteList(), mapper) {
+    override fun execute(): SqlCursor {
+        return driver.executeQuery(
+            null,
+            """
+            SELECT
+                M.*,
+                coalesce(C.total, 0) AS totalCount,
+                coalesce(C.readCount, 0) AS readCount,
+                coalesce(C.latestUpload, 0) AS latestUpload,
+                coalesce(C.fetchedAt, 0) AS chapterFetchedAt,
+                coalesce(C.lastRead, 0) AS lastRead,
+                coalesce(C.bookmarkCount, 0) AS bookmarkCount,
+                coalesce(MC.category_id, 0) AS category
+            FROM mangas M
+            LEFT JOIN(
+                SELECT
+                    chapters.manga_id,
+                    count(*) AS total,
+                    sum(read) AS readCount,
+                    coalesce(max(chapters.date_upload), 0) AS latestUpload,
+                    coalesce(max(history.last_read), 0) AS lastRead,
+                    coalesce(max(chapters.date_fetch), 0) AS fetchedAt,
+                    sum(chapters.bookmark) AS bookmarkCount
+                FROM chapters
+                LEFT JOIN history
+                ON chapters._id = history.chapter_id
+                GROUP BY chapters.manga_id
+            ) AS C
+            ON M._id = C.manga_id
+            LEFT JOIN mangas_categories AS MC
+            ON MC.manga_id = M._id
+            WHERE M.favorite = 1 AND M.source <> $MERGED_SOURCE_ID
+            UNION
+            SELECT
+                M.*,
+                coalesce(C.total, 0) AS totalCount,
+                coalesce(C.readCount, 0) AS readCount,
+                coalesce(C.latestUpload, 0) AS latestUpload,
+                coalesce(C.fetchedAt, 0) AS chapterFetchedAt,
+                coalesce(C.lastRead, 0) AS lastRead,
+                coalesce(C.bookmarkCount, 0) AS bookmarkCount,
+                coalesce(MC.category_id, 0) AS category
+            FROM mangas M
+            LEFT JOIN (
+                SELECT merged.manga_id,merged.merge_id
+                FROM merged
+                GROUP BY merged.merge_id
+            ) as ME
+            ON ME.merge_id = M._id
+            LEFT JOIN(
+                SELECT
+                    ME.merge_id,
+                    count(*) AS total,
+                    sum(read) AS readCount,
+                    coalesce(max(chapters.date_upload), 0) AS latestUpload,
+                    coalesce(max(history.last_read), 0) AS lastRead,
+                    coalesce(max(chapters.date_fetch), 0) AS fetchedAt,
+                    sum(chapters.bookmark) AS bookmarkCount
+                FROM chapters
+                LEFT JOIN history
+                ON chapters._id = history.chapter_id
+                LEFT JOIN merged as ME
+                ON ME.manga_id = chapters.manga_id
+                GROUP BY ME.merge_id
+            ) AS C
+            ON ME.merge_id = C.merge_id
+            LEFT JOIN mangas_categories AS MC
+            ON MC.manga_id = M._id
+            WHERE M.favorite = 1 AND M.source = $MERGED_SOURCE_ID;
+            """.trimIndent(),
+            1,
+        )
+    }
+
+    override fun toString(): String = "LibraryQuery.sq:get"
+}

app/src/main/java/eu/kanade/data/manga/MangaMapper.kt

@@ -0,0 +1,71 @@
+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, List<String>?, UpdateStrategy) -> Manga =
+    { id, source, url, artist, author, description, genre, title, status, thumbnailUrl, favorite, lastUpdate, _, initialized, viewerFlags, chapterFlags, coverLastModified, dateAdded, filteredScanlators, updateStrategy ->
+        Manga(
+            id = id,
+            source = source,
+            favorite = favorite,
+            lastUpdate = lastUpdate ?: 0,
+            dateAdded = dateAdded,
+            viewerFlags = viewerFlags,
+            chapterFlags = chapterFlags,
+            coverLastModified = coverLastModified,
+            url = url,
+            // SY -->
+            ogTitle = title,
+            ogArtist = artist,
+            ogAuthor = author,
+            ogDescription = description,
+            ogGenre = genre,
+            ogStatus = status,
+            // SY <--
+            thumbnailUrl = thumbnailUrl,
+            updateStrategy = updateStrategy,
+            initialized = initialized,
+            // SY -->
+            filteredScanlators = filteredScanlators,
+            // SY <--
+        )
+    }
+
+val libraryManga: (Long, Long, String, String?, String?, String?, List<String>?, String, Long, String?, Boolean, Long?, Long?, Boolean, Long, Long, Long, Long, List<String>?, 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, filteredScanlators, 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,
+                // SY -->
+                filteredScanlators,
+                // SY <--
+                updateStrategy,
+            ),
+            category = category,
+            totalChapters = totalCount,
+            readCount = readCount,
+            bookmarkCount = bookmarkCount,
+            latestUpload = latestUpload,
+            chapterFetchedAt = chapterFetchedAt,
+            lastRead = lastRead,
+        )
+    }

app/src/main/java/eu/kanade/data/manga/MangaMergeRepositoryImpl.kt

@@ -0,0 +1,129 @@
+package eu.kanade.data.manga
+
+import eu.kanade.data.DatabaseHandler
+import eu.kanade.data.exh.mergedMangaReferenceMapper
+import eu.kanade.domain.manga.model.Manga
+import eu.kanade.domain.manga.model.MergeMangaSettingsUpdate
+import eu.kanade.domain.manga.repository.MangaMergeRepository
+import eu.kanade.tachiyomi.util.system.logcat
+import eu.kanade.tachiyomi.util.system.toLong
+import exh.merged.sql.models.MergedMangaReference
+import kotlinx.coroutines.flow.Flow
+import logcat.LogPriority
+
+class MangaMergeRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : MangaMergeRepository {
+
+    override suspend fun getMergedManga(): List<Manga> {
+        return handler.awaitList { mergedQueries.selectAllMergedMangas(mangaMapper) }
+    }
+
+    override suspend fun subscribeMergedManga(): Flow<List<Manga>> {
+        return handler.subscribeToList { mergedQueries.selectAllMergedMangas(mangaMapper) }
+    }
+
+    override suspend fun getMergedMangaById(id: Long): List<Manga> {
+        return handler.awaitList { mergedQueries.selectMergedMangasById(id, mangaMapper) }
+    }
+
+    override suspend fun subscribeMergedMangaById(id: Long): Flow<List<Manga>> {
+        return handler.subscribeToList { mergedQueries.selectMergedMangasById(id, mangaMapper) }
+    }
+
+    override suspend fun getReferencesById(id: Long): List<MergedMangaReference> {
+        return handler.awaitList { mergedQueries.selectByMergeId(id, mergedMangaReferenceMapper) }
+    }
+
+    override suspend fun subscribeReferencesById(id: Long): Flow<List<MergedMangaReference>> {
+        return handler.subscribeToList { mergedQueries.selectByMergeId(id, mergedMangaReferenceMapper) }
+    }
+
+    override suspend fun updateSettings(update: MergeMangaSettingsUpdate): Boolean {
+        return try {
+            partialUpdate(update)
+            true
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            false
+        }
+    }
+
+    override suspend fun updateAllSettings(values: List<MergeMangaSettingsUpdate>): Boolean {
+        return try {
+            partialUpdate(*values.toTypedArray())
+            true
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            false
+        }
+    }
+
+    private suspend fun partialUpdate(vararg values: MergeMangaSettingsUpdate) {
+        handler.await(inTransaction = true) {
+            values.forEach { value ->
+                mergedQueries.updateSettingsById(
+                    id = value.id,
+                    getChapterUpdates = value.getChapterUpdates?.toLong(),
+                    downloadChapters = value.downloadChapters?.toLong(),
+                    infoManga = value.isInfoManga?.toLong(),
+                    chapterPriority = value.chapterPriority?.toLong(),
+                    chapterSortMode = value.chapterSortMode?.toLong(),
+                )
+            }
+        }
+    }
+
+    override suspend fun insert(reference: MergedMangaReference): Long? {
+        return handler.awaitOneOrNull {
+            mergedQueries.insert(
+                infoManga = reference.isInfoManga,
+                getChapterUpdates = reference.getChapterUpdates,
+                chapterSortMode = reference.chapterSortMode.toLong(),
+                chapterPriority = reference.chapterPriority.toLong(),
+                downloadChapters = reference.downloadChapters,
+                mergeId = reference.mergeId!!,
+                mergeUrl = reference.mergeUrl,
+                mangaId = reference.mangaId,
+                mangaUrl = reference.mangaUrl,
+                mangaSource = reference.mangaSourceId,
+            )
+            mergedQueries.selectLastInsertedRowId()
+        }
+    }
+
+    override suspend fun insertAll(references: List<MergedMangaReference>) {
+        handler.await(true) {
+            references.forEach { reference ->
+                mergedQueries.insert(
+                    infoManga = reference.isInfoManga,
+                    getChapterUpdates = reference.getChapterUpdates,
+                    chapterSortMode = reference.chapterSortMode.toLong(),
+                    chapterPriority = reference.chapterPriority.toLong(),
+                    downloadChapters = reference.downloadChapters,
+                    mergeId = reference.mergeId!!,
+                    mergeUrl = reference.mergeUrl,
+                    mangaId = reference.mangaId,
+                    mangaUrl = reference.mangaUrl,
+                    mangaSource = reference.mangaSourceId,
+                )
+            }
+        }
+    }
+
+    override suspend fun deleteById(id: Long) {
+        handler.await {
+            mergedQueries.deleteById(id)
+        }
+    }
+
+    override suspend fun deleteByMergeId(mergeId: Long) {
+        handler.await {
+            mergedQueries.deleteByMergeId(mergeId)
+        }
+    }
+
+    override suspend fun getMergeMangaForDownloading(mergeId: Long): List<Manga> {
+        return handler.awaitList { mergedQueries.selectMergedMangasForDownloadingById(mergeId, mangaMapper) }
+    }
+}

app/src/main/java/eu/kanade/data/manga/MangaMetadataRepositoryImpl.kt

@@ -0,0 +1,74 @@
+package eu.kanade.data.manga
+
+import eu.kanade.data.DatabaseHandler
+import eu.kanade.data.exh.searchMetadataMapper
+import eu.kanade.data.exh.searchTagMapper
+import eu.kanade.data.exh.searchTitleMapper
+import eu.kanade.domain.manga.model.Manga
+import eu.kanade.domain.manga.repository.MangaMetadataRepository
+import exh.metadata.metadata.base.FlatMetadata
+import exh.metadata.sql.models.SearchMetadata
+import exh.metadata.sql.models.SearchTag
+import exh.metadata.sql.models.SearchTitle
+import exh.source.EH_SOURCE_ID
+import exh.source.EXH_SOURCE_ID
+import kotlinx.coroutines.flow.Flow
+
+class MangaMetadataRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : MangaMetadataRepository {
+
+    override suspend fun getMetadataById(id: Long): SearchMetadata? {
+        return handler.awaitOneOrNull { search_metadataQueries.selectByMangaId(id, searchMetadataMapper) }
+    }
+
+    override fun subscribeMetadataById(id: Long): Flow<SearchMetadata?> {
+        return handler.subscribeToOneOrNull { search_metadataQueries.selectByMangaId(id, searchMetadataMapper) }
+    }
+
+    override suspend fun getTagsById(id: Long): List<SearchTag> {
+        return handler.awaitList { search_tagsQueries.selectByMangaId(id, searchTagMapper) }
+    }
+
+    override fun subscribeTagsById(id: Long): Flow<List<SearchTag>> {
+        return handler.subscribeToList { search_tagsQueries.selectByMangaId(id, searchTagMapper) }
+    }
+
+    override suspend fun getTitlesById(id: Long): List<SearchTitle> {
+        return handler.awaitList { search_titlesQueries.selectByMangaId(id, searchTitleMapper) }
+    }
+
+    override fun subscribeTitlesById(id: Long): Flow<List<SearchTitle>> {
+        return handler.subscribeToList { search_titlesQueries.selectByMangaId(id, searchTitleMapper) }
+    }
+
+    override suspend fun insertFlatMetadata(flatMetadata: FlatMetadata) {
+        require(flatMetadata.metadata.mangaId != -1L)
+
+        handler.await(true) {
+            flatMetadata.metadata.run {
+                search_metadataQueries.upsert(mangaId, uploader, extra, indexedExtra, extraVersion)
+            }
+            search_tagsQueries.deleteByManga(flatMetadata.metadata.mangaId)
+            flatMetadata.tags.forEach {
+                search_tagsQueries.insert(it.mangaId, it.namespace, it.name, it.type)
+            }
+            search_titlesQueries.deleteByManga(flatMetadata.metadata.mangaId)
+            flatMetadata.titles.forEach {
+                search_titlesQueries.insert(it.mangaId, it.title, it.type)
+            }
+        }
+    }
+
+    override suspend fun getExhFavoriteMangaWithMetadata(): List<Manga> {
+        return handler.awaitList { mangasQueries.getEhMangaWithMetadata(EH_SOURCE_ID, EXH_SOURCE_ID, mangaMapper) }
+    }
+
+    override suspend fun getIdsOfFavoriteMangaWithMetadata(): List<Long> {
+        return handler.awaitList { mangasQueries.getIdsOfFavoriteMangaWithMetadata() }
+    }
+
+    override suspend fun getSearchMetadata(): List<SearchMetadata> {
+        return handler.awaitList { search_metadataQueries.selectAll(searchMetadataMapper) }
+    }
+}

app/src/main/java/eu/kanade/data/manga/MangaRepositoryImpl.kt

@@ -0,0 +1,180 @@
+package eu.kanade.data.manga
+
+import eu.kanade.data.AndroidDatabaseHandler
+import eu.kanade.data.DatabaseHandler
+import eu.kanade.data.listOfStringsAdapter
+import eu.kanade.data.listOfStringsAndAdapter
+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 kotlinx.coroutines.flow.map
+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 { (handler as AndroidDatabaseHandler).getLibraryQuery() }
+        // return handler.awaitList { libraryViewQueries.library(libraryManga) }
+    }
+
+    override fun getLibraryMangaAsFlow(): Flow<List<LibraryManga>> {
+        return handler.subscribeToList { libraryViewQueries.library(libraryManga) }
+            // SY -->
+            .map { getLibraryManga() }
+        // SY <--
+    }
+
+    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) {
+            // SY -->
+            if (mangasQueries.getIdByUrlAndSource(manga.url, manga.source).executeAsOneOrNull() != null) {
+                return@awaitOneOrNull mangasQueries.getIdByUrlAndSource(manga.url, manga.source)
+            }
+            // SY <--
+            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,
+                // SY -->
+                filteredScanlators = manga.filteredScanlators,
+                // SY <--
+                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,
+                    // SY -->
+                    filteredScanlators = value.filteredScanlators?.let(listOfStringsAndAdapter::encode),
+                    // SY <--
+                    mangaId = value.id,
+                    updateStrategy = value.updateStrategy?.let(updateStrategyAdapter::encode),
+                )
+            }
+        }
+    }
+
+    // SY -->
+    override suspend fun getMangaBySourceId(sourceId: Long): List<Manga> {
+        return handler.awaitList { mangasQueries.getBySource(sourceId, mangaMapper) }
+    }
+
+    override suspend fun getAll(): List<Manga> {
+        return handler.awaitList { mangasQueries.getAll(mangaMapper) }
+    }
+
+    override suspend fun deleteManga(mangaId: Long) {
+        handler.await { mangasQueries.deleteById(mangaId) }
+    }
+    // SY <--
+}

app/src/main/java/eu/kanade/data/source/EHentaiPagingSource.kt

@@ -0,0 +1,45 @@
+package eu.kanade.data.source
+
+import eu.kanade.tachiyomi.source.model.FilterList
+import eu.kanade.tachiyomi.source.model.MangasPage
+import eu.kanade.tachiyomi.source.model.MetadataMangasPage
+import eu.kanade.tachiyomi.source.model.SManga
+import eu.kanade.tachiyomi.source.online.all.EHentai
+import eu.kanade.tachiyomi.util.lang.awaitSingle
+import exh.metadata.metadata.base.RaisedSearchMetadata
+
+abstract class EHentaiPagingSource(override val source: EHentai) : SourcePagingSource(source) {
+
+    override fun getPageLoadResult(
+        params: LoadParams<Long>,
+        mangasPage: MangasPage,
+    ): LoadResult.Page<Long, Pair<SManga, RaisedSearchMetadata?>> {
+        mangasPage as MetadataMangasPage
+        val metadata = mangasPage.mangasMetadata
+
+        return LoadResult.Page(
+            data = mangasPage.mangas
+                .mapIndexed { index, sManga -> sManga to metadata.getOrNull(index) },
+            prevKey = null,
+            nextKey = mangasPage.nextKey,
+        )
+    }
+}
+
+class EHentaiSearchPagingSource(source: EHentai, val query: String, val filters: FilterList) : EHentaiPagingSource(source) {
+    override suspend fun requestNextPage(currentPage: Int): MangasPage {
+        return source.fetchSearchManga(currentPage, query, filters).awaitSingle()
+    }
+}
+
+class EHentaiPopularPagingSource(source: EHentai) : EHentaiPagingSource(source) {
+    override suspend fun requestNextPage(currentPage: Int): MangasPage {
+        return source.fetchPopularManga(currentPage).awaitSingle()
+    }
+}
+
+class EHentaiLatestPagingSource(source: EHentai) : EHentaiPagingSource(source) {
+    override suspend fun requestNextPage(currentPage: Int): MangasPage {
+        return source.fetchLatestUpdates(currentPage).awaitSingle()
+    }
+}

app/src/main/java/eu/kanade/data/source/FeedSavedSearchRepositoryImpl.kt

@@ -0,0 +1,73 @@
+package eu.kanade.data.source
+
+import eu.kanade.data.DatabaseHandler
+import eu.kanade.data.exh.feedSavedSearchMapper
+import eu.kanade.data.exh.savedSearchMapper
+import eu.kanade.domain.source.repository.FeedSavedSearchRepository
+import exh.savedsearches.models.FeedSavedSearch
+import exh.savedsearches.models.SavedSearch
+import kotlinx.coroutines.flow.Flow
+
+class FeedSavedSearchRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : FeedSavedSearchRepository {
+
+    override suspend fun getGlobal(): List<FeedSavedSearch> {
+        return handler.awaitList { feed_saved_searchQueries.selectAllGlobal(feedSavedSearchMapper) }
+    }
+
+    override fun getGlobalAsFlow(): Flow<List<FeedSavedSearch>> {
+        return handler.subscribeToList { feed_saved_searchQueries.selectAllGlobal(feedSavedSearchMapper) }
+    }
+
+    override suspend fun getGlobalFeedSavedSearch(): List<SavedSearch> {
+        return handler.awaitList { feed_saved_searchQueries.selectGlobalFeedSavedSearch(savedSearchMapper) }
+    }
+
+    override suspend fun countGlobal(): Long {
+        return handler.awaitOne { feed_saved_searchQueries.countGlobal() }
+    }
+
+    override suspend fun getBySourceId(sourceId: Long): List<FeedSavedSearch> {
+        return handler.awaitList { feed_saved_searchQueries.selectBySource(sourceId, feedSavedSearchMapper) }
+    }
+
+    override fun getBySourceIdAsFlow(sourceId: Long): Flow<List<FeedSavedSearch>> {
+        return handler.subscribeToList { feed_saved_searchQueries.selectBySource(sourceId, feedSavedSearchMapper) }
+    }
+
+    override suspend fun getBySourceIdFeedSavedSearch(sourceId: Long): List<SavedSearch> {
+        return handler.awaitList { feed_saved_searchQueries.selectSourceFeedSavedSearch(sourceId, savedSearchMapper) }
+    }
+
+    override suspend fun countBySourceId(sourceId: Long): Long {
+        return handler.awaitOne { feed_saved_searchQueries.countSourceFeedSavedSearch(sourceId) }
+    }
+
+    override suspend fun delete(feedSavedSearchId: Long) {
+        handler.await { feed_saved_searchQueries.deleteById(feedSavedSearchId) }
+    }
+
+    override suspend fun insert(feedSavedSearch: FeedSavedSearch): Long {
+        return handler.awaitOne(true) {
+            feed_saved_searchQueries.insert(
+                feedSavedSearch.source,
+                feedSavedSearch.savedSearch,
+                feedSavedSearch.global,
+            )
+            feed_saved_searchQueries.selectLastInsertedRowId()
+        }
+    }
+
+    override suspend fun insertAll(feedSavedSearch: List<FeedSavedSearch>) {
+        return handler.await(true) {
+            feedSavedSearch.forEach {
+                feed_saved_searchQueries.insert(
+                    it.source,
+                    it.savedSearch,
+                    it.global,
+                )
+            }
+        }
+    }
+}

app/src/main/java/eu/kanade/data/source/NoResultsException.kt

@@ -0,0 +1,3 @@
+package eu.kanade.data.source
+
+class NoResultsException : Exception()

app/src/main/java/eu/kanade/data/source/SavedSearchRepositoryImpl.kt

@@ -0,0 +1,53 @@
+package eu.kanade.data.source
+
+import eu.kanade.data.DatabaseHandler
+import eu.kanade.data.exh.savedSearchMapper
+import eu.kanade.domain.source.repository.SavedSearchRepository
+import exh.savedsearches.models.SavedSearch
+import kotlinx.coroutines.flow.Flow
+
+class SavedSearchRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : SavedSearchRepository {
+
+    override suspend fun getById(savedSearchId: Long): SavedSearch? {
+        return handler.awaitOneOrNull { saved_searchQueries.selectById(savedSearchId, savedSearchMapper) }
+    }
+
+    override suspend fun getBySourceId(sourceId: Long): List<SavedSearch> {
+        return handler.awaitList { saved_searchQueries.selectBySource(sourceId, savedSearchMapper) }
+    }
+
+    override fun getBySourceIdAsFlow(sourceId: Long): Flow<List<SavedSearch>> {
+        return handler.subscribeToList { saved_searchQueries.selectBySource(sourceId, savedSearchMapper) }
+    }
+
+    override suspend fun delete(savedSearchId: Long) {
+        handler.await { saved_searchQueries.deleteById(savedSearchId) }
+    }
+
+    override suspend fun insert(savedSearch: SavedSearch): Long {
+        return handler.awaitOne(true) {
+            saved_searchQueries.insert(
+                savedSearch.source,
+                savedSearch.name,
+                savedSearch.query,
+                savedSearch.filtersJson,
+            )
+            saved_searchQueries.selectLastInsertedRowId()
+        }
+    }
+
+    override suspend fun insertAll(savedSearch: List<SavedSearch>) {
+        handler.await(true) {
+            savedSearch.forEach {
+                saved_searchQueries.insert(
+                    it.source,
+                    it.name,
+                    it.query,
+                    it.filtersJson,
+                )
+            }
+        }
+    }
+}

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) }
+    }
+}

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)
+}

app/src/main/java/eu/kanade/data/source/SourcePagingSource.kt

@@ -0,0 +1,85 @@
+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.MetadataMangasPage
+import eu.kanade.tachiyomi.source.model.SManga
+import eu.kanade.tachiyomi.util.lang.awaitSingle
+import eu.kanade.tachiyomi.util.lang.withIOContext
+import exh.metadata.metadata.base.RaisedSearchMetadata
+
+abstract class SourcePagingSource(
+    protected open val source: CatalogueSource,
+) : SourcePagingSourceType() {
+
+    abstract suspend fun requestNextPage(currentPage: Int): MangasPage
+
+    override suspend fun load(params: LoadParams<Long>): LoadResult<Long, /*SY --> */ Pair<SManga, RaisedSearchMetadata?>/*SY <-- */> {
+        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)
+        }
+
+        // SY -->
+        return getPageLoadResult(params, mangasPage)
+        // SY <--
+    }
+
+    // SY -->
+    open fun getPageLoadResult(params: LoadParams<Long>, mangasPage: MangasPage): LoadResult.Page<Long, /*SY --> */ Pair<SManga, RaisedSearchMetadata?>/*SY <-- */> {
+        val page = params.key ?: 1
+
+        // SY -->
+        val metadata = if (mangasPage is MetadataMangasPage) {
+            mangasPage.mangasMetadata
+        } else {
+            emptyList()
+        }
+        // SY <--
+
+        return LoadResult.Page(
+            data = mangasPage.mangas
+                // SY -->
+                .mapIndexed { index, sManga -> sManga to metadata.getOrNull(index) },
+            // SY <--
+            prevKey = null,
+            nextKey = if (mangasPage.hasNextPage) page + 1 else null,
+        )
+    }
+    // SY <--
+
+    override fun getRefreshKey(state: PagingState<Long, /*SY --> */ Pair<SManga, RaisedSearchMetadata?>/*SY <-- */>): 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()
+    }
+}

app/src/main/java/eu/kanade/data/source/SourceRepositoryImpl.kt

@@ -0,0 +1,91 @@
+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 eu.kanade.tachiyomi.source.online.all.EHentai
+import exh.source.MERGED_SOURCE_ID
+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 /* SY --> */ || it.source == MERGED_SOURCE_ID /* SY <-- */ }
+                .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
+        // SY -->
+        if (source is EHentai) {
+            return EHentaiSearchPagingSource(source, query, filterList)
+        }
+        // SY <--
+        return SourceSearchPagingSource(source, query, filterList)
+    }
+
+    override fun getPopular(sourceId: Long): SourcePagingSourceType {
+        val source = sourceManager.get(sourceId) as CatalogueSource
+        // SY -->
+        if (source is EHentai) {
+            return EHentaiPopularPagingSource(source)
+        }
+        // SY <--
+        return SourcePopularPagingSource(source)
+    }
+
+    override fun getLatest(sourceId: Long): SourcePagingSourceType {
+        val source = sourceManager.get(sourceId) as CatalogueSource
+        // SY -->
+        if (source is EHentai) {
+            return EHentaiLatestPagingSource(source)
+        }
+        // SY <--
+        return SourceLatestPagingSource(source)
+    }
+}

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,
+        )
+    }

app/src/main/java/eu/kanade/data/track/TrackRepositoryImpl.kt

@@ -0,0 +1,85 @@
+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) }
+    }
+
+    // SY -->
+    override suspend fun getTracks(): List<Track> {
+        return handler.awaitList {
+            manga_syncQueries.getTracks(trackMapper)
+        }
+    }
+
+    override suspend fun getTracksByMangaIds(mangaIds: List<Long>): List<Track> {
+        return handler.awaitList {
+            manga_syncQueries.getTracksByMangaIds(mangaIds, trackMapper)
+        }
+    }
+    // SY <--
+
+    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,
+                )
+            }
+        }
+    }
+}

app/src/main/java/eu/kanade/data/updates/UpdatesMapper.kt

@@ -0,0 +1,28 @@
+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,
+        // SY -->
+        ogMangaTitle = mangaTitle,
+        // SY <--
+        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,
+        ),
+    )
+}

app/src/main/java/eu/kanade/data/updates/UpdatesQuery.kt

@@ -0,0 +1,89 @@
+package eu.kanade.data.updates
+
+import com.squareup.sqldelight.Query
+import com.squareup.sqldelight.db.SqlCursor
+import com.squareup.sqldelight.db.SqlDriver
+import com.squareup.sqldelight.internal.copyOnWriteList
+import eu.kanade.domain.updates.model.UpdatesWithRelations
+import exh.source.MERGED_SOURCE_ID
+
+private val mapper = { cursor: SqlCursor ->
+    updateWithRelationMapper(
+        cursor.getLong(0)!!,
+        cursor.getString(1)!!,
+        cursor.getLong(2)!!,
+        cursor.getString(3)!!,
+        cursor.getString(4),
+        cursor.getLong(5)!! == 1L,
+        cursor.getLong(6)!! == 1L,
+        cursor.getLong(7)!!,
+        cursor.getLong(8)!! == 1L,
+        cursor.getString(9),
+        cursor.getLong(10)!!,
+        cursor.getLong(11)!!,
+        cursor.getLong(12)!!,
+    )
+}
+
+class UpdatesQuery(val driver: SqlDriver, val after: Long) : Query<UpdatesWithRelations>(copyOnWriteList(), mapper) {
+    override fun execute(): SqlCursor {
+        return driver.executeQuery(
+            null,
+            """
+            SELECT
+                mangas._id AS mangaId,
+                mangas.title AS mangaTitle,
+                chapters._id AS chapterId,
+                chapters.name AS chapterName,
+                chapters.scanlator,
+                chapters.read,
+                chapters.bookmark,
+                mangas.source,
+                mangas.favorite,
+                mangas.thumbnail_url AS thumbnailUrl,
+                mangas.cover_last_modified AS coverLastModified,
+                chapters.date_upload AS dateUpload,
+                chapters.date_fetch AS datefetch
+            FROM mangas JOIN chapters
+            ON mangas._id = chapters.manga_id
+            WHERE favorite = 1 AND source <> $MERGED_SOURCE_ID
+            AND date_fetch > date_added
+            AND dateUpload > :after
+            UNION
+            SELECT
+                mangas._id AS mangaId,
+                mangas.title AS mangaTitle,
+                chapters._id AS chapterId,
+                chapters.name AS chapterName,
+                chapters.scanlator,
+                chapters.read,
+                chapters.bookmark,
+                mangas.source,
+                mangas.favorite,
+                mangas.thumbnail_url AS thumbnailUrl,
+                mangas.cover_last_modified AS coverLastModified,
+                chapters.date_upload AS dateUpload,
+                chapters.date_fetch AS datefetch
+            FROM mangas
+            LEFT JOIN (
+                SELECT merged.manga_id,merged.merge_id
+                FROM merged
+                GROUP BY merged.merge_id
+            ) as ME
+            ON ME.merge_id = mangas._id
+            JOIN chapters
+            ON ME.manga_id = chapters.manga_id
+            WHERE favorite = 1 AND source = $MERGED_SOURCE_ID
+            AND date_fetch > date_added
+            AND dateUpload > :after
+            ORDER BY datefetch DESC;
+            """.trimIndent(),
+            1,
+            binders = {
+                bindLong(1, after)
+            },
+        )
+    }
+
+    override fun toString(): String = "LibraryQuery.sq:get"
+}

app/src/main/java/eu/kanade/data/updates/UpdatesRepositoryImpl.kt

@@ -0,0 +1,21 @@
+package eu.kanade.data.updates
+
+import eu.kanade.data.AndroidDatabaseHandler
+import eu.kanade.data.DatabaseHandler
+import eu.kanade.domain.updates.model.UpdatesWithRelations
+import eu.kanade.domain.updates.repository.UpdatesRepository
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+
+class UpdatesRepositoryImpl(
+    val databaseHandler: DatabaseHandler,
+) : UpdatesRepository {
+
+    override fun subscribeAll(after: Long): Flow<List<UpdatesWithRelations>> {
+        return databaseHandler.subscribeToList {
+            updatesViewQueries.updates(after, updateWithRelationMapper)
+        }.map {
+            databaseHandler.awaitList { (databaseHandler as AndroidDatabaseHandler).getUpdatesQuery(after) }
+        }
+    }
+}

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(), 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(), 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()) }
+    }
+}

app/src/main/java/eu/kanade/domain/SYDomainModule.kt

@@ -0,0 +1,152 @@
+package eu.kanade.domain
+
+import eu.kanade.data.manga.FavoritesEntryRepositoryImpl
+import eu.kanade.data.manga.MangaMergeRepositoryImpl
+import eu.kanade.data.manga.MangaMetadataRepositoryImpl
+import eu.kanade.data.source.FeedSavedSearchRepositoryImpl
+import eu.kanade.data.source.SavedSearchRepositoryImpl
+import eu.kanade.domain.chapter.interactor.DeleteChapters
+import eu.kanade.domain.chapter.interactor.GetChapterByUrl
+import eu.kanade.domain.chapter.interactor.GetMergedChapterByMangaId
+import eu.kanade.domain.history.interactor.GetHistoryByMangaId
+import eu.kanade.domain.manga.interactor.CreateSortTag
+import eu.kanade.domain.manga.interactor.DeleteByMergeId
+import eu.kanade.domain.manga.interactor.DeleteFavoriteEntries
+import eu.kanade.domain.manga.interactor.DeleteMangaById
+import eu.kanade.domain.manga.interactor.DeleteMergeById
+import eu.kanade.domain.manga.interactor.DeleteSortTag
+import eu.kanade.domain.manga.interactor.GetAllManga
+import eu.kanade.domain.manga.interactor.GetExhFavoriteMangaWithMetadata
+import eu.kanade.domain.manga.interactor.GetFavoriteEntries
+import eu.kanade.domain.manga.interactor.GetFlatMetadataById
+import eu.kanade.domain.manga.interactor.GetIdsOfFavoriteMangaWithMetadata
+import eu.kanade.domain.manga.interactor.GetManga
+import eu.kanade.domain.manga.interactor.GetMangaBySource
+import eu.kanade.domain.manga.interactor.GetMergedManga
+import eu.kanade.domain.manga.interactor.GetMergedMangaById
+import eu.kanade.domain.manga.interactor.GetMergedMangaForDownloading
+import eu.kanade.domain.manga.interactor.GetMergedReferencesById
+import eu.kanade.domain.manga.interactor.GetPagePreviews
+import eu.kanade.domain.manga.interactor.GetSearchMetadata
+import eu.kanade.domain.manga.interactor.GetSearchTags
+import eu.kanade.domain.manga.interactor.GetSearchTitles
+import eu.kanade.domain.manga.interactor.GetSortTag
+import eu.kanade.domain.manga.interactor.InsertFavoriteEntries
+import eu.kanade.domain.manga.interactor.InsertFlatMetadata
+import eu.kanade.domain.manga.interactor.InsertMergedReference
+import eu.kanade.domain.manga.interactor.ReorderSortTag
+import eu.kanade.domain.manga.interactor.SetMangaFilteredScanlators
+import eu.kanade.domain.manga.interactor.UpdateMergedSettings
+import eu.kanade.domain.manga.repository.FavoritesEntryRepository
+import eu.kanade.domain.manga.repository.MangaMergeRepository
+import eu.kanade.domain.manga.repository.MangaMetadataRepository
+import eu.kanade.domain.source.interactor.CountFeedSavedSearchBySourceId
+import eu.kanade.domain.source.interactor.CountFeedSavedSearchGlobal
+import eu.kanade.domain.source.interactor.CreateSourceCategory
+import eu.kanade.domain.source.interactor.CreateSourceRepo
+import eu.kanade.domain.source.interactor.DeleteFeedSavedSearchById
+import eu.kanade.domain.source.interactor.DeleteSavedSearchById
+import eu.kanade.domain.source.interactor.DeleteSourceCategory
+import eu.kanade.domain.source.interactor.DeleteSourceRepos
+import eu.kanade.domain.source.interactor.GetExhSavedSearch
+import eu.kanade.domain.source.interactor.GetFeedSavedSearchBySourceId
+import eu.kanade.domain.source.interactor.GetFeedSavedSearchGlobal
+import eu.kanade.domain.source.interactor.GetSavedSearchById
+import eu.kanade.domain.source.interactor.GetSavedSearchBySourceId
+import eu.kanade.domain.source.interactor.GetSavedSearchBySourceIdFeed
+import eu.kanade.domain.source.interactor.GetSavedSearchGlobalFeed
+import eu.kanade.domain.source.interactor.GetShowLatest
+import eu.kanade.domain.source.interactor.GetSourceCategories
+import eu.kanade.domain.source.interactor.GetSourceRepos
+import eu.kanade.domain.source.interactor.InsertFeedSavedSearch
+import eu.kanade.domain.source.interactor.InsertSavedSearch
+import eu.kanade.domain.source.interactor.RenameSourceCategory
+import eu.kanade.domain.source.interactor.SetSourceCategories
+import eu.kanade.domain.source.interactor.ToggleExcludeFromDataSaver
+import eu.kanade.domain.source.repository.FeedSavedSearchRepository
+import eu.kanade.domain.source.repository.SavedSearchRepository
+import eu.kanade.tachiyomi.source.online.MetadataSource
+import exh.search.SearchEngine
+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
+import xyz.nulldev.ts.api.http.serializer.FilterSerializer
+
+class SYDomainModule : InjektModule {
+
+    override fun InjektRegistrar.registerInjectables() {
+        addFactory { GetShowLatest(get()) }
+        addFactory { ToggleExcludeFromDataSaver(get()) }
+        addFactory { SetSourceCategories(get()) }
+        addFactory { SetMangaFilteredScanlators(get()) }
+        addFactory { GetAllManga(get()) }
+        addFactory { GetMangaBySource(get()) }
+        addFactory { DeleteChapters(get()) }
+        addFactory { DeleteMangaById(get()) }
+        addFactory { FilterSerializer() }
+        addFactory { GetHistoryByMangaId(get()) }
+        addFactory { GetChapterByUrl(get()) }
+        addFactory { CreateSourceRepo(get()) }
+        addFactory { DeleteSourceRepos(get()) }
+        addFactory { GetSourceRepos(get()) }
+        addFactory { GetSourceCategories(get()) }
+        addFactory { CreateSourceCategory(get()) }
+        addFactory { RenameSourceCategory(get(), get()) }
+        addFactory { DeleteSourceCategory(get()) }
+        addFactory { GetSortTag(get()) }
+        addFactory { CreateSortTag(get(), get()) }
+        addFactory { DeleteSortTag(get(), get()) }
+        addFactory { ReorderSortTag(get(), get()) }
+        addFactory { GetPagePreviews(get(), get()) }
+        addFactory { SearchEngine() }
+
+        // Required for [MetadataSource]
+        addFactory<MetadataSource.GetMangaId> { GetManga(get()) }
+        addFactory<MetadataSource.GetFlatMetadataById> { GetFlatMetadataById(get()) }
+        addFactory<MetadataSource.InsertFlatMetadata> { InsertFlatMetadata(get()) }
+
+        addSingletonFactory<MangaMetadataRepository> { MangaMetadataRepositoryImpl(get()) }
+        addFactory { GetFlatMetadataById(get()) }
+        addFactory { InsertFlatMetadata(get()) }
+        addFactory { GetExhFavoriteMangaWithMetadata(get()) }
+        addFactory { GetSearchMetadata(get()) }
+        addFactory { GetSearchTags(get()) }
+        addFactory { GetSearchTitles(get()) }
+        addFactory { GetIdsOfFavoriteMangaWithMetadata(get()) }
+
+        addSingletonFactory<MangaMergeRepository> { MangaMergeRepositoryImpl(get()) }
+        addFactory { GetMergedManga(get()) }
+        addFactory { GetMergedMangaById(get()) }
+        addFactory { GetMergedReferencesById(get()) }
+        addFactory { GetMergedChapterByMangaId(get(), get()) }
+        addFactory { InsertMergedReference(get()) }
+        addFactory { UpdateMergedSettings(get()) }
+        addFactory { DeleteByMergeId(get()) }
+        addFactory { DeleteMergeById(get()) }
+        addFactory { GetMergedMangaForDownloading(get()) }
+
+        addSingletonFactory<FavoritesEntryRepository> { FavoritesEntryRepositoryImpl(get()) }
+        addFactory { GetFavoriteEntries(get()) }
+        addFactory { InsertFavoriteEntries(get()) }
+        addFactory { DeleteFavoriteEntries(get()) }
+
+        addSingletonFactory<SavedSearchRepository> { SavedSearchRepositoryImpl(get()) }
+        addFactory { GetSavedSearchById(get()) }
+        addFactory { GetSavedSearchBySourceId(get()) }
+        addFactory { DeleteSavedSearchById(get()) }
+        addFactory { InsertSavedSearch(get()) }
+        addFactory { GetExhSavedSearch(get(), get(), get()) }
+
+        addSingletonFactory<FeedSavedSearchRepository> { FeedSavedSearchRepositoryImpl(get()) }
+        addFactory { InsertFeedSavedSearch(get()) }
+        addFactory { DeleteFeedSavedSearchById(get()) }
+        addFactory { GetFeedSavedSearchGlobal(get()) }
+        addFactory { GetFeedSavedSearchBySourceId(get()) }
+        addFactory { CountFeedSavedSearchGlobal(get()) }
+        addFactory { CountFeedSavedSearchBySourceId(get()) }
+        addFactory { GetSavedSearchGlobalFeed(get()) }
+        addFactory { GetSavedSearchBySourceIdFeed(get()) }
+    }
+}

app/src/main/java/eu/kanade/domain/UnsortedPreferences.kt

@@ -0,0 +1,89 @@
+package eu.kanade.domain
+
+import eu.kanade.tachiyomi.core.preference.PreferenceStore
+
+class UnsortedPreferences(
+    private val preferenceStore: PreferenceStore,
+) {
+
+    // SY -->
+
+    fun migrateFlags() = preferenceStore.getInt("migrate_flags", Int.MAX_VALUE)
+
+    fun defaultMangaOrder() = preferenceStore.getString("default_manga_order", "")
+
+    fun migrationSources() = preferenceStore.getString("migrate_sources", "")
+
+    fun smartMigration() = preferenceStore.getBoolean("smart_migrate", false)
+
+    fun useSourceWithMost() = preferenceStore.getBoolean("use_source_with_most", false)
+
+    fun skipPreMigration() = preferenceStore.getBoolean("skip_pre_migration", false)
+
+    fun hideNotFoundMigration() = preferenceStore.getBoolean("hide_not_found_migration", false)
+
+    fun isHentaiEnabled() = preferenceStore.getBoolean("eh_is_hentai_enabled", true)
+
+    fun enableExhentai() = preferenceStore.getBoolean("enable_exhentai", false)
+
+    fun imageQuality() = preferenceStore.getString("ehentai_quality", "auto")
+
+    fun useHentaiAtHome() = preferenceStore.getInt("eh_enable_hah", 0)
+
+    fun useJapaneseTitle() = preferenceStore.getBoolean("use_jp_title", false)
+
+    fun exhUseOriginalImages() = preferenceStore.getBoolean("eh_useOrigImages", false)
+
+    fun ehTagFilterValue() = preferenceStore.getInt("eh_tag_filtering_value", 0)
+
+    fun ehTagWatchingValue() = preferenceStore.getInt("eh_tag_watching_value", 0)
+
+    // EH Cookies
+    fun memberIdVal() = preferenceStore.getString("eh_ipb_member_id", "")
+
+    fun passHashVal() = preferenceStore.getString("eh_ipb_pass_hash", "")
+    fun igneousVal() = preferenceStore.getString("eh_igneous", "")
+    fun ehSettingsProfile() = preferenceStore.getInt("eh_ehSettingsProfile", -1)
+    fun exhSettingsProfile() = preferenceStore.getInt("eh_exhSettingsProfile", -1)
+    fun exhSettingsKey() = preferenceStore.getString("eh_settingsKey", "")
+    fun exhSessionCookie() = preferenceStore.getString("eh_sessionCookie", "")
+    fun exhHathPerksCookies() = preferenceStore.getString("eh_hathPerksCookie", "")
+
+    fun exhShowSyncIntro() = preferenceStore.getBoolean("eh_show_sync_intro", true)
+
+    fun exhReadOnlySync() = preferenceStore.getBoolean("eh_sync_read_only", false)
+
+    fun exhLenientSync() = preferenceStore.getBoolean("eh_lenient_sync", false)
+
+    fun exhShowSettingsUploadWarning() = preferenceStore.getBoolean("eh_showSettingsUploadWarning2", true)
+
+    fun logLevel() = preferenceStore.getInt("eh_log_level", 0)
+
+    fun exhAutoUpdateFrequency() = preferenceStore.getInt("eh_auto_update_frequency", 1)
+
+    fun exhAutoUpdateRequirements() = preferenceStore.getStringSet("eh_auto_update_restrictions", emptySet())
+
+    fun exhAutoUpdateStats() = preferenceStore.getString("eh_auto_update_stats", "")
+
+    fun exhWatchedListDefaultState() = preferenceStore.getBoolean("eh_watched_list_default_state", false)
+
+    fun exhSettingsLanguages() = preferenceStore.getString(
+        "eh_settings_languages",
+        "false*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false\nfalse*false*false",
+    )
+
+    fun exhEnabledCategories() = preferenceStore.getString(
+        "eh_enabled_categories",
+        "false,false,false,false,false,false,false,false,false,false",
+    )
+
+    fun enhancedEHentaiView() = preferenceStore.getBoolean("enhanced_e_hentai_view", true)
+
+    fun preferredMangaDexId() = preferenceStore.getString("preferred_mangaDex_id", "0")
+
+    fun mangadexSyncToLibraryIndexes() = preferenceStore.getStringSet("pref_mangadex_sync_to_library_indexes", emptySet())
+
+    fun allowLocalSourceHiddenFolders() = preferenceStore.getBoolean("allow_local_source_hidden_folders", false)
+
+    fun extensionRepos() = preferenceStore.getStringSet("extension_repos", emptySet())
+}

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)
+}

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)
+}

app/src/main/java/eu/kanade/domain/category/interactor/CreateCategoryWithName.kt

@@ -0,0 +1,55 @@
+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(/* SY --> */newCategory/* SY <-- */)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            Result.InternalError(e)
+        }
+    }
+
+    sealed class Result {
+        // SY -->
+        data class Success(val category: Category) : Result()
+
+        // SY <--
+        object NameAlreadyExistsError : Result()
+        data class InternalError(val error: Throwable) : Result()
+    }
+}

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

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)
+    }
+}

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

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,
+    }
+}

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)
+    }
+}

app/src/main/java/eu/kanade/domain/category/interactor/SetDisplayModeForCategory.kt

@@ -0,0 +1,41 @@
+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.LibraryGroup
+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) {
+        // SY -->
+        if (preferences.groupLibraryBy().get() != LibraryGroup.BY_DEFAULT) {
+            preferences.libraryDisplayMode().set(display)
+            return
+        }
+        // SY <--
+        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)
+    }
+}

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)
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/category/interactor/SetSortModeForCategory.kt

@@ -0,0 +1,41 @@
+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.LibraryGroup
+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) {
+        // SY -->
+        if (preferences.groupLibraryBy().get() != LibraryGroup.BY_DEFAULT) {
+            preferences.librarySortingMode().set(LibrarySort(type, direction))
+            return
+        }
+        // SY <--
+        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)
+    }
+}

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

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 }
+}

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,
+)

app/src/main/java/eu/kanade/domain/category/repository/CategoryRepository.kt

@@ -0,0 +1,30 @@
+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>>
+
+    // SY -->
+    suspend fun insert(category: Category): Long
+    // SY <--
+
+    suspend fun updatePartial(update: CategoryUpdate)
+
+    suspend fun updatePartial(updates: List<CategoryUpdate>)
+
+    suspend fun updateAllFlags(flags: Long?)
+
+    suspend fun delete(categoryId: Long)
+}

app/src/main/java/eu/kanade/domain/chapter/interactor/DeleteChapters.kt

@@ -0,0 +1,12 @@
+package eu.kanade.domain.chapter.interactor
+
+import eu.kanade.domain.chapter.repository.ChapterRepository
+
+class DeleteChapters(
+    private val chapterRepository: ChapterRepository,
+) {
+
+    suspend fun await(chapters: List<Long>) {
+        chapterRepository.removeChaptersWithIds(chapters)
+    }
+}

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
+        }
+    }
+}

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

app/src/main/java/eu/kanade/domain/chapter/interactor/GetChapterByUrl.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 GetChapterByUrl(
+    private val chapterRepository: ChapterRepository,
+) {
+
+    suspend fun await(url: String): List<Chapter> {
+        return try {
+            chapterRepository.getChapterByUrl(url)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            emptyList()
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/chapter/interactor/GetMergedChapterByMangaId.kt

@@ -0,0 +1,107 @@
+package eu.kanade.domain.chapter.interactor
+
+import eu.kanade.domain.chapter.model.Chapter
+import eu.kanade.domain.chapter.repository.ChapterRepository
+import eu.kanade.domain.manga.interactor.GetMergedReferencesById
+import eu.kanade.tachiyomi.util.system.logcat
+import exh.merged.sql.models.MergedMangaReference
+import exh.source.MERGED_SOURCE_ID
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flowOf
+import logcat.LogPriority
+
+class GetMergedChapterByMangaId(
+    private val chapterRepository: ChapterRepository,
+    private val getMergedReferencesById: GetMergedReferencesById,
+) {
+
+    suspend fun await(mangaId: Long, dedupe: Boolean = true): List<Chapter> {
+        return transformMergedChapters(getMergedReferencesById.await(mangaId), getFromDatabase(mangaId), dedupe)
+    }
+
+    suspend fun subscribe(mangaId: Long, dedupe: Boolean = true): Flow<List<Chapter>> {
+        return try {
+            chapterRepository.getMergedChapterByMangaIdAsFlow(mangaId)
+                .combine(getMergedReferencesById.subscribe(mangaId)) { chapters, references ->
+                    transformMergedChapters(references, chapters, dedupe)
+                }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            flowOf(emptyList())
+        }
+    }
+
+    private suspend fun getFromDatabase(mangaId: Long): List<Chapter> {
+        return try {
+            chapterRepository.getMergedChapterByMangaId(mangaId)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            emptyList()
+        }
+    }
+
+    fun transformMergedChapters(mangaReferences: List<MergedMangaReference>, chapterList: List<Chapter>, dedupe: Boolean): List<Chapter> {
+        return if (dedupe) dedupeChapterList(mangaReferences, chapterList) else chapterList
+    }
+
+    private fun dedupeChapterList(mangaReferences: List<MergedMangaReference>, chapterList: List<Chapter>): List<Chapter> {
+        return when (mangaReferences.firstOrNull { it.mangaSourceId == MERGED_SOURCE_ID }?.chapterSortMode) {
+            MergedMangaReference.CHAPTER_SORT_NO_DEDUPE, MergedMangaReference.CHAPTER_SORT_NONE -> chapterList
+            MergedMangaReference.CHAPTER_SORT_PRIORITY -> dedupeByPriority(mangaReferences, chapterList)
+            MergedMangaReference.CHAPTER_SORT_MOST_CHAPTERS -> {
+                findSourceWithMostChapters(chapterList)?.let { mangaId ->
+                    chapterList.filter { it.mangaId == mangaId }
+                } ?: chapterList
+            }
+            MergedMangaReference.CHAPTER_SORT_HIGHEST_CHAPTER_NUMBER -> {
+                findSourceWithHighestChapterNumber(chapterList)?.let { mangaId ->
+                    chapterList.filter { it.mangaId == mangaId }
+                } ?: chapterList
+            }
+            else -> chapterList
+        }
+    }
+
+    private fun findSourceWithMostChapters(chapterList: List<Chapter>): Long? {
+        return chapterList.groupBy { it.mangaId }.maxByOrNull { it.value.size }?.key
+    }
+
+    private fun findSourceWithHighestChapterNumber(chapterList: List<Chapter>): Long? {
+        return chapterList.maxByOrNull { it.chapterNumber }?.mangaId
+    }
+
+    private fun dedupeByPriority(mangaReferences: List<MergedMangaReference>, chapterList: List<Chapter>): List<Chapter> {
+        val sortedChapterList = mutableListOf<Chapter>()
+
+        var existingChapterIndex: Int
+        chapterList.groupBy { it.mangaId }
+            .entries
+            .sortedBy { (mangaId) ->
+                mangaReferences.find { it.mangaId == mangaId }?.chapterPriority ?: Int.MAX_VALUE
+            }
+            .forEach { (_, chapters) ->
+                existingChapterIndex = -1
+                chapters.forEach { chapter ->
+                    val oldChapterIndex = existingChapterIndex
+                    if (chapter.isRecognizedNumber) {
+                        existingChapterIndex = sortedChapterList.indexOfFirst {
+                            it.isRecognizedNumber && it.chapterNumber == chapter.chapterNumber && // check if the chapter is not already there
+                                it.mangaId != chapter.mangaId // allow multiple chapters of the same number from the same source
+                        }
+                        if (existingChapterIndex == -1) {
+                            sortedChapterList.add(oldChapterIndex + 1, chapter)
+                            existingChapterIndex = oldChapterIndex + 1
+                        }
+                    } else {
+                        sortedChapterList.add(oldChapterIndex + 1, chapter)
+                        existingChapterIndex = oldChapterIndex + 1
+                    }
+                }
+            }
+
+        return sortedChapterList.mapIndexed { index, chapter ->
+            chapter.copy(sourceOrder = index.toLong())
+        }
+    }
+}

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) }
+        }
+    }
+}

app/src/main/java/eu/kanade/domain/chapter/interactor/SetReadStatus.kt

@@ -0,0 +1,98 @@
+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 exh.source.MERGED_SOURCE_ID
+import logcat.LogPriority
+
+class SetReadStatus(
+    private val downloadPreferences: DownloadPreferences,
+    private val deleteDownload: DeleteDownload,
+    private val mangaRepository: MangaRepository,
+    private val chapterRepository: ChapterRepository,
+    // SY -->
+    private val getMergedChapterByMangaId: GetMergedChapterByMangaId,
+    // SY <--
+) {
+
+    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(),
+        )
+    }
+
+    // SY -->
+    private suspend fun awaitMerged(mangaId: Long, read: Boolean) = withNonCancellableContext f@{
+        return@f await(
+            read = read,
+            chapters = getMergedChapterByMangaId
+                .await(mangaId, dedupe = false)
+                .toTypedArray(),
+        )
+    }
+
+    suspend fun await(manga: Manga, read: Boolean) = if (manga.source == MERGED_SOURCE_ID) {
+        awaitMerged(manga.id, read)
+    } else {
+        await(manga.id, read)
+    }
+    // SY <--
+
+    sealed class Result {
+        object Success : Result()
+        object NoChapters : Result()
+        data class InternalError(val error: Throwable) : Result()
+    }
+}

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
+    }
+}

app/src/main/java/eu/kanade/domain/chapter/interactor/SyncChaptersWithSource.kt

@@ -0,0 +1,213 @@
+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 exh.source.isEhBasedManga
+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, /* SY --> */ manga.ogTitle /* SY <-- */, 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
+        }
+
+        // --> EXH (carry over reading progress)
+        if (manga.isEhBasedManga()) {
+            val finalAdded = updatedToAdd.subtract(reAdded)
+            if (finalAdded.isNotEmpty()) {
+                val max = dbChapters.maxOfOrNull { it.lastPageRead }
+                if (max != null && max > 0) {
+                    updatedToAdd = updatedToAdd.map {
+                        if (it !in reAdded) {
+                            it.copy(lastPageRead = max)
+                        } else {
+                            it
+                        }
+                    }
+                }
+            }
+        }
+        // <-- EXH
+
+        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 }
+    }
+}

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)
+        }
+    }
+}

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)
+        }
+    }
+}

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

app/src/main/java/eu/kanade/domain/chapter/model/ChapterFilter.kt

@@ -0,0 +1,93 @@
+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
+import exh.md.utils.MdUtil
+
+/**
+ * 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, /* SY --> */ manga.ogTitle /* SY <-- */, 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
+            }
+        }
+        // SY -->
+        .filter { chapter ->
+            manga.filteredScanlators.isNullOrEmpty() || MdUtil.getScanlators(chapter.scanlator).any { group -> manga.filteredScanlators.contains(group) }
+        }
+        // SY <--
+        .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
+            }
+        }
+        // SY -->
+        .filter { chapter ->
+            manga.filteredScanlators.isNullOrEmpty() || MdUtil.getScanlators(chapter.chapter.scanlator).any { group -> manga.filteredScanlators.contains(group) }
+        }
+        // SY <--
+        .sortedWith { (chapter1), (chapter2) -> getChapterSort(manga).invoke(chapter1, chapter2) }
+}

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)
+}

app/src/main/java/eu/kanade/domain/chapter/repository/ChapterRepository.kt

@@ -0,0 +1,34 @@
+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?
+
+    // SY -->
+    suspend fun getChapterByUrl(url: String): List<Chapter>
+
+    suspend fun getMergedChapterByMangaId(mangaId: Long): List<Chapter>
+
+    suspend fun getMergedChapterByMangaIdAsFlow(mangaId: Long): Flow<List<Chapter>>
+    // SY <--
+}

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)
+        }
+    }
+}

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

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),
+                )
+        }
+    }
+}

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,
+)

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() /* SY --> */ && it.isRedundant.not() /* SY <-- */ }
+                        .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)
+        }
+    }
+}

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>,
+)

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)
+    }
+}

app/src/main/java/eu/kanade/domain/history/interactor/GetHistoryByMangaId.kt

@@ -0,0 +1,13 @@
+package eu.kanade.domain.history.interactor
+
+import eu.kanade.domain.history.model.History
+import eu.kanade.domain.history.repository.HistoryRepository
+
+class GetHistoryByMangaId(
+    private val repository: HistoryRepository,
+) {
+
+    suspend fun await(mangaId: Long): List<History> {
+        return repository.getByMangaId(mangaId)
+    }
+}