Add files via upload

app/src/main/kotlin/ShiggyXposed/xposed/xposed/Constants.kt

@@ -0,0 +1,19 @@
+package GoonXposed.xposed
+
+class Constants {
+    companion object {
+        const val TARGET_PACKAGE = "com.discord"
+        const val TARGET_ACTIVITY = "$TARGET_PACKAGE.react_activities.ReactActivity"
+
+        const val FILES_DIR = "files/pyoncord"
+        const val CACHE_DIR = "cache/pyoncord"
+        const val MAIN_SCRIPT_FILE = "bundle.js"
+
+
+        const val LOG_TAG = "Goon"
+
+        const val LOADER_NAME = "GoonXposed"
+
+        const val USER_AGENT = "GoonXposed"
+    }
+}

app/src/main/kotlin/ShiggyXposed/xposed/xposed/Main.kt

@@ -0,0 +1,107 @@
+package GoonXposed.xposed
+
+import android.app.Activity
+import android.content.Context
+import android.content.ContextWrapper
+import android.os.Bundle
+import de.robv.android.xposed.IXposedHookLoadPackage
+import de.robv.android.xposed.IXposedHookZygoteInit
+import de.robv.android.xposed.callbacks.XC_LoadPackage
+import GoonXposed.xposed.Utils.Log
+import GoonXposed.xposed.modules.*
+import GoonXposed.xposed.modules.appearance.FontsModule
+import GoonXposed.xposed.modules.appearance.SysColorsModule
+import GoonXposed.xposed.modules.appearance.ThemesModule
+import GoonXposed.xposed.modules.bridge.AdditionalBridgeMethodsModule
+import GoonXposed.xposed.modules.bridge.BridgeModule
+import GoonXposed.xposed.modules.no_track.BlockCrashReportingModule
+import GoonXposed.xposed.modules.no_track.BlockDeepLinksTrackingModule
+import kotlinx.coroutines.CompletableDeferred
+
+object HookStateHolder {
+    /**
+     * Whether all hooks are completed, and we are ready to load the JS bundle.
+     */
+    val readyDeferred = CompletableDeferred<Unit>()
+
+    /**
+     * Whether we have successfully received a [Context] yet.
+     * Sometimes the app process is recreated and Xposed hooks way too late for us to get [Context] from [ContextWrapper.attachBaseContext].
+     * But since Xposed hooks before [Activity.onCreate], we can still get it from there and still initialize properly.
+     */
+    @Volatile
+    var gotContext = false
+}
+
+class Main : Module(), IXposedHookLoadPackage, IXposedHookZygoteInit {
+    private var hooked = false
+    private val modules = mutableListOf(
+        HookScriptLoaderModule,
+        BridgeModule,
+        AdditionalBridgeMethodsModule,
+        PluginsModule(),
+        UpdaterModule,
+        FixResourcesModule,
+        BlockDeepLinksTrackingModule,
+        BlockCrashReportingModule,
+        LogBoxModule,
+        CacheModule,
+        FontsModule,
+        ThemesModule,
+        SysColorsModule
+    )
+
+    init {
+        modules += PayloadGlobalModule(modules)
+    }
+
+    override fun initZygote(startupParam: IXposedHookZygoteInit.StartupParam) {
+        for (module in modules) module.onInit(startupParam)
+    }
+
+    override fun handleLoadPackage(param: XC_LoadPackage.LoadPackageParam) = with(param) {
+        if (hooked) return
+
+        val reactActivity = classLoader.loadClass(Constants.TARGET_ACTIVITY)
+
+        ContextWrapper::class.java.hookMethod("attachBaseContext", Context::class.java) {
+            after {
+                val ctx = args[0] as Context
+                HookStateHolder.gotContext = true
+                Log.i("Received Context")
+                this@Main.onContext(ctx)
+            }
+        }
+
+        reactActivity.hookMethod("onCreate", Bundle::class.java) {
+            after {
+                val act = thisObject as Activity
+                Log.i("Received Activity")
+
+                if (!HookStateHolder.gotContext) {
+                    Log.w("Activity created before we got Context, process may have been recreated!")
+                    this@Main.onContext(act.applicationContext)
+                }
+
+                this@Main.onActivity(act)
+                HookStateHolder.readyDeferred.complete(Unit)
+            }
+        }
+
+        this@Main.onLoad(param)
+
+        hooked = true
+    }
+
+    override fun onLoad(packageParam: XC_LoadPackage.LoadPackageParam) {
+        for (module in modules) module.onLoad(packageParam)
+    }
+
+    override fun onContext(context: Context) {
+        for (module in modules) module.onContext(context)
+    }
+
+    override fun onActivity(activity: Activity) {
+        for (module in modules) module.onActivity(activity)
+    }
+}

app/src/main/kotlin/ShiggyXposed/xposed/xposed/Module.kt

@@ -0,0 +1,183 @@
+package GoonXposed.xposed
+
+import android.app.Activity
+import android.content.Context
+import android.os.Build
+import de.robv.android.xposed.IXposedHookZygoteInit
+import de.robv.android.xposed.XC_MethodHook
+import de.robv.android.xposed.XposedBridge
+import de.robv.android.xposed.callbacks.XC_LoadPackage
+import kotlinx.serialization.json.JsonObjectBuilder
+import java.io.File
+import java.lang.reflect.Method
+
+data class AppInfo(
+    val name: String,
+    val packageName: String,
+    val version: String,
+    val versionCode: Long,
+)
+
+abstract class Module {
+    /**
+     * Builds a JSON payload to be injected into the JavaScript context.
+     */
+    @Deprecated("This will be removed in future versions. Payloads can be replaced via synchronous bridge methods.")
+    open fun buildPayload(builder: JsonObjectBuilder) {
+    }
+
+    /**
+     * Called during Zygote initialization.
+     */
+    open fun onInit(startupParam: IXposedHookZygoteInit.StartupParam) {}
+
+    /**
+     * Called when a package is loaded.
+     *
+     * Hooks should typically be set up here.
+     *
+     * Bridge methods that do not require [Context] can also be registered here.
+     */
+    open fun onLoad(packageParam: XC_LoadPackage.LoadPackageParam) {}
+
+    /**
+     * Called after [Context] has been attached to a [android.content.ContextWrapper]
+     * via [android.content.ContextWrapper.attachBaseContext].
+     *
+     * This may be called multiple times for different [Context]s, e.g. when the app is killed by the system.
+     *
+     * For bridge methods that require access to [Context], register them here.
+     */
+    open fun onContext(context: Context) {}
+
+    /**
+     * Called after an [Activity.onCreate] method is executed.
+     *
+     * UI code that requires an [Activity] context can be placed here.
+     *
+     * Bridge methods must not be registered here, as it can be too late and cause crashes.
+     *
+     * If you need to register bridge methods that require an [Activity], do it in [onContext] and make it async.
+     *
+     * Once an [Activity] is available, execute the queued calls. Then from JS, call the method asynchronously.
+     */
+    open fun onActivity(activity: Activity) {}
+
+    protected fun Context.getAppInfo(): AppInfo {
+        val pInfo = packageManager.getPackageInfo(packageName, 0)
+        val versionCode = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) pInfo.longVersionCode
+        else @Suppress("DEPRECATION") pInfo.versionCode.toLong()
+
+        return AppInfo(
+            packageManager.getApplicationLabel(applicationInfo).toString(),
+            packageName,
+            pInfo.versionName ?: versionCode.toString(),
+            versionCode,
+        )
+    }
+
+    protected fun File.asDir() {
+        if (!this.isDirectory) this.delete()
+        this.mkdirs()
+    }
+
+    protected fun File.asFile() {
+        if (!this.isFile) this.deleteRecursively()
+    }
+
+    protected fun Class<*>.method(
+        name: String, vararg params: Class<*>?
+    ): Method = getDeclaredMethod(name, *params).apply {
+        isAccessible = true
+    }
+
+    protected fun ClassLoader.safeLoadClass(name: String): Class<*>? = runCatching { loadClass(name) }.getOrNull()
+
+    protected fun Method.hook(hook: XC_MethodHook): XC_MethodHook.Unhook = XposedBridge.hookMethod(this, hook)
+
+    protected fun Method.hook(block: MethodHookBuilder.() -> Unit): XC_MethodHook.Unhook =
+        hook(MethodHookBuilder().apply(block).build())
+
+    protected fun Class<*>.hookMethod(
+        name: String, vararg params: Class<*>?, block: MethodHookBuilder.() -> Unit
+    ): XC_MethodHook.Unhook = method(name, *params).hook(MethodHookBuilder().apply(block).build())
+
+    protected class MethodHookBuilder {
+        private var beforeBlock: (HookScope.() -> Unit)? = null
+        private var afterBlock: (HookScope.() -> Unit)? = null
+
+        fun before(block: HookScope.() -> Unit) {
+            beforeBlock = block
+        }
+
+        fun after(block: HookScope.() -> Unit) {
+            afterBlock = block
+        }
+
+        fun build(): XC_MethodHook = object : XC_MethodHook() {
+            override fun beforeHookedMethod(param: MethodHookParam) {
+                val b = beforeBlock
+                if (b != null) {
+                    val scope = HookScope(
+                        param = param, proceed = { p ->
+                            super.beforeHookedMethod(p)
+                        })
+                    scope.b()
+                } else {
+                    super.beforeHookedMethod(param)
+                }
+            }
+
+            override fun afterHookedMethod(param: MethodHookParam) {
+                val a = afterBlock
+                if (a != null) {
+                    val scope = HookScope(
+                        param = param, proceed = { p ->
+                            super.afterHookedMethod(p)
+                        })
+                    scope.a()
+                } else {
+                    super.afterHookedMethod(param)
+                }
+            }
+        }
+    }
+
+    /**
+     * Scope object passed to before/after hook blocks.
+     *
+     * Provides:
+     * - Access to the [param] object
+     * - [proceed] to call the original XC_MethodHook super method
+     * - Accessors for `thisObject`, `args`, `result`, and `throwable`
+     *
+     * @property param The [XC_MethodHook.MethodHookParam] for the current hook.
+     * @property proceed Function that calls the super method.
+     */
+    protected class HookScope internal constructor(
+        val param: XC_MethodHook.MethodHookParam, private val proceed: (XC_MethodHook.MethodHookParam) -> Unit
+    ) {
+        /**
+         * Continues with the default XC_MethodHook super behavior.
+         * Equivalent to calling `super.beforeHookedMethod(param)` or
+         * `super.afterHookedMethod(param)` depending on the phase.
+         */
+        fun proceed() = proceed(param)
+
+        val thisObject: Any? get() = param.thisObject
+
+        val args: Array<Any?> get() = param.args
+
+        var result: Any?
+            get() = param.result
+            set(value) {
+                param.result = value
+            }
+
+        var throwable: Throwable?
+            get() = param.throwable
+            set(value) {
+                param.throwable = value
+            }
+    }
+}

app/src/main/kotlin/ShiggyXposed/xposed/xposed/Utils.kt

@@ -0,0 +1,58 @@
+package GoonXposed.xposed
+
+import android.app.AlertDialog
+import android.app.AndroidAppHelper
+import android.content.Context
+import android.content.Intent
+import GoonXposed.xposed.modules.UpdaterModule
+import kotlinx.serialization.json.Json
+import java.io.File
+import kotlin.system.exitProcess
+
+class Utils {
+    companion object {
+        val JSON = Json { ignoreUnknownKeys = true }
+
+        fun reloadApp() {
+            val application = AndroidAppHelper.currentApplication()
+            val intent = application.packageManager.getLaunchIntentForPackage(application.packageName)
+            application.startActivity(Intent.makeRestartActivityTask(intent!!.component))
+            exitProcess(0)
+        }
+
+        fun showRecoveryAlert(context: Context) {
+            AlertDialog.Builder(context).setTitle("GoonCord Recovery Options")
+                .setItems(arrayOf("Reload", "Delete Script", "Reset Loader Config")) { _, which ->
+                    when (which) {
+                        0 -> {
+                            reloadApp()
+                        }
+
+                        1 -> {
+                            val bundleFile = File(
+                                context.dataDir, "${Constants.CACHE_DIR}/${Constants.MAIN_SCRIPT_FILE}"
+                            )
+
+                            if (bundleFile.exists()) bundleFile.delete()
+
+                            reloadApp()
+                        }
+
+                        2 -> {
+                            UpdaterModule.resetLoaderConfig(context)
+                            reloadApp()
+                        }
+                    }
+                }.show()
+        }
+    }
+
+    object Log {
+        fun e(msg: String) = android.util.Log.e(Constants.LOG_TAG, msg)
+        fun e(msg: String, throwable: Throwable) = android.util.Log.e(Constants.LOG_TAG, msg, throwable)
+        fun i(msg: String) = android.util.Log.i(Constants.LOG_TAG, msg)
+        fun i(msg: String, throwable: Throwable) = android.util.Log.i(Constants.LOG_TAG, msg, throwable)
+        fun w(msg: String) = android.util.Log.w(Constants.LOG_TAG, msg)
+        fun w(msg: String, throwable: Throwable) = android.util.Log.w(Constants.LOG_TAG, msg, throwable)
+    }
+}

app/src/main/kotlin/ShiggyXposed/xposed/xposed/modules/CacheModule.kt

@@ -0,0 +1,270 @@
+package GoonXposed.xposed.modules
+
+import android.content.Context
+import android.util.AtomicFile
+import GoonXposed.xposed.Module
+import GoonXposed.xposed.Utils.Log
+import GoonXposed.xposed.modules.bridge.BridgeModule
+import java.io.*
+
+/**
+ * A module for caching versioned modules finds and blacklist, and assets mappings.
+ *
+ * See [ModulesCache] and [AssetsCache] for the cache structure.
+ *
+ * ## Methods
+ *
+ * ### Modules cache
+ *
+ * - `Shiggy.caches.modules.read() : { blacklist: number[], finds: { [filter: string]: { [id: string]: number } | null }, version: number } | null`
+ * - Reads the modules cache. Returns `null` if the cache file does not exist or is invalid.
+ *
+ * - `Shiggy.caches.modules.write(blacklist: number[], finds: { [filter: string]: { [id: string]: number } | null }) : void`
+ * - Writes the modules cache.
+ *
+ *  ### Assets cache
+ *
+ * - `Shiggy.caches.assets.read() : { data: { [name: string]: { [type: string]: number } }, version: number } | null`
+ * - Reads the assets cache. Returns `null` if the cache file does not exist or is invalid.
+ *
+ * - `Shiggy.caches.assets.write(data: { [name: string]: { [type: string]: number } }) : void`
+ * - Writes the assets cache.
+ *
+ *  The caches are versioned and tied to the app version code. When the app is updated,
+ *  the caches are invalidated and new cache files are created.
+ */
+object CacheModule : Module() {
+
+    private const val CACHE_DIR = "revenge"
+
+    private const val MODULES_CACHE_PREFIX = "modules"
+    private const val ASSETS_CACHE_PREFIX = "assets"
+
+
+    private lateinit var modulesCache: ModulesCache
+    private lateinit var assetsCache: AssetsCache
+
+    override fun onContext(context: Context) = with(context) {
+        val revengeCacheDir = File(cacheDir, CACHE_DIR).apply { asDir() }
+        val (_, _, _, versionCode) = getAppInfo()
+
+        val modulesCacheFile = File(
+            revengeCacheDir, "$MODULES_CACHE_PREFIX.$versionCode"
+        ).apply { asFile() }
+
+        val assetsCacheFile = File(
+            revengeCacheDir, "$ASSETS_CACHE_PREFIX.$versionCode"
+        ).apply { asFile() }
+
+        BridgeModule.registerMethod("revenge.caches.modules.read") {
+            if (::modulesCache.isInitialized) modulesCache.toMap() else ModulesCache.loadFromFileOrNull(modulesCacheFile)
+                ?.let {
+                    modulesCache = it
+                    it.toMap()
+                }
+        }
+
+        BridgeModule.registerMethod("revenge.caches.modules.write") {
+            val (blacklist, finds) = it
+            @Suppress("UNCHECKED_CAST")
+            modulesCache = ModulesCache(
+                blacklist as ArrayList<Double>, finds as HashMap<String, HashMap<String, Double>?>
+            ).apply { saveToFile(modulesCacheFile) }
+            Log.i("Modules cache saved: ${modulesCacheFile.absolutePath} (blacklisted: ${blacklist.size}, finds: ${finds.size})")
+        }
+
+        BridgeModule.registerMethod("revenge.caches.assets.read") {
+            if (::assetsCache.isInitialized) assetsCache.toMap() else AssetsCache.loadFromFileOrNull(assetsCacheFile)
+                ?.let {
+                    assetsCache = it
+                    it.toMap()
+                }
+        }
+
+        BridgeModule.registerMethod("revenge.caches.assets.write") {
+            val (data) = it
+            @Suppress("UNCHECKED_CAST")
+            assetsCache =
+                AssetsCache(data as HashMap<String, HashMap<String, Double>>).apply { saveToFile(assetsCacheFile) }
+            Log.i("Assets cache saved: ${assetsCacheFile.absolutePath} (count: ${data.size})")
+        }
+    }
+}
+
+private class CacheVersionMismatchException(expected: Int, actual: Int) :
+    Throwable("Expected cache version: $expected, but got version: $actual")
+
+data class ModulesCache(
+    val blacklist: List<Double>, val finds: Map<String, Map<String, Double>?>
+) {
+    fun saveToFile(file: File) {
+        val atomic = AtomicFile(file)
+        var fos: FileOutputStream? = null
+        try {
+            fos = atomic.startWrite()
+            val out = DataOutputStream(BufferedOutputStream(fos))
+
+            out.writeInt(VERSION)
+
+            // Write blacklist
+            out.writeInt(blacklist.size)
+            for (num in blacklist) out.writeInt(num.toInt())
+
+            // Write finds
+            out.writeInt(finds.size)
+            for ((filter, matches) in finds) {
+                out.writeUTF(filter)
+                if (matches == null) {
+                    out.writeBoolean(false) // null marker
+                } else {
+                    out.writeBoolean(true) // not null
+                    out.writeInt(matches.size)
+                    for ((id, flag) in matches) {
+                        out.writeInt(id.toInt())
+                        out.writeInt(flag.toInt())
+                    }
+                }
+            }
+
+            out.flush()
+            atomic.finishWrite(fos)
+        } catch (t: Throwable) {
+            if (fos != null) atomic.failWrite(fos)
+            throw t
+        }
+    }
+
+    fun toMap(): Map<String, Any> {
+        val findsMap = finds.mapValues { (_, matches) -> matches?.map { (k, v) -> k to v }?.toMap() }
+
+        return mapOf("blacklist" to blacklist, "finds" to findsMap, "version" to VERSION)
+    }
+
+    companion object {
+        const val VERSION = 3
+
+        fun loadFromFileOrNull(file: File): ModulesCache? {
+            if (!file.exists() || file.length() <= 0L) return null
+            val atomic = AtomicFile(file)
+            try {
+                DataInputStream(BufferedInputStream(atomic.openRead())).use { input ->
+                    val version = input.readInt()
+                    if (version != VERSION) throw CacheVersionMismatchException(VERSION, version)
+
+                    val blacklistSize = input.readInt()
+                    val blacklist = MutableList(blacklistSize) { input.readInt().toDouble() }
+
+                    val findsSize = input.readInt()
+                    val finds = mutableMapOf<String, Map<String, Double>?>()
+                    repeat(findsSize) {
+                        val filter = input.readUTF()
+                        val hasMatches = input.readBoolean()
+                        if (!hasMatches) {
+                            finds[filter] = null
+                        } else {
+                            val mapSize = input.readInt()
+                            val matches = mutableMapOf<String, Double>()
+                            repeat(mapSize) {
+                                val id = input.readInt().toString()
+                                val flag = input.readInt().toDouble()
+                                matches[id] = flag
+                            }
+                            finds[filter] = matches
+                        }
+                    }
+
+                    return ModulesCache(blacklist, finds)
+                }
+            } catch (e: CacheVersionMismatchException) {
+                Log.i("Modules cache version mismatch: ${e.message}")
+            } catch (e: EOFException) {
+                Log.e("Modules cache corrupt: ${e.message}")
+            } catch (e: IOException) {
+                Log.e("Failed to read modules cache: ${e.message}")
+            }
+            runCatching { file.delete() }
+            return null
+        }
+    }
+}
+
+data class AssetsCache(
+    val data: Map<String, Map<String, Double>>
+) {
+    fun saveToFile(file: File) {
+        val atomic = AtomicFile(file)
+        var fos: FileOutputStream? = null
+        try {
+            fos = atomic.startWrite()
+            val out = DataOutputStream(BufferedOutputStream(fos))
+
+            out.writeInt(VERSION)
+
+            out.writeInt(data.size)
+            for ((name, mappings) in data) {
+                out.writeUTF(name)
+                out.writeInt(mappings.size)
+                for ((type, id) in mappings) {
+                    out.writeUTF(type)
+                    out.writeInt(id.toInt())
+                }
+            }
+
+            out.flush()
+            atomic.finishWrite(fos)
+        } catch (t: Throwable) {
+            if (fos != null) atomic.failWrite(fos)
+            throw t
+        }
+    }
+
+    fun toMap(): Map<String, Any> {
+        return mapOf(
+            "data" to data.mapValues { (_, mappings) ->
+                mappings.map { (type, id) -> type to id }.toMap()
+            }, "version" to VERSION
+        )
+    }
+
+    companion object {
+        const val VERSION = 2
+
+        fun loadFromFileOrNull(file: File): AssetsCache? {
+            if (!file.exists() || file.length() <= 0L) return null
+            val atomic = AtomicFile(file)
+            try {
+                DataInputStream(BufferedInputStream(atomic.openRead())).use { input ->
+                    val version = input.readInt()
+                    if (version != VERSION) throw CacheVersionMismatchException(VERSION, version)
+
+                    val dataSize = input.readInt()
+                    val data = mutableMapOf<String, Map<String, Double>>()
+
+                    repeat(dataSize) {
+                        val name = input.readUTF()
+                        val mappingsSize = input.readInt()
+                        val mappings = mutableMapOf<String, Double>()
+
+                        repeat(mappingsSize) {
+                            val type = input.readUTF()
+                            val id = input.readInt().toDouble()
+                            mappings[type] = id
+                        }
+
+                        data[name] = mappings
+                    }
+
+                    return AssetsCache(data)
+                }
+            } catch (e: CacheVersionMismatchException) {
+                Log.i("Assets cache version mismatch: ${e.message}")
+            } catch (e: EOFException) {
+                Log.e("Assets cache corrupt: ${e.message}")
+            } catch (e: IOException) {
+                Log.e("Failed to read assets cache: ${e.message}")
+            }
+            runCatching { file.delete() }
+            return null
+        }
+    }
+}

app/src/main/kotlin/ShiggyXposed/xposed/xposed/modules/FixResourcesModule.kt

@@ -0,0 +1,23 @@
+package GoonXposed.xposed.modules
+
+import android.content.res.Resources
+import de.robv.android.xposed.callbacks.XC_LoadPackage
+import GoonXposed.xposed.Constants.Companion.TARGET_PACKAGE
+import GoonXposed.xposed.Module
+
+/**
+ * Hooks [Resources.getIdentifier] to fix resource package name mismatch.
+ */
+object FixResourcesModule : Module() {
+    override fun onLoad(packageParam: XC_LoadPackage.LoadPackageParam) = with(packageParam) {
+        if (packageName != TARGET_PACKAGE) {
+            Resources::class.java.hookMethod(
+                "getIdentifier", String::class.java, String::class.java, String::class.java
+            ) {
+                before {
+                    if (args[2] == packageName) args[2] = TARGET_PACKAGE
+                }
+            }
+        }
+    }
+}

app/src/main/kotlin/ShiggyXposed/xposed/xposed/modules/HookScriptLoaderModule.kt

@@ -0,0 +1,121 @@
+package GoonXposed.xposed.modules
+
+import android.content.res.AssetManager
+import android.content.res.XModuleResources
+import de.robv.android.xposed.IXposedHookZygoteInit
+import de.robv.android.xposed.XposedBridge
+import de.robv.android.xposed.callbacks.XC_LoadPackage
+import GoonXposed.xposed.Constants
+import GoonXposed.xposed.HookStateHolder
+import GoonXposed.xposed.Module
+import GoonXposed.xposed.Utils.Log
+import GoonXposed.xposed.modules.HookScriptLoaderModule.PRELOADS_DIR
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.runBlocking
+import java.io.File
+import java.lang.reflect.Method
+
+/**
+ * Hooks React Native's script loading methods to load custom scripts and bundles.
+ *
+ * Preload scripts should be placed in the [PRELOADS_DIR] directory inside the module's files directory.
+ *
+ * The main bundle should be placed in the [Constants.CACHE_DIR] directory named [Constants.MAIN_SCRIPT_FILE].
+ * If the bundle file does not exist, it will attempt to load `assets://Shiggy.bundle` from the module's assets.
+ */
+object HookScriptLoaderModule : Module() {
+    private lateinit var preloadsDir: File
+    private lateinit var mainScript: File
+
+    private lateinit var modulePath: String
+    private lateinit var resources: XModuleResources
+
+    const val PRELOADS_DIR = "preloads"
+
+    override fun onInit(startupParam: IXposedHookZygoteInit.StartupParam) {
+        this@HookScriptLoaderModule.modulePath = startupParam.modulePath
+    }
+
+    override fun onLoad(packageParam: XC_LoadPackage.LoadPackageParam) = with(packageParam) {
+        val cacheDir = File(appInfo.dataDir, Constants.CACHE_DIR).apply { asDir() }
+        val filesDir = File(appInfo.dataDir, Constants.FILES_DIR).apply { asDir() }
+
+        preloadsDir = File(filesDir, PRELOADS_DIR).apply { asDir() }
+        mainScript = File(cacheDir, Constants.MAIN_SCRIPT_FILE).apply { asFile() }
+
+        listOf(
+            "com.facebook.react.runtime.ReactInstance\$loadJSBundle$1",
+            "com.facebook.react.runtime.ReactInstance$1",
+            // TODO: Remove once Discord fully switches to Bridgeless
+            "com.facebook.react.bridge.CatalystInstanceImpl"
+        ).mapNotNull { classLoader.safeLoadClass(it) }.forEach { hook(it) }
+    }
+
+    private fun hook(instance: Class<*>) = runCatching {
+        val loadScriptFromAssets = instance.method(
+            "loadScriptFromAssets", AssetManager::class.java, String::class.java, Boolean::class.javaPrimitiveType
+        )
+
+        val loadScriptFromFile = instance.method(
+            "loadScriptFromFile", String::class.java, String::class.java, Boolean::class.javaPrimitiveType
+        )
+
+        loadScriptFromAssets.hook {
+            before {
+                Log.i("Received call to loadScriptFromAssets: ${args[1]} (sync: ${args[2]})")
+                runCustomScripts(loadScriptFromFile, loadScriptFromAssets)
+            }
+        }
+
+        loadScriptFromFile.hook {
+            before {
+                Log.i("Received call to loadScriptFromFile: ${args[0]} (sync: ${args[2]})")
+                runCustomScripts(loadScriptFromFile, loadScriptFromAssets)
+            }
+        }
+    }.onFailure {
+        Log.e("Failed to hook script loading methods in ${instance.name}:", it)
+    }
+
+    private fun HookScope.runCustomScripts(loadScriptFromFile: Method, loadScriptFromAssets: Method) {
+        Log.i("Running custom scripts...")
+
+        runBlocking {
+            val ready = async { HookStateHolder.readyDeferred.join() }
+            val download = async { UpdaterModule.downloadScript().join() }
+
+            awaitAll(ready, download)
+        }
+
+        val loadSynchronously = args[2]
+        val runScriptFile = { file: File ->
+            Log.i("Loading script: ${file.absolutePath}")
+
+            XposedBridge.invokeOriginalMethod(
+                loadScriptFromFile, thisObject, arrayOf(file.absolutePath, file.absolutePath, loadSynchronously)
+            )
+
+            Unit
+        }
+
+        try {
+            preloadsDir.walk().filter { it.isFile }.forEach(runScriptFile)
+
+            if (mainScript.exists()) runScriptFile(mainScript)
+            else {
+                Log.i("Main script does not exist, falling back")
+
+                if (!::resources.isInitialized) resources = XModuleResources.createInstance(modulePath, null)
+
+                XposedBridge.invokeOriginalMethod(
+                    loadScriptFromAssets,
+                    thisObject,
+                    arrayOf(resources.assets, "assets://Shiggy.bundle", loadSynchronously)
+                )
+            }
+        } catch (e: Throwable) {
+            Log.e("Unable to run scripts:", e)
+        }
+    }
+}

app/src/main/kotlin/ShiggyXposed/xposed/xposed/modules/PayloadGlobalModule.kt

@@ -0,0 +1,80 @@
+package GoonXposed.xposed.modules
+
+import android.content.res.AssetManager
+import de.robv.android.xposed.XC_MethodHook
+import de.robv.android.xposed.XposedBridge
+import de.robv.android.xposed.callbacks.XC_LoadPackage
+import GoonXposed.xposed.BuildConfig
+import GoonXposed.xposed.Constants
+import GoonXposed.xposed.Module
+import GoonXposed.xposed.Utils.Companion.JSON
+import GoonXposed.xposed.modules.HookScriptLoaderModule.PRELOADS_DIR
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.put
+import java.io.File
+
+// TODO: Remove this redundant module and merge its functionality into AdditionalBridgeMethodsModule if needed
+class PayloadGlobalModule(private val modules: List<Module>) : Module() {
+    private companion object {
+        const val GLOBAL_NAME = "__PYON_LOADER__"
+    }
+
+    private fun getPayloadString(): String = JSON.encodeToString(
+        buildJsonObject {
+            put("loaderName", Constants.LOADER_NAME)
+            put("loaderVersion", BuildConfig.VERSION_NAME)
+            @Suppress("DEPRECATION") for (module in modules) module.buildPayload(this)
+        })
+
+    override fun onLoad(packageParam: XC_LoadPackage.LoadPackageParam) = with(packageParam) {
+        val catalystInstance = classLoader.safeLoadClass("com.facebook.react.bridge.CatalystInstanceImpl")
+        val scriptLoader = classLoader.safeLoadClass("com.facebook.react.runtime.ReactInstance\$loadJSBundle$1")
+            ?: classLoader.safeLoadClass("com.facebook.react.runtime.ReactInstance$1")
+
+        val setGlobalVariable: (XC_MethodHook.MethodHookParam, String, String) -> Unit = { param, key, json ->
+            runCatching {
+                // Attempt old CatalystInstanceImpl method
+                catalystInstance!!.method(
+                    "setGlobalVariable", String::class.java, String::class.java
+                ).invoke(param.thisObject, key, json)
+            }.onFailure {
+                // Failed (likely because it's a stub), use a workaround
+                val preloadsDir = File("${appInfo.dataDir}/${Constants.FILES_DIR}", PRELOADS_DIR)
+                File(preloadsDir, "rv_globals_$key.js").apply {
+                    writeText("this[${JSON.encodeToString(key)}]=$json")
+
+                    XposedBridge.invokeOriginalMethod(
+                        scriptLoader!!.method(
+                            "loadScriptFromFile",
+                            String::class.java,
+                            String::class.java,
+                            Boolean::class.javaPrimitiveType
+                        ), param.thisObject, arrayOf(absolutePath, absolutePath, param.args[2])
+                    )
+
+                    delete()
+                }
+            }
+        }
+
+        val hook = MethodHookBuilder().run {
+            before {
+                setGlobalVariable(param, GLOBAL_NAME, getPayloadString())
+            }
+
+            build()
+        }
+
+        listOf(catalystInstance, scriptLoader).forEach { if (it != null) hook(it, hook) }
+    }
+
+    private fun hook(instance: Class<*>, hook: XC_MethodHook) {
+        instance.method(
+            "loadScriptFromAssets", AssetManager::class.java, String::class.java, Boolean::class.javaPrimitiveType,
+        ).hook(hook)
+
+        instance.method(
+            "loadScriptFromFile", String::class.java, String::class.java, Boolean::class.javaPrimitiveType
+        ).hook(hook)
+    }
+}

app/src/main/kotlin/ShiggyXposed/xposed/xposed/modules/PluginsModule.kt

@@ -0,0 +1,124 @@
+package GoonXposed.xposed.modules
+
+import android.content.Context
+import android.util.AtomicFile
+import GoonXposed.xposed.Module
+import GoonXposed.xposed.Utils.Log
+import GoonXposed.xposed.modules.bridge.BridgeModule
+import java.io.*
+
+/**
+ * Manages the states of plugins, allowing reading and writing of plugin states to a file.
+ *
+ * ## Methods
+ *
+ * - `Shiggy.plugins.states.read(): { flags: { [pluginId: string]: number } }`
+ * - Reads the current plugin states from the file and returns them as a map.
+ *
+ * - `Shiggy.plugins.states.write(flags: { [pluginId: string]: number }): void`
+ * - Writes the provided plugin states to the file.
+ */
+class PluginsModule : Module() {
+    private companion object {
+        const val DATA_DIR = "Shiggy/plugins"
+        const val STATES_FILE = "states"
+    }
+
+    private lateinit var states: PluginStates
+
+    override fun onContext(context: Context) = with(context) {
+        val dataDir = File(filesDir, DATA_DIR)
+
+        val statesFile = File(
+            dataDir, STATES_FILE
+        ).apply { asFile() }
+
+        BridgeModule.registerMethod("Shiggy.plugins.states.read") {
+            if (::states.isInitialized) states.toMap() else
+                PluginStates.loadFromFileOrNull(statesFile)?.let {
+                    states = it
+                    it.toMap()
+                }
+        }
+
+        BridgeModule.registerMethod("Shiggy.plugins.states.write") {
+            val (flags) = it
+            @Suppress("UNCHECKED_CAST")
+            states = PluginStates(
+                flags as Map<String, Double>
+            ).apply { saveToFile(statesFile) }
+            Log.i("Plugin states saved: ${statesFile.absolutePath}")
+        }
+    }
+}
+
+private class UnsupportedPluginStatesVersionException(version: Int) :
+    Throwable("Unsupported plugin states version: $version")
+
+data class PluginStates(
+    val flags: Map<String, Double>
+) {
+    fun saveToFile(file: File) {
+        val atomic = AtomicFile(file)
+        var fos: FileOutputStream? = null
+        try {
+            fos = atomic.startWrite()
+            val out = DataOutputStream(BufferedOutputStream(fos))
+
+            out.writeInt(CURRENT_VERSION)
+
+            // Write flags
+            out.writeInt(flags.size)
+            for ((id, flags) in flags) {
+                out.writeUTF(id)
+                out.writeInt(flags.toInt())
+            }
+
+            out.flush()
+            atomic.finishWrite(fos)
+        } catch (t: Throwable) {
+            if (fos != null) atomic.failWrite(fos)
+            throw t
+        }
+    }
+
+    fun toMap(): Map<String, Any> = mapOf("flags" to flags)
+
+    companion object {
+        const val CURRENT_VERSION = 1
+
+        fun loadFromFileOrNull(file: File): PluginStates? {
+            if (!file.exists() || file.length() <= 0L) return null
+            val atomic = AtomicFile(file)
+
+            try {
+                DataInputStream(BufferedInputStream(atomic.openRead())).use { input ->
+                    when (val version = input.readInt()) {
+                        1 -> return loadV1FromFileOrNull(input)
+                        else -> throw UnsupportedPluginStatesVersionException(version)
+                    }
+                }
+            } catch (e: UnsupportedPluginStatesVersionException) {
+                Log.i(e.message!!)
+            } catch (e: EOFException) {
+                Log.e("Plugin states corrupt: ${e.message}")
+            } catch (e: IOException) {
+                Log.e("Failed to read plugin states: ${e.message}")
+            }
+
+            runCatching { file.delete() }
+            return null
+        }
+
+        private fun loadV1FromFileOrNull(input: DataInputStream): PluginStates {
+            val flagsSize = input.readInt()
+            val flags = mutableMapOf<String, Double>()
+
+            repeat(flagsSize) {
+                flags[input.readUTF()] = input.readInt().toDouble()
+            }
+
+            return PluginStates(flags)
+        }
+    }
+}

app/src/main/kotlin/ShiggyXposed/xposed/xposed/modules/UpdaterModule.kt

@@ -0,0 +1,155 @@
+package GoonXposed.xposed.modules
+
+import android.app.Activity
+import android.app.AlertDialog
+import android.content.Context
+import android.util.AtomicFile
+import android.widget.Toast
+import androidx.core.util.writeBytes
+import de.robv.android.xposed.callbacks.XC_LoadPackage
+import GoonXposed.xposed.Constants
+import GoonXposed.xposed.Module
+import GoonXposed.xposed.Utils
+import GoonXposed.xposed.Utils.Companion.JSON
+import GoonXposed.xposed.Utils.Companion.reloadApp
+import GoonXposed.xposed.Utils.Log
+import io.ktor.client.*
+import io.ktor.client.call.*
+import io.ktor.client.engine.cio.*
+import io.ktor.client.plugins.*
+import io.ktor.client.request.*
+import io.ktor.client.statement.*
+import io.ktor.http.*
+import kotlinx.coroutines.*
+import kotlinx.serialization.Serializable
+import java.io.File
+import java.lang.ref.WeakReference
+
+@Serializable
+data class CustomLoadUrl(
+    val enabled: Boolean = false, val url: String = ""
+)
+
+@Serializable
+data class LoaderConfig(
+    val customLoadUrl: CustomLoadUrl = CustomLoadUrl()
+)
+
+/**
+ * Module that updates the JS bundle by downloading it from a remote URL.
+ *
+ * Shows dialogs when failed allowing retry.
+ */
+object UpdaterModule : Module() {
+    private lateinit var config: LoaderConfig
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    private var lastActivity: WeakReference<Activity>? = null
+
+    private lateinit var cacheDir: File
+    private lateinit var bundle: File
+    private lateinit var etag: File
+
+    private const val TIMEOUT_CACHED = 5000L
+    private const val TIMEOUT = 10000L
+    private const val ETAG_FILE = "etag.txt"
+    private const val CONFIG_FILE = "loader.json"
+
+    private const val DEFAULT_BUNDLE_URL =
+        "https://github.com/OTKUSteyler/GoonCord/releases/download/latest/gooncord.js"
+
+    override fun onLoad(packageParam: XC_LoadPackage.LoadPackageParam) = with(packageParam) {
+        cacheDir = File(appInfo.dataDir, Constants.CACHE_DIR).apply { mkdirs() }
+        val filesDir = File(appInfo.dataDir, Constants.FILES_DIR).apply { mkdirs() }
+
+        bundle = File(cacheDir, Constants.MAIN_SCRIPT_FILE)
+        etag = File(cacheDir, ETAG_FILE)
+
+        val configFile = File(filesDir, CONFIG_FILE)
+
+        config = runCatching {
+            if (configFile.exists()) {
+                JSON.decodeFromString<LoaderConfig>(configFile.readText())
+            } else LoaderConfig()
+        }.getOrDefault(LoaderConfig())
+    }
+
+    fun downloadScript(activity: Activity? = null): Job = scope.launch {
+        try {
+            HttpClient(CIO) {
+                expectSuccess = false
+                install(UserAgent) { agent = Constants.USER_AGENT }
+                install(HttpRedirect) {}
+            }.use { client ->
+                val url = config.customLoadUrl.takeIf { it.enabled }?.url ?: DEFAULT_BUNDLE_URL
+                Log.i("Fetching JS bundle from: $url")
+
+                val response: HttpResponse = client.get(url) {
+                    headers {
+                        if (etag.exists() && bundle.exists()) {
+                            append(HttpHeaders.IfNoneMatch, etag.readText())
+                        }
+                    }
+
+                    // Retries don't need timeout
+                    if (activity == null) {
+                        timeout {
+                            requestTimeoutMillis = if (!bundle.exists()) TIMEOUT else TIMEOUT_CACHED
+                        }
+                    }
+                }
+
+                when (response.status) {
+                    HttpStatusCode.OK -> {
+                        val bytes: ByteArray = response.body()
+                        AtomicFile(bundle).writeBytes(bytes)
+
+                        val newTag = response.headers[HttpHeaders.ETag]
+                        if (!newTag.isNullOrEmpty()) etag.writeText(newTag) else etag.delete()
+
+                        Log.i("Bundle updated (${bytes.size} bytes)")
+
+                        // This is a retry, so we show a dialog
+                        if (activity != null) {
+                            withContext(Dispatchers.Main) {
+                                AlertDialog.Builder(activity).setTitle("GoonCord Update Successful")
+                                    .setMessage("A reload is required for changes to take effect.")
+                                    .setPositiveButton("Reload") { dialog, _ ->
+                                        reloadApp()
+                                        dialog.dismiss()
+                                    }.setCancelable(false).show()
+                            }
+                        }
+                    }
+
+                    HttpStatusCode.NotModified -> {
+                        Log.i("Server responded with 304, no changes")
+                    }
+
+                    else -> {
+                        throw ResponseException(response, "Received status: ${response.status}")
+                    }
+                }
+            }
+        } catch (e: Throwable) {
+            Log.e("Failed to download script", e)
+            showErrorDialog(e)
+        }
+    }
+
+    override fun onActivity(activity: Activity) {
+        lastActivity = WeakReference(activity)
+    }
+
+    fun showErrorDialog(e: Throwable) {
+        val activity = lastActivity?.get() ?: return
+
+        activity.runOnUiThread {
+        }
+    }
+
+    fun resetLoaderConfig(context: Context) {
+        val filesDir = File(context.dataDir, Constants.FILES_DIR)
+        val config = File(filesDir, CONFIG_FILE)
+        if (config.exists()) config.delete()
+    }
+}

app/src/main/kotlin/ShiggyXposed/xposed/xposed/modules/appearance/FontsModule.kt

@@ -0,0 +1,228 @@
+package GoonXposed.xposed.modules.appearance
+
+import android.content.res.AssetManager
+import android.graphics.Typeface
+import android.graphics.Typeface.CustomFallbackBuilder
+import android.graphics.fonts.Font
+import android.graphics.fonts.FontFamily
+import android.os.Build
+import de.robv.android.xposed.XC_MethodReplacement
+import de.robv.android.xposed.XposedHelpers
+import de.robv.android.xposed.callbacks.XC_LoadPackage
+import GoonXposed.xposed.Constants
+import GoonXposed.xposed.Module
+import GoonXposed.xposed.Utils.Companion.JSON
+import GoonXposed.xposed.Utils.Log
+import io.ktor.client.*
+import io.ktor.client.call.*
+import io.ktor.client.engine.cio.*
+import io.ktor.client.plugins.*
+import io.ktor.client.request.*
+import io.ktor.client.statement.*
+import io.ktor.http.*
+import kotlinx.coroutines.*
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonObjectBuilder
+import kotlinx.serialization.json.put
+import java.io.File
+import java.io.IOException
+
+@Serializable
+data class FontDefinition(
+    val name: String? = null,
+    val description: String? = null,
+    val spec: Int? = null,
+    val main: Map<String, String>,
+)
+
+object FontsModule : Module() {
+    private val EXTENSIONS = arrayOf("", "_bold", "_italic", "_bold_italic")
+    private val FILE_EXTENSIONS = arrayOf(".ttf", ".otf")
+    private const val FONTS_ASSET_PATH = "fonts/"
+
+    private lateinit var fontsDir: File
+    private lateinit var fontsDownloadsDir: File
+    private var fontsAbsPath: String? = null
+
+    override fun buildPayload(builder: JsonObjectBuilder) {
+        builder.apply {
+            put("fontPatch", 2)
+        }
+    }
+
+    override fun onLoad(packageParam: XC_LoadPackage.LoadPackageParam) = with(packageParam) {
+        XposedHelpers.findAndHookMethod(
+            "com.facebook.react.views.text.ReactFontManager\$Companion",
+            classLoader,
+            "createAssetTypeface",
+            String::class.java,
+            Int::class.java,
+            "android.content.res.AssetManager",
+            object : XC_MethodReplacement() {
+                override fun replaceHookedMethod(param: MethodHookParam): Typeface? {
+                    val fontFamilyName: String = param.args[0].toString()
+                    val style: Int = param.args[1] as Int
+                    val assetManager: AssetManager = param.args[2] as AssetManager
+                    return createAssetTypeface(fontFamilyName, style, assetManager)
+                }
+            })
+
+        val fontDefFile = File(appInfo.dataDir, "${Constants.FILES_DIR}/fonts.json").apply { asFile() }
+        if (!fontDefFile.exists()) return@with
+
+        val fontDef = try {
+            JSON.decodeFromString<FontDefinition>(fontDefFile.readText())
+        } catch (_: Throwable) {
+            return@with
+        }
+
+        fontsDownloadsDir = File(appInfo.dataDir, "${Constants.FILES_DIR}/downloads/fonts").apply { asDir() }
+        fontsDir = File(fontsDownloadsDir, fontDef.name!!).apply { asDir() }
+        fontsAbsPath = fontsDir.absolutePath + "/"
+
+        fontsDir.listFiles()?.forEach { file ->
+            val fileName = file.name
+            if (!fileName.startsWith(".")) {
+                val fontName = fileName.split('.')[0]
+                if (fontDef.main.keys.none { it == fontName }) {
+                    Log.i("Deleting font file: $fileName")
+                    file.delete()
+                }
+            }
+        }
+
+        // These files should be downloaded by the JS side, but oh well
+        CoroutineScope(Dispatchers.IO).launch {
+            fontDef.main.keys.map { name ->
+                async {
+                    val url = fontDef.main.getValue(name)
+                    try {
+                        Log.i("Downloading $name from $url")
+                        val file =
+                            File(fontsDir, "$name${FILE_EXTENSIONS.first { url.endsWith(it) }}").apply { asFile() }
+                        if (file.exists()) return@async
+
+                        val client = HttpClient(CIO) {
+                            install(UserAgent) { agent = Constants.USER_AGENT }
+                        }
+
+                        val response: HttpResponse = client.get(url)
+                        if (response.status == HttpStatusCode.OK) file.writeBytes(response.body())
+
+                        return@async
+                    } catch (e: Throwable) {
+                        Log.e("Failed to download fonts ($name from $url)", e)
+                    }
+                }
+            }.awaitAll()
+        }
+    }
+
+    private fun createAssetTypefaceWithFallbacks(
+        fontFamilyNames: Array<String>, style: Int, assetManager: AssetManager
+    ): Typeface? {
+        val fontFamilies: MutableList<FontFamily> = ArrayList()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            // Iterate over the list of fontFamilyNames, constructing new FontFamily objects
+            // for use in the CustomFallbackBuilder below.
+            for (fontFamilyName in fontFamilyNames) {
+                try {
+                    for (fileExtension in FILE_EXTENSIONS) {
+                        val (customName, refName) = fontFamilyName.split(":")
+                        val file = File(fontsDownloadsDir, "$customName/$refName.$fileExtension").apply { asFile() }
+                        val font = Font.Builder(file).build()
+                        val family = FontFamily.Builder(font).build()
+                        fontFamilies.add(family)
+                    }
+                } catch (_: Throwable) {
+                }
+
+                for (fontRootPath in arrayOf(fontsAbsPath, FONTS_ASSET_PATH).filterNotNull()) {
+                    for (fileExtension in FILE_EXTENSIONS) {
+                        val fileName =
+                            StringBuilder().append(fontRootPath).append(fontFamilyName).append(fileExtension).toString()
+                        try {
+                            val builder = if (fileName[0] == '/') Font.Builder(File(fileName)) else Font.Builder(
+                                assetManager, fileName
+                            )
+                            val font = builder.build()
+                            val family = FontFamily.Builder(font).build()
+                            fontFamilies.add(family)
+                        } catch (_: RuntimeException) {
+                            // If the typeface asset does not exist, try another extension.
+                            continue
+                        } catch (_: IOException) {
+                            // If the font asset does not exist, try another extension.
+                            continue
+                        }
+                    }
+                }
+            }
+
+            // If there's some problem constructing fonts, fall back to the default behavior.
+            if (fontFamilies.isEmpty()) return createAssetTypeface(fontFamilyNames[0], style, assetManager)
+
+            val fallbackBuilder = CustomFallbackBuilder(fontFamilies[0])
+            for (i in 1 until fontFamilies.size) {
+                fallbackBuilder.addCustomFallback(fontFamilies[i])
+            }
+            return fallbackBuilder.build()
+        }
+        return null
+    }
+
+    private fun createAssetTypeface(
+        fontFamilyName: String, style: Int, assetManager: AssetManager
+    ): Typeface? {
+        // This logic attempts to safely check if the frontend code is attempting to use
+        // fallback fonts, and if it is, to use the fallback typeface creation logic.
+        var fontFamilyName: String = fontFamilyName
+        val fontFamilyNames = fontFamilyName.split(",".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+        for (i in fontFamilyNames.indices) {
+            fontFamilyNames[i] = fontFamilyNames[i].trim()
+        }
+
+        // If there are multiple font family names:
+        //   For newer versions of Android, construct a Typeface with fallbacks
+        //   For older versions of Android, ignore all the fallbacks and just use the first font family
+        if (fontFamilyNames.size > 1) {
+            fontFamilyName = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                return createAssetTypefaceWithFallbacks(fontFamilyNames, style, assetManager)
+            } else {
+                fontFamilyNames[0]
+            }
+        }
+
+        val extension = EXTENSIONS[style]
+
+        try {
+            for (fileExtension in FILE_EXTENSIONS) {
+                val (customName, refName) = fontFamilyName.split(":")
+                val file = File(fontsDownloadsDir, "$customName/$refName.$fileExtension").apply { asFile() }
+                if (!file.exists()) throw Exception()
+                return Typeface.createFromFile(file.absolutePath)
+            }
+        } catch (_: Throwable) {
+        }
+
+        // Lastly, after all those checks above, this is the original RN logic for
+        // getting the typeface.
+        for (fontRootPath in arrayOf(fontsAbsPath, FONTS_ASSET_PATH).filterNotNull()) {
+            for (fileExtension in FILE_EXTENSIONS) {
+                val fileName =
+                    StringBuilder().append(fontRootPath).append(fontFamilyName).append(extension).append(fileExtension)
+                        .toString()
+
+                return try {
+                    if (fileName[0] == '/') Typeface.createFromFile(fileName)
+                    else Typeface.createFromAsset(assetManager, fileName)
+                } catch (_: RuntimeException) {
+                    // If the typeface asset does not exist, try another extension.
+                    continue
+                }
+            }
+        }
+
+        return Typeface.create(fontFamilyName, style)
+    }
+}

app/src/main/kotlin/ShiggyXposed/xposed/xposed/modules/appearance/SysColorsModule.kt

@@ -0,0 +1,43 @@
+package GoonXposed.xposed.modules.appearance
+
+import android.R.color
+import android.app.AndroidAppHelper
+import android.content.Context
+import android.os.Build
+import androidx.core.content.ContextCompat
+import GoonXposed.xposed.Module
+import kotlinx.serialization.json.*
+import java.lang.ref.WeakReference
+
+object SysColorsModule : Module() {
+    private lateinit var context: WeakReference<Context>
+    private fun isSupported() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
+
+    override fun buildPayload(builder: JsonObjectBuilder) {
+        context = WeakReference(AndroidAppHelper.currentApplication())
+        val accents = arrayOf("accent1", "accent2", "accent3", "neutral1", "neutral2")
+        val shades = arrayOf(0, 10, 50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000)
+
+        builder.apply {
+            put("isSysColorsSupported", isSupported())
+            if (isSupported()) putJsonObject("sysColors") {
+                for (accent in accents) putJsonArray(accent) {
+                    for (shade in shades) {
+                        val colorName = "system_" + accent + "_" + shade
+
+                        val colorResourceId = runCatching {
+                            color::class.java.getField(colorName).getInt(null)
+                        }.getOrElse { 0 }
+
+                        add(convertToColor(colorResourceId))
+                    }
+                }
+            }
+        }
+    }
+
+    private fun convertToColor(id: Int): String {
+        val clr = if (isSupported()) ContextCompat.getColor(context.get()!!, id) else 0
+        return String.format("#%06X", 0xFFFFFF and clr)
+    }
+}

app/src/main/kotlin/ShiggyXposed/xposed/xposed/modules/appearance/ThemesModule.kt

@@ -0,0 +1,159 @@
+package GoonXposed.xposed.modules.appearance
+
+import android.content.Context
+import android.content.res.Resources
+import androidx.core.graphics.toColorInt
+import de.robv.android.xposed.callbacks.XC_LoadPackage
+import GoonXposed.xposed.Constants
+import GoonXposed.xposed.Module
+import GoonXposed.xposed.Utils.Companion.JSON
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonObjectBuilder
+import kotlinx.serialization.json.encodeToJsonElement
+import kotlinx.serialization.json.put
+import java.io.File
+
+@Serializable
+data class Author(
+    val name: String, val id: String? = null
+)
+
+@Serializable
+data class ThemeData(
+    val name: String,
+    val description: String? = null,
+    val authors: List<Author>? = null,
+    val spec: Int,
+    val semanticColors: Map<String, List<String>>? = null,
+    val rawColors: Map<String, String>? = null
+)
+
+@Serializable
+data class Theme(
+    val id: String, val selected: Boolean, val data: ThemeData
+)
+
+object ThemesModule : Module() {
+    private lateinit var param: XC_LoadPackage.LoadPackageParam
+
+    private var theme: Theme? = null
+    private val rawColorMap = mutableMapOf<String, Int>()
+
+    private const val THEME_FILE = "current-theme.json"
+
+
+    @ExperimentalSerializationApi
+    override fun buildPayload(builder: JsonObjectBuilder) {
+        builder.apply {
+            put("hasThemeSupport", true)
+            if (theme != null) put("storedTheme", JSON.encodeToJsonElement<Theme>(theme!!))
+            else put("storedTheme", null)
+        }
+    }
+
+    private fun String.fromScreamingSnakeToCamelCase() =
+        this.split("_").joinToString("") { it -> it.lowercase().replaceFirstChar { it.uppercase() } }
+
+    override fun onLoad(packageParam: XC_LoadPackage.LoadPackageParam) {
+        param = packageParam
+        theme = getTheme()
+        hookTheme()
+    }
+
+    private fun File.isValidThemeFile(): Boolean {
+        if (!this.exists()) return false
+
+        val text = this.readText()
+        return text.isNotBlank() && text != "{}" && text != "null"
+    }
+
+    private fun getTheme(): Theme? {
+        val themeFile = File(param.appInfo.dataDir, "${Constants.FILES_DIR}/${THEME_FILE}").apply { asFile() }
+        if (!themeFile.isValidThemeFile()) return null
+
+        return try {
+            val themeText = themeFile.readText()
+            JSON.decodeFromString<Theme>(themeText)
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    fun hookTheme() {
+        val themeManager = param.classLoader.loadClass("com.discord.theme.utils.ColorUtilsKt")
+        val darkTheme = param.classLoader.loadClass("com.discord.theme.DarkerTheme")
+        val lightTheme = param.classLoader.loadClass("com.discord.theme.LightTheme")
+
+        val theme = this.theme ?: return
+
+        // Apply rawColors
+        theme.data.rawColors?.forEach { (key, value) ->
+            rawColorMap[key.lowercase()] = hexStringToColorInt(value)
+        }
+
+        // Apply semanticColors
+        theme.data.semanticColors?.forEach { (key, value) ->
+            // TEXT_NORMAL -> getTextNormal
+            val methodName = "get${key.fromScreamingSnakeToCamelCase()}"
+            value.forEachIndexed { index, v ->
+                when (index) {
+                    0 -> hookThemeMethod(darkTheme, methodName, hexStringToColorInt(v))
+                    1 -> hookThemeMethod(lightTheme, methodName, hexStringToColorInt(v))
+                }
+            }
+        }
+
+        // If there's any rawColors value, hook the color getter
+        if (!theme.data.rawColors.isNullOrEmpty()) {
+            val getColorCompat = themeManager.getDeclaredMethod(
+                "getColorCompat",
+                Resources::class.java,
+                Int::class.javaPrimitiveType,
+                Resources.Theme::class.java,
+            )
+
+            val getColorCompatLegacy = themeManager.getDeclaredMethod(
+                "getColorCompat", Context::class.java, Int::class.javaPrimitiveType
+            )
+
+            val patch = MethodHookBuilder().run {
+                before {
+                    val arg1 = args[0]
+                    val resources = if (arg1 is Context) arg1.resources else (arg1 as Resources)
+                    val name = resources.getResourceEntryName(args[1] as Int)
+
+                    if (rawColorMap[name] != null) result = rawColorMap[name]
+                }
+
+                build()
+            }
+
+            getColorCompat.hook(patch)
+            getColorCompatLegacy.hook(patch)
+        }
+    }
+
+    // Parse HEX colour string to INT. Takes "#RRGGBBAA" or "#RRGGBB"
+    private fun hexStringToColorInt(hexString: String): Int {
+        return if (hexString.length == 9) {
+            // Rearrange RRGGBBAA -> AARRGGBB so parseColor() is happy
+            val alpha = hexString.substring(7, 9)
+            val rrggbb = hexString.substring(1, 7)
+            "#$alpha$rrggbb".toColorInt()
+        } else hexString.toColorInt()
+    }
+
+    private fun hookThemeMethod(themeClass: Class<*>, methodName: String, themeValue: Int) {
+        try {
+            themeClass.getDeclaredMethod(methodName).let { method ->
+                method.hook {
+                    before {
+                        result = themeValue
+                    }
+                }
+            }
+        } catch (_: NoSuchMethodException) {
+        }
+    }
+}

app/src/main/kotlin/ShiggyXposed/xposed/xposed/modules/bridge/AdditionalBridgeMethodsModule.kt

@@ -0,0 +1,94 @@
+package GoonXposed.xposed.modules.bridge
+
+import android.app.Activity
+import android.app.AlertDialog
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import android.os.Build
+import android.widget.Toast
+import GoonXposed.xposed.Module
+import GoonXposed.xposed.Utils
+import java.io.File
+
+object AdditionalBridgeMethodsModule : Module() {
+    override fun onContext(context: Context) = with(context) {
+        BridgeModule.registerMethod("Shiggy.fs.getConstants") {
+            mapOf(
+                "data" to dataDir.absolutePath,
+                "files" to filesDir.absolutePath,
+                "cache" to cacheDir.absolutePath,
+            )
+        }
+
+        BridgeModule.registerMethod("Shiggy.fs.delete") {
+            val (path) = it
+            File(path as String).run {
+                if (this.isDirectory) this.deleteRecursively()
+                else this.delete()
+            }
+        }
+
+        BridgeModule.registerMethod("Shiggy.fs.exists") {
+            val (path) = it
+            File(path as String).exists()
+        }
+
+        BridgeModule.registerMethod("Shiggy.fs.read") { it ->
+            val (path) = it
+            val file = File(path as String).apply { openFileGuarded() }
+
+            file.bufferedReader().use { it.readText() }
+        }
+
+        BridgeModule.registerMethod("Shiggy.fs.write") {
+            val (path, contents) = it
+            val file = File(path as String).apply { openFileGuarded() }
+
+            file.writeText(contents as String)
+        }
+    }
+
+    override fun onActivity(activity: Activity) = with(activity) {
+        BridgeModule.registerMethod("Shiggy.alertError") {
+            val (error, version) = it
+            val app = getAppInfo()
+            val errorString = "$error"
+
+            val clipboard = applicationContext.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+            val clip = ClipData.newPlainText("Stack Trace", errorString)
+
+            AlertDialog.Builder(this)
+                .setTitle("GoonCord Error")
+                .setMessage(
+                    """
+                    GoonCord: $version
+                    ${app.name}: ${app.version} (${app.versionCode})
+                    Device: ${Build.MANUFACTURER} ${Build.MODEL}
+
+
+                """.trimIndent() + errorString
+                )
+                .setPositiveButton("OK") { dialog, _ ->
+                    dialog.dismiss()
+                }
+                .setNeutralButton("Copy") { dialog, _ ->
+                    clipboard.setPrimaryClip(clip)
+                    Toast.makeText(applicationContext, "Copied stack trace", Toast.LENGTH_SHORT).show()
+                    dialog.dismiss()
+                }
+                .show()
+
+            null
+        }
+
+        BridgeModule.registerMethod("Shiggy.showRecoveryAlert") {
+            Utils.showRecoveryAlert(this)
+        }
+    }
+
+    private fun File.openFileGuarded() {
+        if (!this.exists()) throw Error("Path does not exist: $path")
+        if (!this.isFile) throw Error("Path is not a file: $path")
+    }
+}

app/src/main/kotlin/ShiggyXposed/xposed/xposed/modules/bridge/BridgeModule.kt

@@ -0,0 +1,157 @@
+package GoonXposed.xposed.modules.bridge
+
+import de.robv.android.xposed.callbacks.XC_LoadPackage
+import GoonXposed.xposed.BuildConfig
+import GoonXposed.xposed.Constants
+import GoonXposed.xposed.Module
+import GoonXposed.xposed.Utils.Log
+import java.lang.reflect.Method
+
+/**
+ * See for possible return types:
+ * https://github.com/facebook/react-native/blob/c23e84ae9/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridge/Arguments.kt#L19
+ *
+ * You may return a [Unit] and the resulting value will be `null`.
+ */
+typealias BridgeMethodCallback = (args: BridgeMethodArgs) -> Any?
+
+typealias BridgeMethodArgs = ArrayList<Any>
+
+/**
+ * A module that exposes a bridge for calling methods from JavaScript.
+ *
+ * To call a method, pass an object with the following structure to a hooked method:
+ * ```js
+ * {
+ *   Shiggy: {
+ *     method: "method.name",
+ *     args: [arg1, arg2, ...]
+ *   }
+ * }
+ * ```
+ *
+ * For methods that accept additional arguments, only the first object argument is used for the bridge call.
+ *
+ * The result will be an object with either a `result` or `error` key:
+ * ```js
+ * {
+ *   result: ... // The return value of the method
+ * }
+ * ```
+ * or
+ * ```js
+ * {
+ *   error: "Error message"
+ * }
+ * ```
+ */
+object BridgeModule : Module() {
+    private lateinit var readableMapGetString: Method
+    private lateinit var readableMapToHashMap: Method
+    private lateinit var argumentsMakeNative: Method
+
+    private const val CALL_DATA_KEY = "Shiggy"
+    private const val METHOD_NAME_KEY = "method"
+    private const val METHOD_ARGS_KEY = "args"
+
+    private val methods: MutableMap<String, BridgeMethodCallback> = mutableMapOf()
+
+    /**
+     * Registers a bridge method that can be called from JavaScript.
+     *
+     * If the method is already registered, it will be overwritten.
+     *
+     * @param name The name of the method to register.
+     * @param callback The callback to invoke when the method is called.
+     */
+    fun registerMethod(name: String, callback: BridgeMethodCallback) {
+        if (methods.containsKey(name)) Log.w("Bridge method already exists and will be overridden: $name")
+        methods[name] = callback
+    }
+
+    override fun onLoad(packageParam: XC_LoadPackage.LoadPackageParam) = with(packageParam) {
+        val arguments = classLoader.loadClass("com.facebook.react.bridge.Arguments")
+        val readableMap = classLoader.loadClass("com.facebook.react.bridge.ReadableMap")
+        val promise = classLoader.loadClass("com.facebook.react.bridge.Promise")
+
+        val promiseResolve = promise.method("resolve", Object::class.java)
+        argumentsMakeNative = arguments.method("makeNativeObject", Object::class.java)
+        readableMapGetString = readableMap.method("getString", String::class.java)
+        readableMapToHashMap = readableMap.method("toHashMap")
+
+        classLoader.loadClass("com.horcrux.svg.RNSVGRenderableManager")
+            .hookMethod("getBBox", Double::class.javaObjectType, readableMap) {
+                before {
+                    callBridgeMethod(readableMapToHashMap(args[1]!!))?.let { result = it.toNativeObject() }
+                }
+            }
+
+        classLoader.loadClass("com.facebook.react.modules.blob.FileReaderModule")
+            .hookMethod("readAsDataURL", readableMap, promise) {
+                before {
+                    val (readableMap, promise) = args
+                    callBridgeMethod(readableMapToHashMap(readableMap!!))?.let {
+                        promiseResolve.invoke(promise, it.toNativeObject())
+                        result = null
+                    }
+                }
+            }
+
+        // Clear methods every package load. Plugins should re-register on each load.
+        methods.clear()
+        registerDefaultMethods()
+
+        return@with
+    }
+
+    private fun registerDefaultMethods() {
+        methods["Shiggy.info"] = {
+            mapOf(
+                "name" to Constants.LOADER_NAME, "version" to BuildConfig.VERSION_CODE
+            )
+        }
+
+        methods["Shiggy.test"] = {
+            mapOf(
+                "string" to "string",
+                "number" to 7256,
+                "array" to listOf("testing", 527737, listOf(true)),
+                "object" to mapOf("nested" to true),
+                "boolean" to false,
+                "args" to it,
+            )
+        }
+    }
+
+    private fun Any?.toNativeObject(): Any? = argumentsMakeNative.invoke(
+        null, when (this) {
+            Unit -> null
+            else -> this
+        }
+    )
+
+    private fun readableMapToHashMap(map: Any): HashMap<String, Any?> {
+        @Suppress("UNCHECKED_CAST") return readableMapToHashMap.invoke(map) as HashMap<String, Any?>
+    }
+
+    private fun callBridgeMethod(hashMap: HashMap<String, Any?>): Map<String, Any?>? = try {
+        val (method, args) = getBridgeCallData(hashMap) ?: return null
+        val ret = method(args).toNativeObject()
+        mapOf("result" to ret)
+    } catch (e: Throwable) {
+        mapOf("error" to e.stackTraceToString())
+    }
+
+    private fun getBridgeCallData(hashMap: HashMap<String, Any?>): Pair<BridgeMethodCallback, BridgeMethodArgs>? {
+        @Suppress("UNCHECKED_CAST") val data = hashMap[CALL_DATA_KEY] as HashMap<String, Any?>?
+        data ?: return null
+
+        @Suppress("UNCHECKED_CAST") val name = data[METHOD_NAME_KEY] as String
+        val method = methods[name]
+        method ?: throw Error("Method not registered: $name")
+
+        @Suppress("UNCHECKED_CAST") val args = data[METHOD_ARGS_KEY] as BridgeMethodArgs
+
+        return Pair(method, args)
+    }
+}

app/src/main/kotlin/ShiggyXposed/xposed/xposed/modules/no_track/BlockCrashReportingModule.kt

@@ -0,0 +1,50 @@
+package GoonXposed.xposed.modules.no_track
+
+import android.content.Context
+import de.robv.android.xposed.callbacks.XC_LoadPackage
+import GoonXposed.xposed.Module
+import GoonXposed.xposed.Utils.Log
+
+/**
+ * Hooks Discord's crash reporting to disable Sentry initialization.
+ * While Discord doesn't have Sentry auto-initialization on by default, we still hook the content provider just to be safe.
+ */
+object BlockCrashReportingModule : Module() {
+    override fun onLoad(packageParam: XC_LoadPackage.LoadPackageParam) = with(packageParam) {
+        val crashReportingClass = classLoader.safeLoadClass("com.discord.crash_reporting.CrashReporting")
+        crashReportingClass?.apply {
+
+            // This only exists on 30720x and above
+            runCatching {
+                hookMethod("isDisabled") {
+                    before {
+                        Log.i("Forced CrashReporting.isDisabled() to true")
+                        result = true
+                    }
+                }
+            }.onFailure {
+                // In older versions, this hook works fine.
+                // Hooking this on 30720x will result in a crash after a few seconds,
+                // since Discord asserts initialization when setting a Sentry tag.
+                hookMethod(
+                    "init", Context::class.java, String::class.java
+                ) {
+                    before {
+                        Log.i("Blocked CrashReporting initialization")
+                        result = null
+                    }
+                }
+            }
+        }
+
+        val sentryInitProviderClass = classLoader.safeLoadClass("io.sentry.android.core.SentryInitProvider")
+        sentryInitProviderClass?.hookMethod("onCreate") {
+            before {
+                Log.i("Blocked SentryInitProvider initialization")
+                result = true
+            }
+        }
+
+        return@with
+    }
+}

app/src/main/kotlin/ShiggyXposed/xposed/xposed/modules/no_track/BlockDeepLinksTrackingModule.kt

@@ -0,0 +1,25 @@
+package GoonXposed.xposed.modules.no_track
+
+import android.content.Context
+import de.robv.android.xposed.callbacks.XC_LoadPackage
+import GoonXposed.xposed.Module
+import GoonXposed.xposed.Utils.Log
+
+/**
+ * Hooks Discord's deep links tracking to disable AppsFlyer initialization.
+ */
+object BlockDeepLinksTrackingModule : Module() {
+    override fun onLoad(packageParam: XC_LoadPackage.LoadPackageParam) = with(packageParam) {
+        val deepLinksClass = classLoader.safeLoadClass("com.discord.deep_link.DeepLinks")
+        deepLinksClass?.hookMethod(
+            "init", Context::class.java
+        ) {
+            before {
+                Log.i("Blocked DeepLinks tracking initialization")
+                result = null
+            }
+        }
+
+        return@with
+    }
+}