diff --git a/app/src/main/java/com/fluxa/app/ui/catalog/HomeLibraryCoordinator.kt b/app/src/main/java/com/fluxa/app/ui/catalog/HomeLibraryCoordinator.kt
index 83c5c5d..6fe19ab 100644
--- a/app/src/main/java/com/fluxa/app/ui/catalog/HomeLibraryCoordinator.kt
+++ b/app/src/main/java/com/fluxa/app/ui/catalog/HomeLibraryCoordinator.kt
@@ -1,7 +1,7 @@
 package com.fluxa.app.ui.catalog
 
 import android.util.Log
-import com.fluxa.app.core.rust.FluxaCoreStateHandle
+import com.fluxa.app.core.rust.FluxaUniFfiCoreStateHandle
 import com.fluxa.app.data.local.*
 import com.fluxa.app.data.local.UserProfile
 import com.fluxa.app.data.remote.Meta
@@ -36,7 +36,7 @@ internal class HomeLibraryCoordinator(
     private val repository: StremioRepository,
     private val traktRepository: TraktRepository,
     private val scope: CoroutineScope,
-    private val coreState: FluxaCoreStateHandle,
+    private val coreState: FluxaUniFfiCoreStateHandle,
     private val gson: Gson
 ) {
     private val _state = MutableStateFlow(LibraryUiState())
diff --git a/app/src/main/java/com/fluxa/app/ui/catalog/HomeSearchFocusStateHolder.kt b/app/src/main/java/com/fluxa/app/ui/catalog/HomeSearchFocusStateHolder.kt
index d23fa83..7f598a9 100644
--- a/app/src/main/java/com/fluxa/app/ui/catalog/HomeSearchFocusStateHolder.kt
+++ b/app/src/main/java/com/fluxa/app/ui/catalog/HomeSearchFocusStateHolder.kt
@@ -1,7 +1,7 @@
 package com.fluxa.app.ui.catalog
 
-import com.fluxa.app.core.rust.FluxaCoreNative
-import com.fluxa.app.core.rust.FluxaCoreStateHandle
+import com.fluxa.app.core.rust.FluxaCoreUniFfi
+import com.fluxa.app.core.rust.FluxaUniFfiCoreStateHandle
 import com.fluxa.app.data.remote.Meta
 import com.google.gson.Gson
 import java.io.Closeable
@@ -11,7 +11,7 @@ import kotlinx.coroutines.flow.asStateFlow
 
 class HomeSearchFocusStateHolder(
     initialHistory: List<Meta>,
-    private val coreState: FluxaCoreStateHandle = FluxaCoreNative.createAppCoreState(
+    private val coreState: FluxaUniFfiCoreStateHandle = FluxaCoreUniFfi.createAppCoreState(
         mapOf(
             "homeSearch" to mapOf(
                 "searchHistory" to initialHistory
diff --git a/app/src/main/java/com/fluxa/app/ui/catalog/HomeViewModel.kt b/app/src/main/java/com/fluxa/app/ui/catalog/HomeViewModel.kt
index 10cc57c..85ee1cc 100644
--- a/app/src/main/java/com/fluxa/app/ui/catalog/HomeViewModel.kt
+++ b/app/src/main/java/com/fluxa/app/ui/catalog/HomeViewModel.kt
@@ -6,7 +6,8 @@ import com.fluxa.app.data.remote.*
 import com.fluxa.app.data.repository.*
 import com.fluxa.app.core.rust.FluxaAndroidHeadlessEnvironment
 import com.fluxa.app.core.rust.FluxaCoreNative
-import com.fluxa.app.core.rust.FluxaCoreStateHandle
+import com.fluxa.app.core.rust.FluxaCoreUniFfi
+import com.fluxa.app.core.rust.FluxaUniFfiCoreStateHandle
 import com.fluxa.app.core.rust.FluxaHeadlessRuntimeFactory
 import com.fluxa.app.domain.discovery.DiscoverCatalogOption
 import com.fluxa.app.domain.discovery.MetadataFeedOption
@@ -71,7 +72,7 @@ class HomeViewModel @Inject constructor(
     private val addonListType = object : TypeToken<List<AddonDescriptor>>() {}.type
     private val headlessRuntime = FluxaHeadlessRuntimeFactory.createUniFfi(headlessEnvironment)
     private val initialSearchHistory = searchHistoryStore.load(null)
-    private val coreState: FluxaCoreStateHandle = FluxaCoreNative.createAppCoreState(
+    private val coreState: FluxaUniFfiCoreStateHandle = FluxaCoreUniFfi.createAppCoreState(
         mapOf(
             "home" to mapOf(
                 "categories" to emptyList<HomeCategory>(),
@@ -143,6 +144,7 @@ class HomeViewModel @Inject constructor(
             scope = viewModelScope,
             gson = gson,
             dispatch = ::dispatchHeadless,
+            activeProfile = { currentActiveProfile },
             setActiveProfile = { setActiveProfileState(it) },
             setWatchlist = ::setWatchlistState,
             setContinueWatching = ::setCurrentWatchlistState,
@@ -237,6 +239,16 @@ class HomeViewModel @Inject constructor(
     private var currentWatchlist: List<Meta> = emptyList()
     private val _currentContinueWatchingCount = MutableStateFlow(0)
     val currentContinueWatchingCount: StateFlow<Int> = _currentContinueWatchingCount.asStateFlow()
+    private val _syncingProviders = MutableStateFlow<Set<String>>(emptySet())
+    val syncingProviders: StateFlow<Set<String>> = _syncingProviders.asStateFlow()
+
+    fun setProviderSyncing(provider: String, syncing: Boolean) {
+        _syncingProviders.value = if (syncing) {
+            _syncingProviders.value + provider
+        } else {
+            _syncingProviders.value - provider
+        }
+    }
     private var externalContinueWatching: List<Meta> = emptyList()
     private var traktWatchedState: TraktWatchedState = TraktWatchedState()
     private var currentActiveProfile: UserProfile? = null
@@ -1086,7 +1098,7 @@ class HomeViewModel @Inject constructor(
         cacheSaveJob?.cancel()
         cacheSaveJob = viewModelScope.launch(Dispatchers.Default) {
             delay(600)
-            homeCategoryCache.save(profile, categories)
+            homeCategoryCache.save(profile, categories.filterNot { it.id == "continue_watching" })
         }
     }
 
diff --git a/app/src/main/java/com/fluxa/app/ui/catalog/HomeViewModelCoordinatorFactory.kt b/app/src/main/java/com/fluxa/app/ui/catalog/HomeViewModelCoordinatorFactory.kt
index cd62bb1..3c086d8 100644
--- a/app/src/main/java/com/fluxa/app/ui/catalog/HomeViewModelCoordinatorFactory.kt
+++ b/app/src/main/java/com/fluxa/app/ui/catalog/HomeViewModelCoordinatorFactory.kt
@@ -1,7 +1,7 @@
 package com.fluxa.app.ui.catalog
 
 import android.content.Context
-import com.fluxa.app.core.rust.FluxaCoreStateHandle
+import com.fluxa.app.core.rust.FluxaUniFfiCoreStateHandle
 import com.fluxa.app.data.local.UserProfile
 import com.fluxa.app.data.local.WatchlistManager
 import com.fluxa.app.data.remote.AddonDescriptor
@@ -19,7 +19,7 @@ class HomeViewModelCoordinatorFactory @Inject constructor() {
         repository: StremioRepository,
         traktRepository: TraktRepository,
         scope: CoroutineScope,
-        coreState: FluxaCoreStateHandle,
+        coreState: FluxaUniFfiCoreStateHandle,
         gson: Gson
     ): HomeLibraryCoordinator {
         return HomeLibraryCoordinator(repository, traktRepository, scope, coreState, gson)
diff --git a/app/src/main/java/com/fluxa/app/ui/catalog/PlayerScreenState.kt b/app/src/main/java/com/fluxa/app/ui/catalog/PlayerScreenState.kt
index cda62e4..93b500c 100644
--- a/app/src/main/java/com/fluxa/app/ui/catalog/PlayerScreenState.kt
+++ b/app/src/main/java/com/fluxa/app/ui/catalog/PlayerScreenState.kt
@@ -11,8 +11,8 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.media3.ui.AspectRatioFrameLayout
-import com.fluxa.app.core.rust.FluxaCoreNative
-import com.fluxa.app.core.rust.FluxaCoreStateHandle
+import com.fluxa.app.core.rust.FluxaCoreUniFfi
+import com.fluxa.app.core.rust.FluxaUniFfiCoreStateHandle
 import com.fluxa.app.data.remote.IntroTimestamps
 import com.fluxa.app.data.remote.Stream
 import com.fluxa.app.data.remote.Video
@@ -39,7 +39,7 @@ internal class PlayerScreenState(
     initialVolume: Int
 ) {
     private val gson = Gson()
-    private val coreState: FluxaCoreStateHandle = FluxaCoreNative.createAppCoreState(
+    private val coreState: FluxaUniFfiCoreStateHandle = FluxaCoreUniFfi.createAppCoreState(
         mapOf(
             "player" to mapOf(
                 "currentVideoId" to initialVideoId,
@@ -111,7 +111,6 @@ internal class PlayerScreenState(
 
     var showSettings by mutableStateOf(false)
     var activeSettingsTab by mutableIntStateOf(0)
-    var inlineDelayTarget by mutableStateOf<Int?>(null)
     var audioDelayMs by mutableLongStateOf(0L)
     var subtitleDelayMs by mutableLongStateOf(0L)
 
diff --git a/app/src/test/java/com/fluxa/app/core/rust/FluxaCoreBenchmarkTest.kt b/app/src/test/java/com/fluxa/app/core/rust/FluxaCoreBenchmarkTest.kt
index ca8a7e4..eea1a13 100644
--- a/app/src/test/java/com/fluxa/app/core/rust/FluxaCoreBenchmarkTest.kt
+++ b/app/src/test/java/com/fluxa/app/core/rust/FluxaCoreBenchmarkTest.kt
@@ -407,11 +407,11 @@ class FluxaCoreBenchmarkTest {
                 !name.contains("cacheTrimPolicy", ignoreCase = true)
         }
         assertTrue(nativeCacheStorageFunctions.isEmpty())
-        assertTrue(nativeFunctionNames.any { it == "cacheEntryPolicyJsonNative" })
-        assertTrue(nativeFunctionNames.any { it == "cacheTrimPolicyJsonNative" })
+        assertTrue(nativeFunctionNames.any { it == "cacheEntryPolicy" })
+        assertTrue(nativeFunctionNames.any { it == "cacheTrimPolicy" })
         assertFalse(nativeFunctionNames.any { it == "startLocalStreamServerNative" })
         assertFalse(nativeFunctionNames.any { it == "stopLocalStreamServerNative" })
-        assertTrue(nativeFunctionNames.any { it == "parseManifestJsonNative" })
+        assertTrue(nativeFunctionNames.any { it == "coreInvokeNative" })
     }
 
     private fun startStaticServer(payload: ByteArray, requestCount: AtomicInteger): StaticByteServer {
diff --git a/app/src/test/java/com/fluxa/app/core/rust/FluxaCoreUniFfiContractTest.kt b/app/src/test/java/com/fluxa/app/core/rust/FluxaCoreUniFfiContractTest.kt
index 9f54fcc..4839020 100644
--- a/app/src/test/java/com/fluxa/app/core/rust/FluxaCoreUniFfiContractTest.kt
+++ b/app/src/test/java/com/fluxa/app/core/rust/FluxaCoreUniFfiContractTest.kt
@@ -34,4 +34,13 @@ class FluxaCoreUniFfiContractTest {
             assertEquals("Movie", meta["name"])
         }
     }
+
+    @Test
+    fun coreInvokeRoutesCalendarMethodThroughUniFfi() {
+        val value = FluxaCoreUniFfi.coreInvokeValue(
+            "calendarSeasonCandidates",
+            """{"seasonsCount":10,"lastVideoId":"tt1:2:3"}"""
+        )
+        assertEquals("[2,3,10]", value.toString())
+    }
 }
diff --git a/data/src/androidMain/kotlin/com/fluxa/app/core/rust/FluxaCoreNative.kt b/data/src/androidMain/kotlin/com/fluxa/app/core/rust/FluxaCoreNative.kt
index 0dd156d..90758de 100644
--- a/data/src/androidMain/kotlin/com/fluxa/app/core/rust/FluxaCoreNative.kt
+++ b/data/src/androidMain/kotlin/com/fluxa/app/core/rust/FluxaCoreNative.kt
@@ -69,6 +69,8 @@ import com.google.gson.stream.JsonReader
 import java.io.Closeable
 import java.io.StringReader
 
+private fun urlArgs(url: String): String = JsonObject().apply { addProperty("url", url) }.toString()
+
 private fun JsonObject.stringOrNull(key: String): String? =
     get(key)?.takeUnless { it.isJsonNull }?.asString
 
@@ -211,13 +213,6 @@ data class NativeCloudstreamRequest(
     val timeoutMs: Long = 0L
 )
 
-// ── calendar_plan ─────────────────────────────────────────────────────────────
-
-data class NativeCalendarNotificationContent(
-    val items: List<Map<String, Any?>> = emptyList(),
-    val keys: List<String> = emptyList()
-)
-
 data class NativeDetailSeasonLoadPlan(
     val firstSeasonToLoad: Int = 1,
     val savedSeason: Int? = null
@@ -599,10 +594,10 @@ object FluxaCoreNative {
         }.getOrDefault(emptyMap())
     }
 
-    fun coreCapabilities(portable: Boolean = false): NativeCoreCapabilitySet = call {
-        val json = coreCapabilitiesJsonNative(portable)
-        json.takeIf { it.isNotBlank() }?.let { gson.fromJson(it, NativeCoreCapabilitySet::class.java) }
-            ?: NativeCoreCapabilitySet()
+    fun coreCapabilities(portable: Boolean = false): NativeCoreCapabilitySet {
+        val args = JsonObject().apply { addProperty("portable", portable) }
+        val value = FluxaCoreUniFfi.coreInvokeValue("coreCapabilities", args.toString())
+        return gson.fromJson(value, NativeCoreCapabilitySet::class.java) ?: NativeCoreCapabilitySet()
     }
 
     internal fun appCoreStateJson(handle: Long): String = call {
@@ -621,53 +616,60 @@ object FluxaCoreNative {
         coreInvokeNative(method, argsJson).orEmpty()
     }
 
-    fun normalizeManifestUrl(rawUrl: String): String = call { normalizeManifestUrlNative(rawUrl) }
+    fun normalizeManifestUrl(rawUrl: String): String =
+        FluxaCoreUniFfi.coreInvokeValue("normalizeManifestUrl", urlArgs(rawUrl)).asString
 
-    fun identity(rawUrl: String): String = call { identityNative(rawUrl) }
+    fun identity(rawUrl: String): String =
+        FluxaCoreUniFfi.coreInvokeValue("identity", urlArgs(rawUrl)).asString
 
-    fun manifestCandidates(rawUrl: String): List<String> = call {
-        manifestCandidatesJsonNative(rawUrl)
-    }.let { json ->
-        gson.fromJson<List<String>>(json, stringListType)
+    fun manifestCandidates(rawUrl: String): List<String> {
+        val value = FluxaCoreUniFfi.coreInvokeValue("manifestCandidates", urlArgs(rawUrl))
+        return gson.fromJson(value, stringListType) ?: emptyList()
     }
 
-    fun manifestFetchPlan(rawUrl: String): NativeManifestFetchPlan? = call {
-        manifestFetchPlanJsonNative(rawUrl)
-            ?.takeIf { it.isNotBlank() }
-            ?.let { gson.fromJson(it, NativeManifestFetchPlan::class.java) }
+    fun manifestFetchPlan(rawUrl: String): NativeManifestFetchPlan? {
+        val value = FluxaCoreUniFfi.coreInvokeValue("manifestFetchPlan", urlArgs(rawUrl))
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson(it, NativeManifestFetchPlan::class.java) }
     }
 
-    fun baseUrl(rawUrl: String): String = call { baseUrlNative(rawUrl) }
+    fun baseUrl(rawUrl: String): String =
+        FluxaCoreUniFfi.coreInvokeValue("baseUrl", urlArgs(rawUrl)).asString
 
     fun preferHttpsAssetUrl(rawUrl: String): String? {
-        val resolved = call {
-            preferHttpsAssetUrlNative(rawUrl).takeIf { it.isNotBlank() }
-        }
-        return resolved
+        val value = FluxaCoreUniFfi.coreInvokeValue("preferHttpsAssetUrl", urlArgs(rawUrl))
+        return value.takeUnless { it.isJsonNull }?.asString?.takeIf { it.isNotBlank() }
     }
 
-    fun addonStoreInputType(text: String): String = call {
-        addonStoreInputTypeNative(text)
-    }
+    fun addonStoreInputType(text: String): String =
+        FluxaCoreUniFfi.coreInvokeValue(
+            "addonStoreInputType",
+            JsonObject().apply { addProperty("input", text) }.toString()
+        ).asString
 
-    fun normalizeCloudstreamRepoUrl(rawUrl: String): String = call {
-        normalizeCloudstreamRepoUrlNative(rawUrl)
-    }
+    fun normalizeCloudstreamRepoUrl(rawUrl: String): String =
+        FluxaCoreUniFfi.coreInvokeValue("normalizeCloudstreamRepoUrl", urlArgs(rawUrl)).asString
 
-    fun normalizePluginRepositoryUrl(rawUrl: String): String = call {
-        normalizePluginRepositoryUrlNative(rawUrl)
-    }
+    fun normalizePluginRepositoryUrl(rawUrl: String): String =
+        FluxaCoreUniFfi.coreInvokeValue("normalizePluginRepositoryUrl", urlArgs(rawUrl)).asString
 
-    fun pluginIsSecureRemoteUrl(url: String): Boolean = call {
-        pluginIsSecureRemoteUrlNative(url)
-    }
+    fun pluginIsSecureRemoteUrl(url: String): Boolean =
+        FluxaCoreUniFfi.coreInvokeValue("isSecureRemoteUrl", urlArgs(url)).asBoolean
 
-    fun pluginSameRepositoryUrl(left: String, right: String): Boolean = call {
-        pluginSameRepositoryUrlNative(left, right)
-    }
+    fun pluginSameRepositoryUrl(left: String, right: String): Boolean =
+        FluxaCoreUniFfi.coreInvokeValue(
+            "samePluginRepositoryUrl",
+            JsonObject().apply {
+                addProperty("left", left)
+                addProperty("right", right)
+            }.toString()
+        ).asBoolean
 
-    fun extractAddonManifestUrl(detailText: String): String? = call {
-        extractAddonManifestUrlNative(detailText).takeIf { it.isNotBlank() }
+    fun extractAddonManifestUrl(detailText: String): String? {
+        val value = FluxaCoreUniFfi.coreInvokeValue(
+            "extractAddonManifestUrl",
+            JsonObject().apply { addProperty("text", detailText) }.toString()
+        )
+        return value.takeUnless { it.isJsonNull }?.asString?.takeIf { it.isNotBlank() }
     }
 
     fun addonStoreSearchPolicy(
@@ -675,54 +677,52 @@ object FluxaCoreNative {
         nowMillis: Long,
         cachedAtMillis: Long?,
         ttlMillis: Long
-    ): NativeAddonStoreSearchPolicy = call {
+    ): NativeAddonStoreSearchPolicy {
         val request = NativeAddonStoreSearchPolicyRequest(
             query = query,
             nowMillis = nowMillis,
             cachedAtMillis = cachedAtMillis,
             ttlMillis = ttlMillis
         )
-        gson.fromJson(
-            addonStoreSearchPolicyJsonNative(gson.toJson(request)),
-            NativeAddonStoreSearchPolicy::class.java
-        ) ?: NativeAddonStoreSearchPolicy()
+        val value = FluxaCoreUniFfi.coreInvokeValue("addonStoreSearchPolicy", gson.toJson(request))
+        return gson.fromJson(value, NativeAddonStoreSearchPolicy::class.java) ?: NativeAddonStoreSearchPolicy()
     }
 
     fun repositoryMetaDetailPlan(
         useConfiguredAddons: Boolean,
         authKey: String?,
         localAddons: List<String>?
-    ): NativeRepositoryMetaDetailPlan = call {
+    ): NativeRepositoryMetaDetailPlan {
         val request = NativeRepositoryMetaDetailPlanRequest(
             useConfiguredAddons = useConfiguredAddons,
             authKey = authKey.orEmpty(),
             localAddons = localAddons.orEmpty()
         )
-        gson.fromJson(
-            repositoryMetaDetailPlanJsonNative(gson.toJson(request)),
-            NativeRepositoryMetaDetailPlan::class.java
-        ) ?: NativeRepositoryMetaDetailPlan()
+        val value = FluxaCoreUniFfi.coreInvokeValue("repositoryMetaDetailPlan", gson.toJson(request))
+        return gson.fromJson(value, NativeRepositoryMetaDetailPlan::class.java) ?: NativeRepositoryMetaDetailPlan()
     }
 
-    fun repositorySeasonVideos(metaDetail: MetaDetail?, seasonNumber: Int): List<Video> = call {
-        val json = repositorySeasonVideosJsonNative(gson.toJson(metaDetail), seasonNumber)
-        gson.fromJson<List<Video>>(json, object : TypeToken<List<Video>>() {}.type) ?: emptyList()
+    fun repositorySeasonVideos(metaDetail: MetaDetail?, seasonNumber: Int): List<Video> {
+        val args = JsonObject().apply {
+            addProperty("metaDetailJson", gson.toJson(metaDetail))
+            addProperty("seasonNumber", seasonNumber)
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("repositorySeasonVideos", args.toString())
+        return gson.fromJson(value, object : TypeToken<List<Video>>() {}.type) ?: emptyList()
     }
 
     fun manifestFetchDecision(
         forceRefresh: Boolean,
         memoryHit: Boolean,
         persistentHit: Boolean
-    ): NativeManifestFetchDecision = call {
+    ): NativeManifestFetchDecision {
         val request = NativeManifestFetchDecisionRequest(
             forceRefresh = forceRefresh,
             memoryHit = memoryHit,
             persistentHit = persistentHit
         )
-        gson.fromJson(
-            manifestFetchDecisionJsonNative(gson.toJson(request)),
-            NativeManifestFetchDecision::class.java
-        ) ?: NativeManifestFetchDecision()
+        val value = FluxaCoreUniFfi.coreInvokeValue("manifestFetchDecision", gson.toJson(request))
+        return gson.fromJson(value, NativeManifestFetchDecision::class.java) ?: NativeManifestFetchDecision()
     }
 
     fun addonResourceRequestPlan(
@@ -732,7 +732,7 @@ object FluxaCoreNative {
         id: String,
         extraArgs: Map<String, String?> = emptyMap(),
         extraRaw: String = ""
-    ): NativeAddonResourceRequestPlan = call {
+    ): NativeAddonResourceRequestPlan {
         val request = NativeAddonResourceRequestPlanRequest(
             transportUrl = transportUrl,
             resource = resource,
@@ -741,14 +741,16 @@ object FluxaCoreNative {
             extraArgs = extraArgs,
             extraRaw = extraRaw
         )
-        gson.fromJson(
-            addonResourceRequestPlanJsonNative(gson.toJson(request)),
-            NativeAddonResourceRequestPlan::class.java
-        ) ?: NativeAddonResourceRequestPlan()
+        val value = FluxaCoreUniFfi.coreInvokeValue("addonResourceRequestPlan", gson.toJson(request))
+        return gson.fromJson(value, NativeAddonResourceRequestPlan::class.java) ?: NativeAddonResourceRequestPlan()
     }
 
-    fun addonStreamsWithProvider(streamsJson: String, addonName: String): String = call {
-        addonStreamsWithProviderJsonNative(streamsJson, addonName)
+    fun addonStreamsWithProvider(streamsJson: String, addonName: String): String {
+        val args = JsonObject().apply {
+            addProperty("streamsJson", streamsJson)
+            addProperty("addonName", addonName)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("addonStreamsWithProvider", args.toString()).toString()
     }
 
     fun buildResourceUrl(
@@ -757,14 +759,15 @@ object FluxaCoreNative {
         type: String,
         id: String,
         extraArgs: Map<String, String?>
-    ): String = call {
-        buildResourceUrlNative(
-            transportUrl,
-            resource,
-            type,
-            id,
-            gson.toJson(extraArgs.filterValues { !it.isNullOrBlank() })
-        )
+    ): String {
+        val args = JsonObject().apply {
+            addProperty("transportUrl", transportUrl)
+            addProperty("resource", resource)
+            addProperty("contentType", type)
+            addProperty("id", id)
+            addProperty("extraJson", gson.toJson(extraArgs.filterValues { !it.isNullOrBlank() }))
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("buildResourceUrl", args.toString()).asString
     }
 
     fun parseManifestJson(
@@ -772,30 +775,33 @@ object FluxaCoreNative {
         transportUrl: String,
         unknownName: String
     ): AddonDescriptor? {
-        val json = call {
-            parseManifestJsonNative(body, transportUrl, unknownName)
+        val args = JsonObject().apply {
+            addProperty("body", body)
+            addProperty("transportUrl", transportUrl)
+            addProperty("unknownName", unknownName)
         }
-        return json.takeIf { it.isNotBlank() }?.let { gson.fromJson(it, AddonDescriptor::class.java) }
+        val value = FluxaCoreUniFfi.coreInvokeValue("parseManifest", args.toString())
+        if (value.isJsonNull) return null
+        return gson.fromJson(value, AddonDescriptor::class.java)
     }
 
-    fun resolveManifestAssets(descriptor: AddonDescriptor): AddonDescriptor? = call {
-        resolveManifestAssetsJsonNative(gson.toJson(descriptor))
-            .takeIf { it.isNotBlank() }
-            ?.let { gson.fromJson(it, AddonDescriptor::class.java) }
+    fun resolveManifestAssets(descriptor: AddonDescriptor): AddonDescriptor? {
+        val value = FluxaCoreUniFfi.coreInvokeValue("resolveManifestAssets", gson.toJson(descriptor))
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson(it, AddonDescriptor::class.java) }
     }
 
     fun mergeLiveManifest(
         descriptor: AddonDescriptor,
         live: AddonDescriptor?,
         unknownName: String
-    ): AddonDescriptor? = call {
-        mergeLiveManifestJsonNative(
-            gson.toJson(descriptor),
-            live?.let(gson::toJson).orEmpty(),
-            unknownName
-        )
-            .takeIf { it.isNotBlank() }
-            ?.let { gson.fromJson(it, AddonDescriptor::class.java) }
+    ): AddonDescriptor? {
+        val args = JsonObject().apply {
+            addProperty("descriptor", gson.toJson(descriptor))
+            live?.let { addProperty("live", gson.toJson(it)) }
+            addProperty("unknownName", unknownName)
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("mergeLiveManifest", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson(it, AddonDescriptor::class.java) }
     }
 
     fun supportsResource(
@@ -803,30 +809,44 @@ object FluxaCoreNative {
         resourceName: String,
         type: String?,
         id: String?
-    ): Boolean = call {
-        supportsResourceNative(
-            gson.toJson(manifest),
-            resourceName,
-            type.orEmpty(),
-            id.orEmpty()
-        )
+    ): Boolean {
+        val args = JsonObject().apply {
+            addProperty("manifest", gson.toJson(manifest))
+            addProperty("resource", resourceName)
+            type?.takeIf { it.isNotEmpty() }?.let { addProperty("contentType", it) }
+            id?.takeIf { it.isNotEmpty() }?.let { addProperty("id", it) }
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("supportsResource", args.toString()).asBoolean
     }
 
-    fun catalogSupportsExtra(catalog: AddonCatalog, extraName: String): Boolean = call {
-        catalogSupportsExtraNative(gson.toJson(catalog), extraName)
+    fun catalogSupportsExtra(catalog: AddonCatalog, extraName: String): Boolean {
+        val args = JsonObject().apply {
+            addProperty("catalog", gson.toJson(catalog))
+            addProperty("extraName", extraName)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("catalogSupportsExtra", args.toString()).asBoolean
     }
 
-    fun catalogRequiresExtra(catalog: AddonCatalog, extraName: String): Boolean = call {
-        catalogRequiresExtraNative(gson.toJson(catalog), extraName)
+    fun catalogRequiresExtra(catalog: AddonCatalog, extraName: String): Boolean {
+        val args = JsonObject().apply {
+            addProperty("catalog", gson.toJson(catalog))
+            addProperty("extraName", extraName)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("catalogRequiresExtra", args.toString()).asBoolean
     }
 
-    fun catalogHasRequiredExtraExcept(catalog: AddonCatalog, allowedNames: Set<String>): Boolean = call {
-        catalogHasRequiredExtraExceptNative(gson.toJson(catalog), gson.toJson(allowedNames))
+    fun catalogHasRequiredExtraExcept(catalog: AddonCatalog, allowedNames: Set<String>): Boolean {
+        val args = JsonObject().apply {
+            addProperty("catalog", gson.toJson(catalog))
+            addProperty("allowedNames", gson.toJson(allowedNames))
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("catalogHasRequiredExtraExcept", args.toString()).asBoolean
     }
 
-    fun parseEpisodeLocator(raw: String?): NativeEpisodeLocator? = call {
-        val json = parseEpisodeLocatorJsonNative(raw.orEmpty()).orEmpty()
-        json.takeIf { it.isNotBlank() }?.let { gson.fromJson(it, NativeEpisodeLocator::class.java) }
+    fun parseEpisodeLocator(raw: String?): NativeEpisodeLocator? {
+        val args = JsonObject().apply { addProperty("input", raw.orEmpty()) }
+        val value = FluxaCoreUniFfi.coreInvokeValue("parseEpisodeLocator", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson(it, NativeEpisodeLocator::class.java) }
     }
 
     fun streamRequestIds(
@@ -835,74 +855,78 @@ object FluxaCoreNative {
         detailId: String?,
         currentSeriesLookupId: String?,
         canonicalBaseId: String?
-    ): List<String> = call {
-        val json = streamRequestIdsJsonNative(
-            type,
-            id,
-            detailId.orEmpty(),
-            currentSeriesLookupId.orEmpty(),
-            canonicalBaseId.orEmpty()
-        )
-        gson.fromJson<List<String>>(json, stringListType) ?: emptyList()
+    ): List<String> {
+        val args = JsonObject().apply {
+            addProperty("contentType", type)
+            addProperty("id", id)
+            detailId?.takeIf { it.isNotEmpty() }?.let { addProperty("detailId", it) }
+            currentSeriesLookupId?.takeIf { it.isNotEmpty() }?.let { addProperty("currentSeriesLookupId", it) }
+            canonicalBaseId?.takeIf { it.isNotEmpty() }?.let { addProperty("canonicalBaseId", it) }
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("streamRequestIds", args.toString())
+        return gson.fromJson(value, stringListType) ?: emptyList()
     }
 
-    fun playbackStreamRequestIds(type: String, id: String, detailId: String?): List<String> = call {
-        val json = playbackStreamRequestIdsJsonNative(type, id, detailId.orEmpty())
-        gson.fromJson<List<String>>(json, stringListType) ?: emptyList()
+    fun playbackStreamRequestIds(type: String, id: String, detailId: String?): List<String> {
+        val args = JsonObject().apply {
+            addProperty("contentType", type)
+            addProperty("id", id)
+            detailId?.takeIf { it.isNotEmpty() }?.let { addProperty("detailId", it) }
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("playbackStreamRequestIds", args.toString())
+        return gson.fromJson(value, stringListType) ?: emptyList()
     }
 
-    fun playbackIntroLookupContentId(id: String): String = call {
-        playbackIntroLookupContentIdNative(id)
+    fun playbackIntroLookupContentId(id: String): String {
+        val args = JsonObject().apply { addProperty("id", id) }
+        return FluxaCoreUniFfi.coreInvokeValue("playbackIntroLookupContentId", args.toString()).asString
     }
 
-    fun directPlaybackPlan(meta: Meta, detail: MetaDetail?, todayIso: String): NativeDirectPlaybackPlan = call {
-        val json = directPlaybackPlanJsonNative(
-            gson.toJson(meta),
-            detail?.let(gson::toJson).orEmpty(),
-            todayIso
-        )
-        gson.fromJson(json, NativeDirectPlaybackPlan::class.java)
+    fun directPlaybackPlan(meta: Meta, detail: MetaDetail?, todayIso: String): NativeDirectPlaybackPlan {
+        val args = JsonObject().apply {
+            addProperty("metaJson", gson.toJson(meta))
+            detail?.let { addProperty("detailJson", gson.toJson(it)) }
+            addProperty("todayIso", todayIso)
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("directPlaybackPlan", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson(it, NativeDirectPlaybackPlan::class.java) }
             ?: NativeDirectPlaybackPlan(meta = meta, lookupId = meta.id)
     }
 
     fun headlessProviderAvailability(
         addons: List<AddonDescriptor>,
         pluginNames: List<String>
-    ): NativeProviderAvailabilityPlan = call {
+    ): NativeProviderAvailabilityPlan {
         val request = NativeProviderAvailabilityPlanRequest(addons, pluginNames)
-        gson.fromJson(
-            headlessProviderAvailabilityPlanJsonNative(gson.toJson(request)),
-            NativeProviderAvailabilityPlan::class.java
-        ) ?: NativeProviderAvailabilityPlan()
+        val value = FluxaCoreUniFfi.coreInvokeValue("providerAvailabilityPlan", gson.toJson(request))
+        return gson.fromJson(value, NativeProviderAvailabilityPlan::class.java) ?: NativeProviderAvailabilityPlan()
     }
 
     fun headlessDetailStreamResult(
         attempts: List<Pair<String, List<Stream>>>,
         hasStreamProviders: Boolean
-    ): NativeDetailStreamResultPlan = call {
+    ): NativeDetailStreamResultPlan {
         val request = NativeDetailStreamResultPlanRequest(
             attempts = attempts.map { (requestId, streams) ->
                 NativeDetailStreamAttemptRequest(requestId, streams)
             },
             hasStreamProviders = hasStreamProviders
         )
-        gson.fromJson(
-            headlessDetailStreamResultPlanJsonNative(gson.toJson(request)),
-            NativeDetailStreamResultPlan::class.java
-        ) ?: NativeDetailStreamResultPlan(hasStreamProviders = hasStreamProviders)
+        val value = FluxaCoreUniFfi.coreInvokeValue("detailStreamResultPlan", gson.toJson(request))
+        return gson.fromJson(value, NativeDetailStreamResultPlan::class.java)
+            ?: NativeDetailStreamResultPlan(hasStreamProviders = hasStreamProviders)
     }
 
-    fun headlessPrefetchDetailStreams(streams: List<Stream>): NativePrefetchDetailStreamsPlan = call {
+    fun headlessPrefetchDetailStreams(streams: List<Stream>): NativePrefetchDetailStreamsPlan {
         val request = NativePrefetchDetailStreamsPlanRequest(streams)
-        gson.fromJson(
-            headlessPrefetchDetailStreamsPlanJsonNative(gson.toJson(request)),
-            NativePrefetchDetailStreamsPlan::class.java
-        ) ?: NativePrefetchDetailStreamsPlan(count = streams.size)
+        val value = FluxaCoreUniFfi.coreInvokeValue("prefetchDetailStreamsPlan", gson.toJson(request))
+        return gson.fromJson(value, NativePrefetchDetailStreamsPlan::class.java)
+            ?: NativePrefetchDetailStreamsPlan(count = streams.size)
     }
 
-    fun headlessDirectPlaybackPolicy(): NativeDirectPlaybackPolicy = call {
-        gson.fromJson(headlessDirectPlaybackPolicyJsonNative(), NativeDirectPlaybackPolicy::class.java)
-            ?: NativeDirectPlaybackPolicy()
+    fun headlessDirectPlaybackPolicy(): NativeDirectPlaybackPolicy {
+        val value = FluxaCoreUniFfi.coreInvokeValue("directPlaybackPolicy", "{}")
+        return gson.fromJson(value, NativeDirectPlaybackPolicy::class.java) ?: NativeDirectPlaybackPolicy()
     }
 
     fun streamDiscoveryEpisodeContext(
@@ -910,20 +934,21 @@ object FluxaCoreNative {
         requestId: String,
         detail: MetaDetail?,
         seasonEpisodes: List<Video>
-    ): NativeStreamDiscoveryEpisodeContext = call {
-        val json = streamDiscoveryEpisodeContextJsonNative(
-            type,
-            requestId,
-            detail?.let(gson::toJson).orEmpty(),
-            gson.toJson(seasonEpisodes)
-        )
-        gson.fromJson(json, NativeStreamDiscoveryEpisodeContext::class.java)
+    ): NativeStreamDiscoveryEpisodeContext {
+        val args = JsonObject().apply {
+            addProperty("contentType", type)
+            addProperty("requestId", requestId)
+            detail?.let { addProperty("detailJson", gson.toJson(it)) }
+            addProperty("seasonEpisodesJson", gson.toJson(seasonEpisodes))
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("streamDiscoveryEpisodeContext", args.toString())
+        return gson.fromJson(value, NativeStreamDiscoveryEpisodeContext::class.java)
             ?: NativeStreamDiscoveryEpisodeContext()
     }
 
-    fun streamPlaybackInfo(stream: Stream): NativeStreamPlaybackInfo = call {
-        val json = streamPlaybackInfoJsonNative(gson.toJson(stream))
-        gson.fromJson(json, NativeStreamPlaybackInfo::class.java) ?: NativeStreamPlaybackInfo()
+    fun streamPlaybackInfo(stream: Stream): NativeStreamPlaybackInfo {
+        val value = FluxaCoreUniFfi.coreInvokeValue("streamPlaybackInfo", gson.toJson(stream))
+        return gson.fromJson(value, NativeStreamPlaybackInfo::class.java) ?: NativeStreamPlaybackInfo()
     }
 
     fun dvProxyPlan(
@@ -932,7 +957,7 @@ object FluxaCoreNative {
         fallbackMode: String,
         deviceHasDvDecoder: Boolean,
         deviceHasDvDisplay: Boolean
-    ): NativeDvProxyPlan = call {
+    ): NativeDvProxyPlan {
         val requestJson = gson.toJson(mapOf(
             "stream" to gson.fromJson(streamJson, Any::class.java),
             "url" to url,
@@ -940,37 +965,47 @@ object FluxaCoreNative {
             "deviceHasDvDecoder" to deviceHasDvDecoder,
             "deviceHasDvDisplay" to deviceHasDvDisplay
         ))
-        gson.fromJson(dvProxyPlanJsonNative(requestJson), NativeDvProxyPlan::class.java)
-            ?: NativeDvProxyPlan()
+        val value = FluxaCoreUniFfi.coreInvokeValue("dvProxyPlan", requestJson)
+        return gson.fromJson(value, NativeDvProxyPlan::class.java) ?: NativeDvProxyPlan()
     }
 
-    fun dolbyVisionRpuInfo(rpuBase64: String): NativeDolbyVisionRpuInfo = call {
-        val json = dolbyVisionRpuInfoJsonNative(gson.toJson(mapOf("rpu_base64" to rpuBase64)))
-        gson.fromJson(json, JsonObject::class.java)?.toDolbyVisionRpuInfo() ?: NativeDolbyVisionRpuInfo()
+    fun dolbyVisionRpuInfo(rpuBase64: String): NativeDolbyVisionRpuInfo {
+        val value = FluxaCoreUniFfi.coreInvokeValue("dolbyVisionRpuInfo", gson.toJson(mapOf("rpu_base64" to rpuBase64)))
+        return value.takeUnless { it.isJsonNull }?.asJsonObject?.toDolbyVisionRpuInfo() ?: NativeDolbyVisionRpuInfo()
     }
 
-    fun dolbyVisionConvertRpu(rpuBase64: String, mode: Int = 2): NativeDolbyVisionRpuConvertResult = call {
-        val json = dolbyVisionConvertRpuJsonNative(gson.toJson(mapOf("rpu_base64" to rpuBase64, "mode" to mode)))
-        gson.fromJson(json, JsonObject::class.java)?.toDolbyVisionRpuConvertResult()
+    fun dolbyVisionConvertRpu(rpuBase64: String, mode: Int = 2): NativeDolbyVisionRpuConvertResult {
+        val value = FluxaCoreUniFfi.coreInvokeValue(
+            "dolbyVisionConvertRpu",
+            gson.toJson(mapOf("rpu_base64" to rpuBase64, "mode" to mode))
+        )
+        return value.takeUnless { it.isJsonNull }?.asJsonObject?.toDolbyVisionRpuConvertResult()
             ?: NativeDolbyVisionRpuConvertResult()
     }
 
-    fun streamRequestHeaders(streamHeaders: Map<String, String>): Map<String, String> = call {
-        val json = streamRequestHeadersJsonNative(gson.toJson(streamHeaders))
-        gson.fromJson<Map<String, String>>(json, object : TypeToken<Map<String, String>>() {}.type) ?: emptyMap()
+    fun streamRequestHeaders(streamHeaders: Map<String, String>): Map<String, String> {
+        val args = JsonObject().apply { addProperty("headersJson", gson.toJson(streamHeaders)) }
+        val value = FluxaCoreUniFfi.coreInvokeValue("streamRequestHeaders", args.toString())
+        return gson.fromJson(value, object : TypeToken<Map<String, String>>() {}.type) ?: emptyMap()
     }
 
-    fun streamRequestReferer(url: String): String? = call {
-        streamRequestRefererNative(url).takeIf { it.isNotBlank() }
+    fun streamRequestReferer(url: String): String? {
+        val value = FluxaCoreUniFfi.coreInvokeValue("streamRequestReferer", urlArgs(url))
+        return value.takeUnless { it.isJsonNull }?.asString?.takeIf { it.isNotBlank() }
     }
 
-    fun isTorrentPlaybackUrl(url: String?): Boolean = call {
+    fun isTorrentPlaybackUrl(url: String?): Boolean {
         val stream = Stream(name = null, title = null, url = url)
-        streamPlaybackInfo(stream).isTorrentPlaybackUrl
+        return streamPlaybackInfo(stream).isTorrentPlaybackUrl
     }
 
-    fun episodeTextMatches(text: String?, season: Int, episode: Int): Boolean = call {
-        episodeTextMatchesNative(text.orEmpty(), season, episode)
+    fun episodeTextMatches(text: String?, season: Int, episode: Int): Boolean {
+        val args = JsonObject().apply {
+            addProperty("text", text.orEmpty())
+            addProperty("season", season)
+            addProperty("episode", episode)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("episodeTextMatches", args.toString()).asBoolean
     }
 
     fun streamMatchesEpisode(
@@ -980,15 +1015,16 @@ object FluxaCoreNative {
         description: String?,
         filename: String?,
         effectiveFilename: String?
-    ): Boolean = call {
-        streamMatchesEpisodeNative(
-            videoId.orEmpty(),
-            title.orEmpty(),
-            name.orEmpty(),
-            description.orEmpty(),
-            filename.orEmpty(),
-            effectiveFilename.orEmpty()
-        )
+    ): Boolean {
+        val args = JsonObject().apply {
+            addProperty("videoId", videoId.orEmpty())
+            addProperty("title", title.orEmpty())
+            addProperty("name", name.orEmpty())
+            addProperty("description", description.orEmpty())
+            addProperty("filename", filename.orEmpty())
+            addProperty("effectiveFilename", effectiveFilename.orEmpty())
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("streamMatchesEpisode", args.toString()).asBoolean
     }
 
     fun selectStreamIndex(
@@ -1000,7 +1036,7 @@ object FluxaCoreNative {
         sourceSelectionMode: String,
         regexPattern: String?,
         preferredBingeGroup: String?
-    ): Int = call {
+    ): Int {
         val nativeStreams = streams.map { stream ->
             NativeStreamSelectionItem(
                 name = stream.name,
@@ -1013,21 +1049,23 @@ object FluxaCoreNative {
                 effectiveFilename = stream.effectiveFilename
             )
         }
-        selectStreamIndexNative(
-            gson.toJson(nativeStreams),
-            currentVideoId.orEmpty(),
-            initialStreamIndex,
-            savedUrl.orEmpty(),
-            savedTitle.orEmpty(),
-            sourceSelectionMode,
-            regexPattern.orEmpty(),
-            preferredBingeGroup.orEmpty()
-        )
+        val args = JsonObject().apply {
+            addProperty("streamsJson", gson.toJson(nativeStreams))
+            addProperty("currentVideoId", currentVideoId.orEmpty())
+            addProperty("initialStreamIndex", initialStreamIndex)
+            savedUrl?.takeIf { it.isNotEmpty() }?.let { addProperty("savedUrl", it) }
+            savedTitle?.takeIf { it.isNotEmpty() }?.let { addProperty("savedTitle", it) }
+            addProperty("sourceSelectionMode", sourceSelectionMode)
+            regexPattern?.takeIf { it.isNotEmpty() }?.let { addProperty("regexPattern", it) }
+            preferredBingeGroup?.takeIf { it.isNotEmpty() }?.let { addProperty("preferredBingeGroup", it) }
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("selectStreamIndex", args.toString()).asInt
     }
 
-    fun mergeContinueWatchingDuplicates(items: List<Meta>): List<Meta> = call {
-        val json = mergeContinueWatchingDuplicatesJsonNative(gson.toJson(items))
-        gson.fromJson<List<Meta>>(json, metaListType) ?: emptyList()
+    fun mergeContinueWatchingDuplicates(items: List<Meta>): List<Meta> {
+        val args = JsonObject().apply { addProperty("itemsJson", gson.toJson(items)) }
+        val value = FluxaCoreUniFfi.coreInvokeValue("mergeContinueWatchingDuplicates", args.toString())
+        return gson.fromJson(value, metaListType) ?: emptyList()
     }
 
     fun filterDiscoverResults(
@@ -1035,31 +1073,37 @@ object FluxaCoreNative {
         year: String?,
         rating: Float?,
         region: String?
-    ): List<Meta> = call {
-        val json = filterDiscoverResultsJsonNative(
-            gson.toJson(items),
-            year.orEmpty(),
-            rating ?: 0f,
-            rating != null,
-            region.orEmpty()
-        )
-        gson.fromJson<List<Meta>>(json, metaListType) ?: emptyList()
+    ): List<Meta> {
+        val args = JsonObject().apply {
+            addProperty("itemsJson", gson.toJson(items))
+            year?.takeIf { it.isNotBlank() }?.let { addProperty("year", it) }
+            rating?.let { addProperty("rating", it) }
+            region?.takeIf { it.isNotBlank() }?.let { addProperty("region", it) }
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("filterDiscoverResults", args.toString())
+        return gson.fromJson(value, metaListType) ?: emptyList()
     }
 
     fun resolvePreferredAudioLanguage(
         lastAudioLanguage: String?,
         preferredAudioLanguage: String?,
         originalLanguage: String?
-    ): String = call {
-        resolvePreferredAudioLanguageNative(
-            lastAudioLanguage.orEmpty(),
-            preferredAudioLanguage.orEmpty(),
-            originalLanguage.orEmpty()
-        )
+    ): String {
+        val args = JsonObject().apply {
+            lastAudioLanguage?.let { addProperty("lastAudioLanguage", it) }
+            preferredAudioLanguage?.let { addProperty("preferredAudioLanguage", it) }
+            originalLanguage?.let { addProperty("originalLanguage", it) }
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("resolvePreferredAudioLanguage", args.toString()).asString
     }
 
-    fun subtitleLanguageMatches(label: String, language: String?, preferredLanguage: String): Boolean = call {
-        subtitleLanguageMatchesNative(label, language.orEmpty(), preferredLanguage)
+    fun subtitleLanguageMatches(label: String, language: String?, preferredLanguage: String): Boolean {
+        val args = JsonObject().apply {
+            addProperty("label", label)
+            language?.let { addProperty("language", it) }
+            addProperty("preferredLanguage", preferredLanguage)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("subtitleLanguageMatches", args.toString()).asBoolean
     }
 
     fun playerTrackState(
@@ -1070,7 +1114,7 @@ object FluxaCoreNative {
         lastSubtitleLanguage: String?,
         preferredSubtitleLanguage: String?,
         secondarySubtitleLanguage: String?
-    ): NativePlayerTrackState = call {
+    ): NativePlayerTrackState {
         val request = NativePlayerTrackStateRequest(
             availableSubtitles = availableSubtitles.map { NativeSubtitleTrackEntry(it.id, it.label, it.language) },
             lastAudioLanguage = lastAudioLanguage,
@@ -1080,7 +1124,8 @@ object FluxaCoreNative {
             preferredSubtitleLanguage = preferredSubtitleLanguage,
             secondarySubtitleLanguage = secondarySubtitleLanguage
         )
-        gson.fromJson(playerTrackStateJsonNative(gson.toJson(request)), NativePlayerTrackState::class.java)
+        val value = FluxaCoreUniFfi.coreInvokeValue("playerTrackState", gson.toJson(request))
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson(it, NativePlayerTrackState::class.java) }
             ?: NativePlayerTrackState()
     }
 
@@ -1089,9 +1134,15 @@ object FluxaCoreNative {
         url: String,
         statusCode: Int,
         body: String?
-    ): NativeAddonResourceParseResult = call {
-        val json = parseAddonResourceResultJsonNative(resource, url, statusCode, body.orEmpty())
-        gson.fromJson(json, NativeAddonResourceParseResult::class.java) ?: NativeAddonResourceParseResult(
+    ): NativeAddonResourceParseResult {
+        val args = JsonObject().apply {
+            addProperty("resource", resource)
+            addProperty("url", url)
+            addProperty("statusCode", statusCode)
+            body?.let { addProperty("body", it) }
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("parseAddonResourceResult", args.toString())
+        return gson.fromJson(value, NativeAddonResourceParseResult::class.java) ?: NativeAddonResourceParseResult(
             kind = "parse_error",
             url = url,
             statusCode = statusCode,
@@ -1099,8 +1150,33 @@ object FluxaCoreNative {
         )
     }
 
-    fun normalizeAddonSubtitles(subtitlesJson: String, resourceUrl: String): String = call {
-        normalizeAddonSubtitlesJsonNative(subtitlesJson, resourceUrl)
+    fun parseAddonStreamResult(
+        url: String,
+        statusCode: Int,
+        body: String?,
+        addonName: String
+    ): NativeAddonResourceParseResult {
+        val args = JsonObject().apply {
+            addProperty("url", url)
+            addProperty("statusCode", statusCode)
+            body?.let { addProperty("body", it) }
+            addProperty("addonName", addonName)
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("parseAddonStreamResult", args.toString())
+        return gson.fromJson(value, NativeAddonResourceParseResult::class.java) ?: NativeAddonResourceParseResult(
+            kind = "parse_error",
+            url = url,
+            statusCode = statusCode,
+            error = "empty native response"
+        )
+    }
+
+    fun normalizeAddonSubtitles(subtitlesJson: String, resourceUrl: String): String {
+        val args = JsonObject().apply {
+            addProperty("subtitles", subtitlesJson)
+            addProperty("resourceUrl", resourceUrl)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("normalizeAddonSubtitles", args.toString()).toString()
     }
 
     fun torrentRuntimeInfo(
@@ -1114,7 +1190,7 @@ object FluxaCoreNative {
         baseUrl: String,
         play: Boolean,
         stat: Boolean
-    ): NativeTorrentRuntimeInfo = call {
+    ): NativeTorrentRuntimeInfo {
         val request = NativeTorrentRuntimeRequest(
             link = link,
             title = title,
@@ -1127,41 +1203,55 @@ object FluxaCoreNative {
             play = play,
             stat = stat
         )
-        val json = torrentRuntimeInfoJsonNative(gson.toJson(request))
-        gson.fromJson(json, NativeTorrentRuntimeInfo::class.java) ?: NativeTorrentRuntimeInfo()
+        val value = FluxaCoreUniFfi.coreInvokeValue("torrentRuntimeInfo", gson.toJson(request))
+        return gson.fromJson(value, NativeTorrentRuntimeInfo::class.java) ?: NativeTorrentRuntimeInfo()
     }
 
-    fun torrentStatusInfo(status: TorrentStatus): NativeTorrentStatusInfo = call {
-        val json = torrentStatusInfoJsonNative(gson.toJson(status))
-        gson.fromJson(json, NativeTorrentStatusInfo::class.java) ?: NativeTorrentStatusInfo()
+    fun torrentStatusInfo(status: TorrentStatus): NativeTorrentStatusInfo {
+        val value = FluxaCoreUniFfi.coreInvokeValue("torrentStatusInfo", gson.toJson(status))
+        return gson.fromJson(value, NativeTorrentStatusInfo::class.java) ?: NativeTorrentStatusInfo()
     }
 
-    fun stableFeedPart(value: String): String = call {
-        stableFeedPartNative(value)
+    fun stableFeedPart(value: String): String {
+        val args = JsonObject().apply { addProperty("value", value) }
+        return FluxaCoreUniFfi.coreInvokeValue("stableFeedPart", args.toString()).asString
     }
 
-    fun normalizeContentType(value: String): String? = call {
-        normalizeContentTypeNative(value).takeIf { it.isNotBlank() }
+    fun normalizeContentType(value: String): String? {
+        val args = JsonObject().apply { addProperty("value", value) }
+        val result = FluxaCoreUniFfi.coreInvokeValue("normalizeContentType", args.toString())
+        return result.takeUnless { it.isJsonNull }?.asString?.takeIf { it.isNotBlank() }
     }
 
-    fun parseExtraArgs(extra: String): Map<String, String> = call {
-        val json = parseExtraArgsJsonNative(extra)
-        gson.fromJson<Map<String, String>>(json, object : TypeToken<Map<String, String>>() {}.type) ?: emptyMap()
+    fun parseExtraArgs(extra: String): Map<String, String> {
+        val args = JsonObject().apply { addProperty("extra", extra) }
+        val value = FluxaCoreUniFfi.coreInvokeValue("parseExtraArgs", args.toString())
+        return gson.fromJson(value, object : TypeToken<Map<String, String>>() {}.type) ?: emptyMap()
     }
 
-    fun providerSearchTerms(provider: String): List<String> = call {
-        val json = providerSearchTermsJsonNative(provider)
-        gson.fromJson<List<String>>(json, stringListType) ?: emptyList()
+    fun providerSearchTerms(provider: String): List<String> {
+        val args = JsonObject().apply { addProperty("provider", provider) }
+        val value = FluxaCoreUniFfi.coreInvokeValue("providerSearchTerms", args.toString())
+        return gson.fromJson(value, stringListType) ?: emptyList()
     }
 
-    fun effectiveMetadataFeedSelection(selectedKeys: List<String>?, availableKeys: List<String>): List<String>? = call {
-        val json = effectiveMetadataFeedSelectionJsonNative(gson.toJson(selectedKeys), gson.toJson(availableKeys))
-        json?.takeIf { it.isNotBlank() }?.let { gson.fromJson<List<String>>(it, stringListType) }
+    fun effectiveMetadataFeedSelection(selectedKeys: List<String>?, availableKeys: List<String>): List<String>? {
+        val args = JsonObject().apply {
+            addProperty("selectedKeys", gson.toJson(selectedKeys))
+            addProperty("availableKeys", gson.toJson(availableKeys))
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("effectiveMetadataFeedSelection", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson<List<String>>(it, stringListType) }
     }
 
-    fun toggleMetadataFeed(selectedKeys: List<String>?, availableKeys: List<String>, key: String): List<String> = call {
-        val json = toggleMetadataFeedJsonNative(gson.toJson(selectedKeys), gson.toJson(availableKeys), key)
-        gson.fromJson<List<String>>(json, stringListType) ?: emptyList()
+    fun toggleMetadataFeed(selectedKeys: List<String>?, availableKeys: List<String>, key: String): List<String> {
+        val args = JsonObject().apply {
+            addProperty("selectedKeys", gson.toJson(selectedKeys))
+            addProperty("availableKeys", gson.toJson(availableKeys))
+            addProperty("key", key)
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("toggleMetadataFeed", args.toString())
+        return gson.fromJson(value, stringListType) ?: emptyList()
     }
 
     fun toggleMetadataFeed(
@@ -1169,14 +1259,15 @@ object FluxaCoreNative {
         availableKeys: List<String>,
         key: String,
         maxEnabled: Int
-    ): List<String> = call {
-        val json = toggleMetadataFeedLimitedJsonNative(
-            gson.toJson(selectedKeys),
-            gson.toJson(availableKeys),
-            key,
-            maxEnabled
-        )
-        gson.fromJson<List<String>>(json, stringListType) ?: emptyList()
+    ): List<String> {
+        val args = JsonObject().apply {
+            addProperty("selectedKeys", gson.toJson(selectedKeys))
+            addProperty("availableKeys", gson.toJson(availableKeys))
+            addProperty("key", key)
+            addProperty("maxEnabled", maxEnabled)
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("toggleMetadataFeedLimited", args.toString())
+        return gson.fromJson(value, stringListType) ?: emptyList()
     }
 
     fun setMetadataFeedGroupEnabled(
@@ -1184,51 +1275,66 @@ object FluxaCoreNative {
         availableKeys: List<String>,
         groupKeys: List<String>,
         enabled: Boolean
-    ): List<String> = call {
-        val json = setMetadataFeedGroupEnabledJsonNative(
-            gson.toJson(selectedKeys),
-            gson.toJson(availableKeys),
-            gson.toJson(groupKeys),
-            enabled
-        )
-        gson.fromJson<List<String>>(json, stringListType) ?: emptyList()
-    }
-
-    fun orderedMetadataFeedKeys(optionKeys: List<String>, order: List<String>?): List<String> = call {
-        val json = orderedMetadataFeedKeysJsonNative(gson.toJson(optionKeys), gson.toJson(order))
-        gson.fromJson<List<String>>(json, stringListType) ?: optionKeys
-    }
-
-    fun moveMetadataFeedOrder(optionKeys: List<String>, currentOrder: List<String>?, key: String, delta: Int): List<String> = call {
-        val json = moveMetadataFeedOrderJsonNative(gson.toJson(optionKeys), gson.toJson(currentOrder), key, delta)
-        gson.fromJson<List<String>>(json, stringListType) ?: optionKeys
-    }
-
-    fun contentTraktKey(meta: Meta): String = call {
-        contentTraktKeysBatchJsonNative(gson.toJson(listOf(meta))).let { json ->
-            (gson.fromJson<List<String>>(json, stringListType) ?: emptyList()).first()
+    ): List<String> {
+        val args = JsonObject().apply {
+            addProperty("selectedKeys", gson.toJson(selectedKeys))
+            addProperty("availableKeys", gson.toJson(availableKeys))
+            addProperty("groupKeys", gson.toJson(groupKeys))
+            addProperty("enabled", enabled)
         }
+        val value = FluxaCoreUniFfi.coreInvokeValue("setMetadataFeedGroupEnabled", args.toString())
+        return gson.fromJson(value, stringListType) ?: emptyList()
     }
 
-    fun contentTraktKeysBatch(metas: List<Meta>): List<String> = call {
-        if (metas.isEmpty()) return@call emptyList()
-        val json = contentTraktKeysBatchJsonNative(gson.toJson(metas))
-        gson.fromJson<List<String>>(json, stringListType) ?: emptyList()
+    fun orderedMetadataFeedKeys(optionKeys: List<String>, order: List<String>?): List<String> {
+        val args = JsonObject().apply {
+            addProperty("optionKeys", gson.toJson(optionKeys))
+            addProperty("order", gson.toJson(order))
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("orderedMetadataFeedKeys", args.toString())
+        return gson.fromJson(value, stringListType) ?: optionKeys
     }
 
-    fun contentMergeKeys(meta: Meta): Set<String> = call {
-        val json = contentMergeKeysJsonNative(gson.toJson(meta))
-        (gson.fromJson<List<String>>(json, stringListType) ?: emptyList()).toSet()
+    fun moveMetadataFeedOrder(optionKeys: List<String>, currentOrder: List<String>?, key: String, delta: Int): List<String> {
+        val args = JsonObject().apply {
+            addProperty("optionKeys", gson.toJson(optionKeys))
+            addProperty("currentOrder", gson.toJson(currentOrder))
+            addProperty("key", key)
+            addProperty("delta", delta)
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("moveMetadataFeedOrder", args.toString())
+        return gson.fromJson(value, stringListType) ?: optionKeys
     }
 
-    fun contentWatchedKeysBatch(metas: List<Meta>): List<Set<String>> = call {
-        if (metas.isEmpty()) return@call emptyList()
-        val json = contentWatchedKeysBatchJsonNative(gson.toJson(metas))
-        (gson.fromJson<List<List<String>>>(json, stringListListType) ?: emptyList()).map { it.toSet() }
+    fun contentTraktKey(meta: Meta): String = contentTraktKeysBatch(listOf(meta)).first()
+
+    fun contentTraktKeysBatch(metas: List<Meta>): List<String> {
+        if (metas.isEmpty()) return emptyList()
+        val args = JsonObject().apply { addProperty("metasJson", gson.toJson(metas)) }
+        val value = FluxaCoreUniFfi.coreInvokeValue("contentTraktKeysBatch", args.toString())
+        return gson.fromJson(value, stringListType) ?: emptyList()
     }
 
-    fun episodeFilenameCandidate(stream: Stream, videoId: String?): String? = call {
-        episodeFilenameCandidateNative(gson.toJson(stream), videoId.orEmpty()).takeIf { it.isNotBlank() }
+    fun contentMergeKeys(meta: Meta): Set<String> {
+        val args = JsonObject().apply { addProperty("metaJson", gson.toJson(meta)) }
+        val value = FluxaCoreUniFfi.coreInvokeValue("contentMergeKeys", args.toString())
+        return (gson.fromJson<List<String>>(value, stringListType) ?: emptyList()).toSet()
+    }
+
+    fun contentWatchedKeysBatch(metas: List<Meta>): List<Set<String>> {
+        if (metas.isEmpty()) return emptyList()
+        val args = JsonObject().apply { addProperty("metasJson", gson.toJson(metas)) }
+        val value = FluxaCoreUniFfi.coreInvokeValue("contentWatchedKeysBatch", args.toString())
+        return (gson.fromJson<List<List<String>>>(value, stringListListType) ?: emptyList()).map { it.toSet() }
+    }
+
+    fun episodeFilenameCandidate(stream: Stream, videoId: String?): String? {
+        val args = JsonObject().apply {
+            addProperty("streamJson", gson.toJson(stream))
+            addProperty("videoId", videoId.orEmpty())
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("episodeFilenameCandidate", args.toString())
+        return value.takeUnless { it.isJsonNull }?.asString?.takeIf { it.isNotBlank() }
     }
 
     fun streamDiscoveryCacheKey(
@@ -1240,21 +1346,18 @@ object FluxaCoreNative {
         cs3OriginalName: String?,
         addonSignatures: List<String>,
         cs3PluginNames: List<String>
-    ): String = call {
-        streamDiscoveryCacheKeyNative(
-            gson.toJson(
-                NativeStreamDiscoveryCacheKeyRequest(
-                    type = type,
-                    id = id,
-                    language = language,
-                    cs3SearchQuery = cs3SearchQuery,
-                    cs3Year = cs3Year,
-                    cs3OriginalName = cs3OriginalName,
-                    addonSignatures = addonSignatures,
-                    cs3PluginNames = cs3PluginNames
-                )
-            )
+    ): String {
+        val request = NativeStreamDiscoveryCacheKeyRequest(
+            type = type,
+            id = id,
+            language = language,
+            cs3SearchQuery = cs3SearchQuery,
+            cs3Year = cs3Year,
+            cs3OriginalName = cs3OriginalName,
+            addonSignatures = addonSignatures,
+            cs3PluginNames = cs3PluginNames
         )
+        return FluxaCoreUniFfi.coreInvokeValue("streamDiscoveryCacheKey", gson.toJson(request)).asString
     }
 
     fun streamDiscoveryPlan(
@@ -1270,7 +1373,7 @@ object FluxaCoreNative {
         cs3SearchQuery: String?,
         cs3OriginalName: String?,
         cs3Year: Int?
-    ): NativeStreamDiscoveryPlan = call {
+    ): NativeStreamDiscoveryPlan {
         val request = NativeStreamDiscoveryPlanRequest(
             type = type,
             id = id,
@@ -1285,9 +1388,8 @@ object FluxaCoreNative {
             cs3OriginalName = cs3OriginalName,
             cs3Year = cs3Year
         )
-        streamDiscoveryPlanJsonNative(gson.toJson(request))
-            ?.takeIf { it.isNotBlank() }
-            ?.let { gson.fromJson(it, NativeStreamDiscoveryPlan::class.java) }
+        val value = FluxaCoreUniFfi.coreInvokeValue("streamDiscoveryPlan", gson.toJson(request))
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson(it, NativeStreamDiscoveryPlan::class.java) }
             ?: NativeStreamDiscoveryPlan()
     }
 
@@ -1304,7 +1406,7 @@ object FluxaCoreNative {
         cs3SearchQuery: String?,
         cs3OriginalName: String?,
         cs3Year: Int?
-    ): NativeStreamDiscoveryExecutionPolicy = call {
+    ): NativeStreamDiscoveryExecutionPolicy {
         val request = NativeStreamDiscoveryPlanRequest(
             type = type,
             id = id,
@@ -1319,14 +1421,19 @@ object FluxaCoreNative {
             cs3OriginalName = cs3OriginalName,
             cs3Year = cs3Year
         )
-        streamDiscoveryExecutionPolicyJsonNative(gson.toJson(request))
-            ?.takeIf { it.isNotBlank() }
+        val value = FluxaCoreUniFfi.coreInvokeValue("streamDiscoveryExecutionPolicy", gson.toJson(request))
+        return value.takeUnless { it.isJsonNull }
             ?.let { gson.fromJson(it, NativeStreamDiscoveryExecutionPolicy::class.java) }
             ?: NativeStreamDiscoveryExecutionPolicy()
     }
 
-    fun streamDiscoveryCachePrefix(type: String, id: String, language: String): String = call {
-        streamDiscoveryCachePrefixNative(type, id, language)
+    fun streamDiscoveryCachePrefix(type: String, id: String, language: String): String {
+        val args = JsonObject().apply {
+            addProperty("contentType", type)
+            addProperty("id", id)
+            addProperty("language", language)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("streamDiscoveryCachePrefix", args.toString()).asString
     }
 
     fun discoverCatalogCacheKey(
@@ -1338,29 +1445,31 @@ object FluxaCoreNative {
         provider: String?,
         region: String?,
         catalogSignatures: List<String>
-    ): String = call {
-        discoverCatalogCacheKeyNative(
-            gson.toJson(
-                NativeDiscoverCatalogCacheKeyRequest(
-                    type = type,
-                    catalogKey = catalogKey,
-                    genre = genre,
-                    year = year,
-                    rating = rating,
-                    provider = provider,
-                    region = region,
-                    catalogSignatures = catalogSignatures
-                )
-            )
+    ): String {
+        val request = NativeDiscoverCatalogCacheKeyRequest(
+            type = type,
+            catalogKey = catalogKey,
+            genre = genre,
+            year = year,
+            rating = rating,
+            provider = provider,
+            region = region,
+            catalogSignatures = catalogSignatures
         )
+        return FluxaCoreUniFfi.coreInvokeValue("discoverCatalogCacheKey", gson.toJson(request)).asString
     }
 
-    fun curateHomeItemsJson(categoryJson: String): String = call {
-        curateHomeItemsJsonNative(categoryJson)
+    fun curateHomeItemsJson(categoryJson: String): String {
+        val args = JsonObject().apply { addProperty("categoryJson", categoryJson) }
+        return FluxaCoreUniFfi.coreInvokeValue("curateHomeItems", args.toString()).toString()
     }
 
-    fun homeOverlapRatioJson(firstCategoryJson: String, secondCategoryJson: String): Float = call {
-        homeOverlapRatioNative(firstCategoryJson, secondCategoryJson)
+    fun homeOverlapRatioJson(firstCategoryJson: String, secondCategoryJson: String): Float {
+        val args = JsonObject().apply {
+            addProperty("firstJson", firstCategoryJson)
+            addProperty("secondJson", secondCategoryJson)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("homeOverlapRatio", args.toString()).asFloat
     }
 
     fun homePersonalizationScoreJson(
@@ -1368,13 +1477,14 @@ object FluxaCoreNative {
         preferredGenresJson: String,
         preferredTypesJson: String,
         priorityLabelsJson: String
-    ): Int = call {
-        homePersonalizationScoreNative(
-            categoryJson,
-            preferredGenresJson,
-            preferredTypesJson,
-            priorityLabelsJson
-        )
+    ): Int {
+        val args = JsonObject().apply {
+            addProperty("categoryJson", categoryJson)
+            addProperty("preferredGenresJson", preferredGenresJson)
+            addProperty("preferredTypesJson", preferredTypesJson)
+            addProperty("priorityLabelsJson", priorityLabelsJson)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("homePersonalizationScore", args.toString()).asInt
     }
 
     fun prioritizeHomeRowsJson(
@@ -1383,38 +1493,47 @@ object FluxaCoreNative {
         preferredGenresJson: String,
         preferredTypesJson: String,
         priorityLabelsJson: String
-    ): String = call {
-        prioritizeHomeRowsJsonNative(
-            categoriesJson,
-            preferredOrderLabelsJson,
-            preferredGenresJson,
-            preferredTypesJson,
-            priorityLabelsJson
-        )
+    ): String {
+        val args = JsonObject().apply {
+            addProperty("categoriesJson", categoriesJson)
+            addProperty("preferredOrderLabelsJson", preferredOrderLabelsJson)
+            addProperty("preferredGenresJson", preferredGenresJson)
+            addProperty("preferredTypesJson", preferredTypesJson)
+            addProperty("priorityLabelsJson", priorityLabelsJson)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("prioritizeHomeRows", args.toString()).toString()
     }
 
-    fun optimizeHomeRowsJson(requestJson: String): String = call {
-        optimizeHomeRowsJsonNative(requestJson)
+    fun optimizeHomeRowsJson(requestJson: String): String =
+        FluxaCoreUniFfi.coreInvokeValue("optimizeHomeRows", requestJson).toString()
+
+    fun buildBillboardPool(enriched: List<Meta>, candidates: List<Meta>): List<Meta> {
+        val args = JsonObject().apply {
+            addProperty("enrichedJson", gson.toJson(enriched))
+            addProperty("candidatesJson", gson.toJson(candidates))
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("buildBillboardPool", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson<List<Meta>>(it, metaListType) } ?: emptyList()
     }
 
-    fun buildBillboardPool(enriched: List<Meta>, candidates: List<Meta>): List<Meta> = call {
-        val json = buildBillboardPoolJsonNative(gson.toJson(enriched), gson.toJson(candidates))
-        if (json != null) gson.fromJson<List<Meta>>(json, metaListType) ?: emptyList() else emptyList()
-    }
-
-    fun normalizeHomeCatalogItems(items: List<Meta>, catalogId: String, genre: String?): List<Meta> = call {
+    fun normalizeHomeCatalogItems(items: List<Meta>, catalogId: String, genre: String?): List<Meta> {
         val todayIso = java.time.LocalDate.now(java.time.ZoneId.systemDefault()).toString()
-        val json = normalizeHomeCatalogItemsJsonNative(
-            gson.toJson(items),
-            catalogId,
-            genre.orEmpty(),
-            todayIso
-        )
-        if (json != null) gson.fromJson<List<Meta>>(json, metaListType) ?: emptyList() else emptyList()
+        val args = JsonObject().apply {
+            addProperty("itemsJson", gson.toJson(items))
+            addProperty("catalogId", catalogId)
+            genre?.takeIf { it.isNotEmpty() }?.let { addProperty("genre", it) }
+            addProperty("todayIso", todayIso)
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("normalizeHomeCatalogItems", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson<List<Meta>>(it, metaListType) } ?: emptyList()
     }
 
-    fun playerProgressPercent(positionMs: Long, durationMs: Long): Float = call {
-        playerProgressPercentNative(positionMs, durationMs)
+    fun playerProgressPercent(positionMs: Long, durationMs: Long): Float {
+        val args = JsonObject().apply {
+            addProperty("positionMs", positionMs)
+            addProperty("durationMs", durationMs)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("playerProgressPercent", args.toString()).asFloat
     }
 
     fun playerShouldSendScrobbleStart(
@@ -1422,12 +1541,22 @@ object FluxaCoreNative {
         isPlaying: Boolean,
         hasScrobbledStart: Boolean,
         progress: Float
-    ): Boolean = call {
-        playerShouldSendScrobbleStartNative(token.orEmpty(), isPlaying, hasScrobbledStart, progress)
+    ): Boolean {
+        val args = JsonObject().apply {
+            token?.let { addProperty("token", it) }
+            addProperty("isPlaying", isPlaying)
+            addProperty("hasScrobbledStart", hasScrobbledStart)
+            addProperty("progress", progress)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("playerShouldSendScrobbleStart", args.toString()).asBoolean
     }
 
-    fun playerShouldMarkScrobbleStopped(hasScrobbledStop: Boolean, progress: Float): Boolean = call {
-        playerShouldMarkScrobbleStoppedNative(hasScrobbledStop, progress)
+    fun playerShouldMarkScrobbleStopped(hasScrobbledStop: Boolean, progress: Float): Boolean {
+        val args = JsonObject().apply {
+            addProperty("hasScrobbledStop", hasScrobbledStop)
+            addProperty("progress", progress)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("playerShouldMarkScrobbleStopped", args.toString()).asBoolean
     }
 
     fun playerShouldQueueScrobblePause(
@@ -1435,93 +1564,132 @@ object FluxaCoreNative {
         wasPlayWhenReady: Boolean,
         hasScrobbledStart: Boolean,
         hasScrobbledStop: Boolean
-    ): Boolean = call {
-        playerShouldQueueScrobblePauseNative(
-            token.orEmpty(),
-            wasPlayWhenReady,
-            hasScrobbledStart,
-            hasScrobbledStop
-        )
+    ): Boolean {
+        val args = JsonObject().apply {
+            token?.let { addProperty("token", it) }
+            addProperty("wasPlayWhenReady", wasPlayWhenReady)
+            addProperty("hasScrobbledStart", hasScrobbledStart)
+            addProperty("hasScrobbledStop", hasScrobbledStop)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("playerShouldQueueScrobblePause", args.toString()).asBoolean
     }
 
-    fun playerShouldEnqueueDurableScrobble(action: String, token: String?, progress: Float): Boolean = call {
-        playerShouldEnqueueDurableScrobbleNative(action, token.orEmpty(), progress)
+    fun playerShouldEnqueueDurableScrobble(action: String, token: String?, progress: Float): Boolean {
+        val args = JsonObject().apply {
+            addProperty("action", action)
+            token?.let { addProperty("token", it) }
+            addProperty("progress", progress)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("playerShouldEnqueueDurableScrobble", args.toString()).asBoolean
     }
 
-    fun playerShouldSavePeriodicProgress(isPlaying: Boolean, nowMs: Long, lastSavedAtMs: Long): Boolean = call {
-        playerShouldSavePeriodicProgressNative(isPlaying, nowMs, lastSavedAtMs)
+    fun playerShouldSavePeriodicProgress(isPlaying: Boolean, nowMs: Long, lastSavedAtMs: Long): Boolean {
+        val args = JsonObject().apply {
+            addProperty("isPlaying", isPlaying)
+            addProperty("nowMs", nowMs)
+            addProperty("lastSavedAtMs", lastSavedAtMs)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("playerShouldSavePeriodicProgress", args.toString()).asBoolean
     }
 
-    fun playerShouldSaveOnDispose(positionMs: Long): Boolean = call {
-        playerShouldSaveOnDisposeNative(positionMs)
+    fun playerShouldSaveOnDispose(positionMs: Long): Boolean {
+        val args = JsonObject().apply { addProperty("positionMs", positionMs) }
+        return FluxaCoreUniFfi.coreInvokeValue("playerShouldSaveOnDispose", args.toString()).asBoolean
     }
 
-    fun safePlayerBufferCacheMb(value: Int?): Int = call {
-        safePlayerBufferCacheMbNative(value ?: 0, value != null)
+    fun safePlayerBufferCacheMb(value: Int?): Int {
+        val args = JsonObject().apply { value?.let { addProperty("value", it) } }
+        return FluxaCoreUniFfi.coreInvokeValue("safePlayerBufferCacheMb", args.toString()).asInt
     }
 
-    fun safeStreamSourceSelectionMode(mode: String?): String = call {
-        safeStreamSourceSelectionModeNative(mode.orEmpty())
+    fun safeStreamSourceSelectionMode(mode: String?): String {
+        val args = JsonObject().apply { mode?.takeIf { it.isNotEmpty() }?.let { addProperty("mode", it) } }
+        return FluxaCoreUniFfi.coreInvokeValue("safeStreamSourceSelectionMode", args.toString()).asString
     }
 
-    fun playerFlowDispatch(state: Any, action: Any): NativePlayerFlowResult = call {
-        val json = playerFlowDispatchJsonNative(gson.toJson(state), gson.toJson(action))
-        json?.takeIf { it.isNotBlank() }?.let { gson.fromJson(it, NativePlayerFlowResult::class.java) }
+    fun playerFlowDispatch(state: Any, action: Any): NativePlayerFlowResult {
+        val args = JsonObject().apply {
+            addProperty("state", gson.toJson(state))
+            addProperty("action", gson.toJson(action))
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("playerFlowDispatch", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson(it, NativePlayerFlowResult::class.java) }
             ?: NativePlayerFlowResult()
     }
 
-    fun traktHasClient(apiKey: String): Boolean = call {
-        traktHasClientNative(apiKey)
+    fun traktHasClient(apiKey: String): Boolean {
+        val args = JsonObject().apply { addProperty("apiKey", apiKey) }
+        return FluxaCoreUniFfi.coreInvokeValue("traktHasClient", args.toString()).asBoolean
     }
 
-    fun traktBearer(token: String): String = call {
-        traktBearerNative(token)
+    fun traktBearer(token: String): String {
+        val args = JsonObject().apply { addProperty("token", token) }
+        return FluxaCoreUniFfi.coreInvokeValue("traktBearer", args.toString()).asString
     }
 
-    fun traktScrobbleUrl(action: String): String = call {
-        traktScrobbleUrlNative(action)
+    fun traktScrobbleUrl(action: String): String {
+        val args = JsonObject().apply { addProperty("action", action) }
+        return FluxaCoreUniFfi.coreInvokeValue("traktScrobbleUrl", args.toString()).asString
     }
 
-    fun traktPlaybackUrl(type: String?): String = call {
-        traktPlaybackUrlNative(type.orEmpty())
+    fun traktPlaybackUrl(type: String?): String {
+        val args = JsonObject().apply { type?.takeIf { it.isNotBlank() }?.let { addProperty("contentType", it) } }
+        return FluxaCoreUniFfi.coreInvokeValue("traktPlaybackUrl", args.toString()).asString
     }
 
-    fun traktTokenExpiresAt(createdAtSeconds: Long, expiresInSeconds: Long): Long = call {
-        traktTokenExpiresAtNative(createdAtSeconds, expiresInSeconds)
+    fun traktTokenExpiresAt(createdAtSeconds: Long, expiresInSeconds: Long): Long {
+        val args = JsonObject().apply {
+            addProperty("createdAtSeconds", createdAtSeconds)
+            addProperty("expiresInSeconds", expiresInSeconds)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("traktTokenExpiresAt", args.toString()).asLong
     }
 
-    fun traktContentIdFrom(ids: TraktIds): String? = call {
-        traktContentIdFromIdsNative(gson.toJson(ids)).takeIf { it.isNotBlank() }
+    fun traktContentIdFrom(ids: TraktIds): String? {
+        val args = JsonObject().apply { addProperty("idsJson", gson.toJson(ids)) }
+        val value = FluxaCoreUniFfi.coreInvokeValue("traktContentIdFromIds", args.toString())
+        return value.takeUnless { it.isJsonNull }?.asString?.takeIf { it.isNotBlank() }
     }
 
-    fun traktIdsFromContentId(rawId: String): TraktIds? = call {
-        traktIdsFromContentIdJsonNative(rawId)
-            ?.takeIf { it.isNotBlank() }
-            ?.let { gson.fromJson(it, TraktIds::class.java) }
+    fun traktIdsFromContentId(rawId: String): TraktIds? {
+        val args = JsonObject().apply { addProperty("rawId", rawId) }
+        val value = FluxaCoreUniFfi.coreInvokeValue("traktIdsFromContentId", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson(it, TraktIds::class.java) }
     }
 
-    fun traktEpisodeLocator(videoId: String): NativeTraktEpisodeLocator? = call {
-        traktEpisodeLocatorJsonNative(videoId)
-            ?.takeIf { it.isNotBlank() }
-            ?.let { gson.fromJson(it, NativeTraktEpisodeLocator::class.java) }
+    fun traktEpisodeLocator(videoId: String): NativeTraktEpisodeLocator? {
+        val args = JsonObject().apply { addProperty("videoId", videoId) }
+        val value = FluxaCoreUniFfi.coreInvokeValue("traktEpisodeLocator", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson(it, NativeTraktEpisodeLocator::class.java) }
     }
 
-    fun traktShowIdFromEpisodeId(videoId: String): String = call {
-        traktShowIdFromEpisodeIdNative(videoId)
+    fun traktShowIdFromEpisodeId(videoId: String): String {
+        val args = JsonObject().apply { addProperty("videoId", videoId) }
+        return FluxaCoreUniFfi.coreInvokeValue("traktShowIdFromEpisodeId", args.toString()).asString
     }
 
-    fun traktScrobbleMediaId(parentId: String, videoId: String?, mediaType: String): String = call {
-        traktScrobbleMediaIdNative(parentId, videoId.orEmpty(), mediaType)
+    fun traktScrobbleMediaId(parentId: String, videoId: String?, mediaType: String): String {
+        val args = JsonObject().apply {
+            addProperty("parentId", parentId)
+            videoId?.takeIf { it.isNotEmpty() }?.let { addProperty("videoId", it) }
+            addProperty("mediaType", mediaType)
+        }
+        return FluxaCoreUniFfi.coreInvokeValue("traktScrobbleMediaId", args.toString()).asString
     }
 
-    fun traktOAuthErrorCode(body: String): String? = call {
-        traktOAuthErrorCodeNative(body).takeIf { it.isNotBlank() }
+    fun traktOAuthErrorCode(body: String): String? {
+        val args = JsonObject().apply { addProperty("body", body) }
+        val value = FluxaCoreUniFfi.coreInvokeValue("traktOAuthErrorCode", args.toString())
+        return value.takeUnless { it.isJsonNull }?.asString?.takeIf { it.isNotBlank() }
     }
 
-    fun traktHistoryRequest(meta: Meta, episodes: List<Video>): TraktHistorySyncRequest? = call {
-        traktHistoryRequestJsonNative(gson.toJson(meta), gson.toJson(episodes))
-            ?.takeIf { it.isNotBlank() }
-            ?.let { gson.fromJson(it, TraktHistorySyncRequest::class.java) }
+    fun traktHistoryRequest(meta: Meta, episodes: List<Video>): TraktHistorySyncRequest? {
+        val args = JsonObject().apply {
+            addProperty("metaJson", gson.toJson(meta))
+            addProperty("episodesJson", gson.toJson(episodes))
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("traktHistoryRequest", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson(it, TraktHistorySyncRequest::class.java) }
     }
 
     fun simklScrobbleBody(
@@ -1531,60 +1699,104 @@ object FluxaCoreNative {
         epNumber: Long,
         timePosSec: Double,
         durationSec: Double
-    ): String? = call {
-        simklScrobbleBodyJsonNative(idsJson, isEpisode, season, epNumber, timePosSec, durationSec)
-            ?.takeIf { it.isNotBlank() }
+    ): String? {
+        val args = JsonObject().apply {
+            addProperty("idsJson", idsJson)
+            addProperty("isEpisode", isEpisode)
+            addProperty("season", season)
+            addProperty("epNumber", epNumber)
+            addProperty("timePosSec", timePosSec)
+            addProperty("durationSec", durationSec)
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("simklScrobbleBody", args.toString())
+        return value.takeUnless { it.isJsonNull }?.toString()?.takeIf { it.isNotBlank() }
     }
 
-    fun simklMatchEpisode(episodesJson: String, targetJson: String): NativeSimklEpisodeMatch? = call {
-        simklMatchEpisodeJsonNative(episodesJson, targetJson)
-            ?.takeIf { it.isNotBlank() }
-            ?.let { gson.fromJson(it, NativeSimklEpisodeMatch::class.java) }
+    fun simklMatchEpisode(episodesJson: String, targetJson: String): NativeSimklEpisodeMatch? {
+        val args = JsonObject().apply {
+            addProperty("episodesJson", episodesJson)
+            addProperty("targetJson", targetJson)
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("simklMatchEpisode", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson(it, NativeSimklEpisodeMatch::class.java) }
     }
 
-    fun simklWatchingToItems(showsJson: String, moviesJson: String): String? = call {
-        simklWatchingToItemsJsonNative(showsJson, moviesJson)?.takeIf { it.isNotBlank() }
+    fun simklWatchingToItems(showsJson: String, moviesJson: String): String? {
+        val args = JsonObject().apply {
+            addProperty("showsJson", showsJson)
+            addProperty("moviesJson", moviesJson)
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("simklWatchingToItems", args.toString())
+        return value.takeUnless { it.isJsonNull }?.toString()?.takeIf { it.isNotBlank() }
     }
 
-    fun simklWatchlistToItems(showsJson: String, moviesJson: String): String? = call {
-        simklWatchlistToItemsJsonNative(showsJson, moviesJson)?.takeIf { it.isNotBlank() }
+    fun simklWatchlistToItems(showsJson: String, moviesJson: String): String? {
+        val args = JsonObject().apply {
+            addProperty("showsJson", showsJson)
+            addProperty("moviesJson", moviesJson)
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("simklWatchlistToItems", args.toString())
+        return value.takeUnless { it.isJsonNull }?.toString()?.takeIf { it.isNotBlank() }
     }
 
-    fun simklWatchedToIds(showsJson: String, moviesJson: String): String? = call {
-        simklWatchedToIdsJsonNative(showsJson, moviesJson)?.takeIf { it.isNotBlank() }
+    fun simklWatchedToIds(showsJson: String, moviesJson: String): String? {
+        val args = JsonObject().apply {
+            addProperty("showsJson", showsJson)
+            addProperty("moviesJson", moviesJson)
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("simklWatchedToIds", args.toString())
+        return value.takeUnless { it.isJsonNull }?.toString()?.takeIf { it.isNotBlank() }
     }
 
-    fun playbackProgressItem(meta: Meta, timeOffset: Long, duration: Long, nowUtc: String): LibraryItem? = call {
-        playbackProgressItemJsonNative(gson.toJson(meta), timeOffset, duration, nowUtc)
-            ?.takeIf { it.isNotBlank() }
-            ?.let { gson.fromJson(it, LibraryItem::class.java) }
+    fun playbackProgressItem(meta: Meta, timeOffset: Long, duration: Long, nowUtc: String): LibraryItem? {
+        val args = JsonObject().apply {
+            addProperty("metaJson", gson.toJson(meta))
+            addProperty("timeOffset", timeOffset)
+            addProperty("duration", duration)
+            addProperty("nowUtc", nowUtc)
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("playbackProgressItem", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson(it, LibraryItem::class.java) }
     }
 
-    fun clearPlaybackProgressItem(meta: Meta): LibraryItem? = call {
-        clearPlaybackProgressItemJsonNative(gson.toJson(meta))
-            ?.takeIf { it.isNotBlank() }
-            ?.let { gson.fromJson(it, LibraryItem::class.java) }
+    fun clearPlaybackProgressItem(meta: Meta): LibraryItem? {
+        val args = JsonObject().apply { addProperty("metaJson", gson.toJson(meta)) }
+        val value = FluxaCoreUniFfi.coreInvokeValue("clearPlaybackProgressItem", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson(it, LibraryItem::class.java) }
     }
 
-    fun watchedStateItems(meta: Meta, episodes: List<Video>, watched: Boolean, watchedAt: String?): List<LibraryItem> = call {
-        val json = watchedStateItemsJsonNative(gson.toJson(meta), gson.toJson(episodes), watched, watchedAt.orEmpty())
-        gson.fromJson<List<LibraryItem>>(json, libraryItemListType) ?: emptyList()
+    fun watchedStateItems(meta: Meta, episodes: List<Video>, watched: Boolean, watchedAt: String?): List<LibraryItem> {
+        val args = JsonObject().apply {
+            addProperty("metaJson", gson.toJson(meta))
+            addProperty("episodesJson", gson.toJson(episodes))
+            addProperty("watched", watched)
+            watchedAt?.takeIf { it.isNotEmpty() }?.let { addProperty("watchedAt", it) }
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("watchedStateItems", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson<List<LibraryItem>>(it, libraryItemListType) } ?: emptyList()
     }
 
-    fun libraryContinueWatchingItems(items: List<LibraryItem>): List<Meta> = call {
-        val json = libraryContinueWatchingItemsJsonNative(gson.toJson(items))
-        gson.fromJson<List<Meta>>(json, metaListType) ?: emptyList()
+    fun libraryContinueWatchingItems(items: List<LibraryItem>): List<Meta> {
+        val value = FluxaCoreUniFfi.coreInvokeValue("libraryContinueWatchingItems", gson.toJson(items))
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson<List<Meta>>(it, metaListType) } ?: emptyList()
     }
 
-    fun filterHomeContinueWatching(items: List<Meta>, traktWatchedState: TraktWatchedState): List<Meta> = call {
-        val traktJson = gson.toJson(traktWatchedState)
-        val json = filterHomeContinueWatchingJsonNative(gson.toJson(items), traktJson)
-        gson.fromJson<List<Meta>>(json, metaListType) ?: emptyList()
+    fun filterHomeContinueWatching(items: List<Meta>, traktWatchedState: TraktWatchedState): List<Meta> {
+        val args = JsonObject().apply {
+            addProperty("itemsJson", gson.toJson(items))
+            addProperty("traktWatchedJson", gson.toJson(traktWatchedState))
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("filterHomeContinueWatching", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson<List<Meta>>(it, metaListType) } ?: emptyList()
     }
 
-    fun watchedVideoIds(items: List<LibraryItem>, imdbId: String): List<String> = call {
-        val json = watchedVideoIdsJsonNative(gson.toJson(items), imdbId)
-        gson.fromJson<List<String>>(json, stringListType) ?: emptyList()
+    fun watchedVideoIds(items: List<LibraryItem>, imdbId: String): List<String> {
+        val args = JsonObject().apply {
+            addProperty("itemsJson", gson.toJson(items))
+            addProperty("imdbId", imdbId)
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("watchedVideoIds", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson<List<String>>(it, stringListType) } ?: emptyList()
     }
 
     fun offlineDownloadPlan(
@@ -1594,7 +1806,7 @@ object FluxaCoreNative {
         stream: Stream,
         subtitleUrl: String?,
         downloadId: String
-    ): NativeOfflineDownloadPlan = call {
+    ): NativeOfflineDownloadPlan {
         val request = NativeOfflineDownloadPlanRequest(
             meta = meta,
             video = video,
@@ -1603,13 +1815,14 @@ object FluxaCoreNative {
             subtitleUrl = subtitleUrl,
             downloadId = downloadId
         )
-        gson.fromJson(offlineDownloadPlanJsonNative(gson.toJson(request)), NativeOfflineDownloadPlan::class.java)
+        val value = FluxaCoreUniFfi.coreInvokeValue("offlineDownloadPlan", gson.toJson(request))
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson(it, NativeOfflineDownloadPlan::class.java) }
             ?: NativeOfflineDownloadPlan(reason = "unsupported_source")
     }
 
-    fun profileSafePrefs(profile: Any): NativeProfileSafePrefs = call {
-        gson.fromJson(profileSafePrefsJsonNative(gson.toJson(profile)), NativeProfileSafePrefs::class.java)
-            ?: NativeProfileSafePrefs()
+    fun profileSafePrefs(profile: Any): NativeProfileSafePrefs {
+        val value = FluxaCoreUniFfi.coreInvokeValue("profileSafePrefs", gson.toJson(profile))
+        return gson.fromJson(value, NativeProfileSafePrefs::class.java) ?: NativeProfileSafePrefs()
     }
 
     fun <T> sanitizeProfile(
@@ -1617,29 +1830,33 @@ object FluxaCoreNative {
         mirroredAddons: Collection<String>,
         mergeMirroredAddons: Boolean,
         type: Class<T>
-    ): T? = call {
-        sanitizeProfileJsonNative(gson.toJson(profile), gson.toJson(mirroredAddons), mergeMirroredAddons)
-            ?.takeIf { it.isNotBlank() }
-            ?.let { gson.fromJson(it, type) }
+    ): T? {
+        val args = JsonObject().apply {
+            addProperty("profile", gson.toJson(profile))
+            addProperty("mirroredAddons", gson.toJson(mirroredAddons))
+            addProperty("mergeMirroredAddons", mergeMirroredAddons)
+        }
+        val value = FluxaCoreUniFfi.coreInvokeValue("sanitizeProfile", args.toString())
+        return value.takeUnless { it.isJsonNull }?.let { gson.fromJson(it, type) }
     }
 
-    fun profileLocalAddonsKey(profile: Any): String = call {
-        profileLocalAddonsKeyNative(gson.toJson(profile))
-    }
+    fun profileLocalAddonsKey(profile: Any): String =
+        FluxaCoreUniFfi.coreInvokeValue("profileLocalAddonsKey", gson.toJson(profile)).asString
 
     fun cacheEntryPolicy(
         key: String,
         storedAtMillis: Long,
         ttlMillis: Long,
         nowMillis: Long
-    ): NativeCacheEntryPolicy = call {
+    ): NativeCacheEntryPolicy {
         val request = NativeCacheEntryPolicyRequest(
             key = key,
             storedAtMillis = storedAtMillis,
             ttlMillis = ttlMillis,
             nowMillis = nowMillis
         )
-        gson.fromJson(cacheEntryPolicyJsonNative(gson.toJson(request)), NativeCacheEntryPolicy::class.java)
+        val value = FluxaCoreUniFfi.coreInvokeValue("cacheEntryPolicy", gson.toJson(request))
+        return gson.fromJson(value, NativeCacheEntryPolicy::class.java)
             ?: NativeCacheEntryPolicy(key = key, storedAtMillis = storedAtMillis)
     }
 
@@ -1647,7 +1864,7 @@ object FluxaCoreNative {
         entries: List<Triple<String, Long, Long>>,
         maxEntries: Int,
         nowMillis: Long
-    ): NativeCacheTrimPolicy = call {
+    ): NativeCacheTrimPolicy {
         val request = NativeCacheTrimPolicyRequest(
             entries = entries.map { (key, expiresAtMillis, storedAtMillis) ->
                 NativeCacheTrimPolicyEntry(
@@ -1659,8 +1876,8 @@ object FluxaCoreNative {
             maxEntries = maxEntries,
             nowMillis = nowMillis
         )
-        gson.fromJson(cacheTrimPolicyJsonNative(gson.toJson(request)), NativeCacheTrimPolicy::class.java)
-            ?: NativeCacheTrimPolicy()
+        val value = FluxaCoreUniFfi.coreInvokeValue("cacheTrimPolicy", gson.toJson(request))
+        return gson.fromJson(value, NativeCacheTrimPolicy::class.java) ?: NativeCacheTrimPolicy()
     }
 
     fun dataFailurePolicy(
@@ -1670,7 +1887,7 @@ object FluxaCoreNative {
         throwableClass: String? = null,
         reason: String? = null,
         statusCode: Long? = null
-    ): NativeDataFailurePolicy = call {
+    ): NativeDataFailurePolicy {
         val request = NativeDataFailurePolicyRequest(
             operation = operation,
             kind = kind,
@@ -1679,127 +1896,102 @@ object FluxaCoreNative {
             reason = reason,
             statusCode = statusCode
         )
-        gson.fromJson(dataFailurePolicyJsonNative(gson.toJson(request)), NativeDataFailurePolicy::class.java)
+        val value = FluxaCoreUniFfi.coreInvokeValue("dataFailurePolicy", gson.toJson(request))
+        return gson.fromJson(value, NativeDataFailurePolicy::class.java)
             ?: NativeDataFailurePolicy(operation = operation, kind = kind, message = message ?: reason.orEmpty())
     }
 
-    // ── calendar_plan ─────────────────────────────────────────────────────────
-    fun calendarContentPlanJson(requestJson: String): String = call {
-        calendarContentPlanJsonNative(requestJson)
-    }
-
-    fun calendarSeasonCandidatesJson(requestJson: String): List<Int> = call {
-        val json = calendarSeasonCandidatesJsonNative(requestJson)
-        gson.fromJson<List<Int>>(json, object : TypeToken<List<Int>>() {}.type) ?: emptyList()
-    }
-
-    fun calendarWidgetRowsJson(requestJson: String): String = call {
-        calendarWidgetRowsJsonNative(requestJson)
-    }
-
-    fun calendarNotificationContent(requestJson: String): NativeCalendarNotificationContent = call {
-        gson.fromJson(calendarNotificationContentJsonNative(requestJson), NativeCalendarNotificationContent::class.java)
-            ?: NativeCalendarNotificationContent()
-    }
-
-    fun calendarReleaseDetectionJson(requestJson: String): String = call {
-        calendarReleaseDetectionJsonNative(requestJson)
-    }
-
     // ── profile_contract ──────────────────────────────────────────────────────
-    fun activeProfilePlanJson(requestJson: String): NativeActiveProfilePlan = call {
-        gson.fromJson(activeProfilePlanJsonNative(requestJson), NativeActiveProfilePlan::class.java)
-            ?: NativeActiveProfilePlan()
+    fun activeProfilePlanJson(requestJson: String): NativeActiveProfilePlan {
+        val value = FluxaCoreUniFfi.coreInvokeValue("activeProfilePlan", requestJson)
+        return gson.fromJson(value, NativeActiveProfilePlan::class.java) ?: NativeActiveProfilePlan()
     }
 
-    fun tokenMergePlanJson(requestJson: String): String = call {
-        tokenMergePlanJsonNative(requestJson)
+    fun tokenMergePlanJson(requestJson: String): String =
+        FluxaCoreUniFfi.coreInvokeValue("tokenMergePlan", requestJson).toString()
+
+    fun profileDefaultSeedJson(requestJson: String): String =
+        FluxaCoreUniFfi.coreInvokeValue("profileDefaultSeed", requestJson).toString()
+
+    fun profileSettingsMigrationPlan(requestJson: String): NativeProfileSettingsMigration {
+        val value = FluxaCoreUniFfi.coreInvokeValue("profileSettingsMigrationPlan", requestJson)
+        return gson.fromJson(value, NativeProfileSettingsMigration::class.java) ?: NativeProfileSettingsMigration()
     }
 
-    fun profileDefaultSeedJson(requestJson: String): String = call {
-        profileDefaultSeedJsonNative(requestJson)
-    }
-
-    fun profileSettingsMigrationPlan(requestJson: String): NativeProfileSettingsMigration = call {
-        gson.fromJson(profileSettingsMigrationPlanJsonNative(requestJson), NativeProfileSettingsMigration::class.java)
-            ?: NativeProfileSettingsMigration()
-    }
-
-    fun profileAvatarDefault(requestJson: String): NativeProfileAvatarDefault = call {
-        gson.fromJson(profileAvatarDefaultJsonNative(requestJson), NativeProfileAvatarDefault::class.java)
-            ?: NativeProfileAvatarDefault()
+    fun profileAvatarDefault(requestJson: String): NativeProfileAvatarDefault {
+        val value = FluxaCoreUniFfi.coreInvokeValue("profileAvatarDefault", requestJson)
+        return gson.fromJson(value, NativeProfileAvatarDefault::class.java) ?: NativeProfileAvatarDefault()
     }
 
     // ── watchlist_plan ────────────────────────────────────────────────────────
-    fun watchlistTogglePlan(requestJson: String): NativeWatchlistTogglePlan = call {
-        gson.fromJson(watchlistTogglePlanJsonNative(requestJson), NativeWatchlistTogglePlan::class.java)
-            ?: NativeWatchlistTogglePlan()
+    fun watchlistTogglePlan(requestJson: String): NativeWatchlistTogglePlan {
+        val value = FluxaCoreUniFfi.coreInvokeValue("watchlistTogglePlan", requestJson)
+        return gson.fromJson(value, NativeWatchlistTogglePlan::class.java) ?: NativeWatchlistTogglePlan()
     }
 
-    fun libraryExternalMergePlanJson(requestJson: String): String = call {
-        libraryExternalMergePlanJsonNative(requestJson)
-    }
+    fun libraryExternalMergePlanJson(requestJson: String): String =
+        FluxaCoreUniFfi.coreInvokeValue("libraryExternalMergePlan", requestJson).toString()
 
-    fun libraryCollectionImportValidation(requestJson: String): NativeLibraryCollectionImportValidation = call {
-        gson.fromJson(libraryCollectionImportValidationJsonNative(requestJson), NativeLibraryCollectionImportValidation::class.java)
+    fun libraryCollectionImportValidation(requestJson: String): NativeLibraryCollectionImportValidation {
+        val value = FluxaCoreUniFfi.coreInvokeValue("libraryCollectionImportValidation", requestJson)
+        return gson.fromJson(value, NativeLibraryCollectionImportValidation::class.java)
             ?: NativeLibraryCollectionImportValidation()
     }
 
-    fun libraryOfflineGrouping(requestJson: String): NativeLibraryOfflineGrouping = call {
-        gson.fromJson(libraryOfflineGroupingJsonNative(requestJson), NativeLibraryOfflineGrouping::class.java)
+    fun libraryOfflineGrouping(requestJson: String): NativeLibraryOfflineGrouping {
+        val value = FluxaCoreUniFfi.coreInvokeValue("libraryOfflineGrouping", requestJson)
+        return gson.fromJson(value, NativeLibraryOfflineGrouping::class.java)
             ?: NativeLibraryOfflineGrouping()
     }
 
-    fun playbackProgressMergePlanJson(requestJson: String): String = call {
-        playbackProgressMergePlanJsonNative(requestJson)
-    }
+    fun playbackProgressMergePlanJson(requestJson: String): String =
+        FluxaCoreUniFfi.coreInvokeValue("playbackProgressMergePlan", requestJson).toString()
 
     // ── player_policy ─────────────────────────────────────────────────────────
-    fun playerBackendSelection(requestJson: String): NativePlayerBackendSelection = call {
-        gson.fromJson(playerBackendSelectionJsonNative(requestJson), NativePlayerBackendSelection::class.java)
-            ?: NativePlayerBackendSelection()
+    fun playerBackendSelection(requestJson: String): NativePlayerBackendSelection {
+        val value = FluxaCoreUniFfi.coreInvokeValue("playerBackendSelection", requestJson)
+        return gson.fromJson(value, NativePlayerBackendSelection::class.java) ?: NativePlayerBackendSelection()
     }
 
-    fun torrentFallbackFilePolicy(requestJson: String): NativeTorrentFallbackFilePolicy = call {
-        gson.fromJson(torrentFallbackFilePolicyJsonNative(requestJson), NativeTorrentFallbackFilePolicy::class.java)
+    fun torrentFallbackFilePolicy(requestJson: String): NativeTorrentFallbackFilePolicy {
+        val value = FluxaCoreUniFfi.coreInvokeValue("torrentFallbackFilePolicy", requestJson)
+        return gson.fromJson(value, NativeTorrentFallbackFilePolicy::class.java)
             ?: NativeTorrentFallbackFilePolicy()
     }
 
-    fun playerBufferTargets(requestJson: String): NativePlayerBufferTargets = call {
-        gson.fromJson(playerBufferTargetsJsonNative(requestJson), NativePlayerBufferTargets::class.java)
-            ?: NativePlayerBufferTargets()
+    fun playerBufferTargets(requestJson: String): NativePlayerBufferTargets {
+        val value = FluxaCoreUniFfi.coreInvokeValue("playerBufferTargets", requestJson)
+        return gson.fromJson(value, NativePlayerBufferTargets::class.java) ?: NativePlayerBufferTargets()
     }
 
-    fun playerRetryPolicy(requestJson: String): NativePlayerRetryPolicy = call {
-        gson.fromJson(playerRetryPolicyJsonNative(requestJson), NativePlayerRetryPolicy::class.java)
-            ?: NativePlayerRetryPolicy()
+    fun playerRetryPolicy(requestJson: String): NativePlayerRetryPolicy {
+        val value = FluxaCoreUniFfi.coreInvokeValue("playerRetryPolicy", requestJson)
+        return gson.fromJson(value, NativePlayerRetryPolicy::class.java) ?: NativePlayerRetryPolicy()
     }
 
-    fun playerSourceSidebarPlanJson(requestJson: String): String = call {
-        playerSourceSidebarPlanJsonNative(requestJson)
-    }
+    fun playerSourceSidebarPlanJson(requestJson: String): String =
+        FluxaCoreUniFfi.coreInvokeValue("playerSourceSidebarPlan", requestJson).toString()
 
     // ── search_plan ───────────────────────────────────────────────────────────
-    fun searchResultGrouping(requestJson: String): NativeSearchResultGrouping = call {
-        gson.fromJson(searchResultGroupingJsonNative(requestJson), NativeSearchResultGrouping::class.java)
-            ?: NativeSearchResultGrouping()
+    fun searchResultGrouping(requestJson: String): NativeSearchResultGrouping {
+        val value = FluxaCoreUniFfi.coreInvokeValue("searchResultGrouping", requestJson)
+        return gson.fromJson(value, NativeSearchResultGrouping::class.java) ?: NativeSearchResultGrouping()
     }
 
-    fun discoverSortPlanJson(requestJson: String): String = call {
-        discoverSortPlanJsonNative(requestJson)
+    fun discoverSortPlanJson(requestJson: String): String =
+        FluxaCoreUniFfi.coreInvokeValue("discoverSortPlan", requestJson).toString()
+
+    fun librarySortPlanJson(requestJson: String): String =
+        FluxaCoreUniFfi.coreInvokeValue("librarySortPlan", requestJson).toString()
+
+    fun detailSeriesLookupId(rawId: String): String {
+        val args = JsonObject().apply { addProperty("id", rawId) }
+        return FluxaCoreUniFfi.coreInvokeValue("detailSeriesLookupId", args.toString()).asString
     }
 
-    fun librarySortPlanJson(requestJson: String): String = call {
-        librarySortPlanJsonNative(requestJson)
-    }
-
-    fun detailSeriesLookupId(rawId: String): String = call {
-        detailSeriesLookupIdNative(rawId)
-    }
-
-    fun detailSeasonLoadPlan(requestJson: String): NativeDetailSeasonLoadPlan = call {
-        gson.fromJson(detailSeasonLoadPlanJsonNative(requestJson), NativeDetailSeasonLoadPlan::class.java)
-            ?: NativeDetailSeasonLoadPlan()
+    fun detailSeasonLoadPlan(requestJson: String): NativeDetailSeasonLoadPlan {
+        val value = FluxaCoreUniFfi.coreInvokeValue("detailSeasonLoadPlan", requestJson)
+        return gson.fromJson(value, NativeDetailSeasonLoadPlan::class.java) ?: NativeDetailSeasonLoadPlan()
     }
 
     private inline fun <T> call(block: () -> T): T {
@@ -1818,7 +2010,6 @@ object FluxaCoreNative {
     }
 
     private external fun coreInvokeNative(method: String, argsJson: String): String?
-    private external fun normalizeManifestUrlNative(rawUrl: String): String
     private external fun createAppCoreStateNative(initialJson: String): Long
     private external fun destroyAppCoreStateNative(handle: Long): Boolean
     private external fun appCoreStateJsonNative(handle: Long): String?
@@ -1828,286 +2019,4 @@ object FluxaCoreNative {
     private external fun headlessEngineSnapshotJsonNative(handle: Long): String?
     private external fun headlessEngineDispatchJsonNative(handle: Long, actionJson: String): String?
     private external fun headlessEngineCompleteEffectJsonNative(handle: Long, resultJson: String): String?
-    private external fun coreCapabilitiesJsonNative(portable: Boolean): String
-    private external fun identityNative(rawUrl: String): String
-    private external fun manifestCandidatesJsonNative(rawUrl: String): String
-    private external fun manifestFetchPlanJsonNative(rawUrl: String): String?
-    private external fun baseUrlNative(rawUrl: String): String
-    private external fun preferHttpsAssetUrlNative(rawUrl: String): String
-    private external fun addonStoreInputTypeNative(text: String): String
-    private external fun normalizeCloudstreamRepoUrlNative(rawUrl: String): String
-    private external fun normalizePluginRepositoryUrlNative(rawUrl: String): String
-    private external fun pluginIsSecureRemoteUrlNative(url: String): Boolean
-    private external fun pluginSameRepositoryUrlNative(left: String, right: String): Boolean
-    private external fun extractAddonManifestUrlNative(detailText: String): String
-    private external fun addonStoreSearchPolicyJsonNative(requestJson: String): String
-    private external fun repositoryMetaDetailPlanJsonNative(requestJson: String): String
-    private external fun repositorySeasonVideosJsonNative(metaDetailJson: String, seasonNumber: Int): String
-    private external fun manifestFetchDecisionJsonNative(requestJson: String): String
-    private external fun addonResourceRequestPlanJsonNative(requestJson: String): String
-    private external fun addonStreamsWithProviderJsonNative(streamsJson: String, addonName: String): String
-    private external fun headlessProviderAvailabilityPlanJsonNative(requestJson: String): String
-    private external fun headlessDetailStreamResultPlanJsonNative(requestJson: String): String
-    private external fun headlessPrefetchDetailStreamsPlanJsonNative(requestJson: String): String
-    private external fun headlessDirectPlaybackPolicyJsonNative(): String
-    private external fun offlineDownloadPlanJsonNative(requestJson: String): String
-    private external fun profileSafePrefsJsonNative(profileJson: String): String
-    private external fun sanitizeProfileJsonNative(
-        profileJson: String,
-        mirroredAddonsJson: String,
-        mergeMirroredAddons: Boolean
-    ): String?
-    private external fun profileLocalAddonsKeyNative(profileJson: String): String
-    private external fun cacheEntryPolicyJsonNative(requestJson: String): String
-    private external fun cacheTrimPolicyJsonNative(requestJson: String): String
-    private external fun dataFailurePolicyJsonNative(requestJson: String): String
-    private external fun buildResourceUrlNative(
-        transportUrl: String,
-        resource: String,
-        type: String,
-        id: String,
-        extraJson: String
-    ): String
-    private external fun parseManifestJsonNative(body: String, transportUrl: String, unknownName: String): String
-    private external fun resolveManifestAssetsJsonNative(descriptorJson: String): String
-    private external fun mergeLiveManifestJsonNative(
-        descriptorJson: String,
-        liveJson: String,
-        unknownName: String
-    ): String
-    private external fun supportsResourceNative(manifestJson: String, resourceName: String, type: String, id: String): Boolean
-    private external fun catalogSupportsExtraNative(catalogJson: String, extraName: String): Boolean
-    private external fun catalogRequiresExtraNative(catalogJson: String, extraName: String): Boolean
-    private external fun catalogHasRequiredExtraExceptNative(catalogJson: String, allowedNamesJson: String): Boolean
-    private external fun parseEpisodeLocatorJsonNative(raw: String): String?
-    private external fun streamRequestIdsJsonNative(
-        type: String,
-        id: String,
-        detailId: String,
-        currentSeriesLookupId: String,
-        canonicalBaseId: String
-    ): String
-    private external fun playbackStreamRequestIdsJsonNative(type: String, id: String, detailId: String): String
-    private external fun streamDiscoveryEpisodeContextJsonNative(
-        type: String,
-        requestId: String,
-        detailJson: String,
-        seasonEpisodesJson: String
-    ): String
-    private external fun playbackIntroLookupContentIdNative(id: String): String
-    private external fun directPlaybackPlanJsonNative(metaJson: String, detailJson: String, todayIso: String): String
-    private external fun streamPlaybackInfoJsonNative(streamJson: String): String
-    private external fun dvProxyPlanJsonNative(requestJson: String): String
-    private external fun dolbyVisionRpuInfoJsonNative(requestJson: String): String
-    private external fun dolbyVisionConvertRpuJsonNative(requestJson: String): String
-    private external fun streamRequestHeadersJsonNative(headersJson: String): String
-    private external fun streamRequestRefererNative(url: String): String
-    private external fun episodeTextMatchesNative(text: String, season: Int, episode: Int): Boolean
-    private external fun streamMatchesEpisodeNative(
-        videoId: String,
-        title: String,
-        name: String,
-        description: String,
-        filename: String,
-        effectiveFilename: String
-    ): Boolean
-    private external fun selectStreamIndexNative(
-        streamsJson: String,
-        currentVideoId: String,
-        initialStreamIndex: Int,
-        savedUrl: String,
-        savedTitle: String,
-        sourceSelectionMode: String,
-        regexPattern: String,
-        preferredBingeGroup: String
-    ): Int
-    private external fun mergeContinueWatchingDuplicatesJsonNative(itemsJson: String): String
-    private external fun filterDiscoverResultsJsonNative(
-        itemsJson: String,
-        year: String,
-        rating: Float,
-        hasRating: Boolean,
-        region: String
-    ): String
-    private external fun resolvePreferredAudioLanguageNative(
-        lastAudioLanguage: String,
-        preferredAudioLanguage: String,
-        originalLanguage: String
-    ): String
-    private external fun subtitleLanguageMatchesNative(
-        label: String,
-        language: String,
-        preferredLanguage: String
-    ): Boolean
-    private external fun findPreferredSubtitleIndexNative(
-        tracksJson: String,
-        lastSubtitleLanguage: String,
-        preferredSubtitleLanguage: String,
-        secondarySubtitleLanguage: String
-    ): Int
-    private external fun playerTrackStateJsonNative(requestJson: String): String
-    private external fun parseAddonResourceResultJsonNative(
-        resource: String,
-        url: String,
-        statusCode: Int,
-        body: String
-    ): String
-    private external fun normalizeAddonSubtitlesJsonNative(subtitlesJson: String, resourceUrl: String): String
-    private external fun torrentRuntimeInfoJsonNative(requestJson: String): String
-    private external fun torrentStatusInfoJsonNative(statusJson: String): String
-    private external fun stableFeedPartNative(value: String): String
-    private external fun normalizeContentTypeNative(value: String): String
-    private external fun parseExtraArgsJsonNative(extra: String): String
-    private external fun providerSearchTermsJsonNative(provider: String): String
-    private external fun effectiveMetadataFeedSelectionJsonNative(selectedKeysJson: String, availableKeysJson: String): String?
-    private external fun toggleMetadataFeedJsonNative(selectedKeysJson: String, availableKeysJson: String, key: String): String
-    private external fun toggleMetadataFeedLimitedJsonNative(
-        selectedKeysJson: String,
-        availableKeysJson: String,
-        key: String,
-        maxEnabled: Int
-    ): String
-    private external fun setMetadataFeedGroupEnabledJsonNative(
-        selectedKeysJson: String,
-        availableKeysJson: String,
-        groupKeysJson: String,
-        enabled: Boolean
-    ): String
-    private external fun orderedMetadataFeedKeysJsonNative(optionKeysJson: String, orderJson: String): String
-    private external fun moveMetadataFeedOrderJsonNative(
-        optionKeysJson: String,
-        currentOrderJson: String,
-        key: String,
-        delta: Int
-    ): String
-    private external fun contentTraktKeysBatchJsonNative(metasJson: String): String
-    private external fun contentMergeKeysJsonNative(metaJson: String): String
-    private external fun contentWatchedKeysBatchJsonNative(metasJson: String): String
-    private external fun episodeFilenameCandidateNative(streamJson: String, videoId: String): String
-    private external fun streamDiscoveryCacheKeyNative(requestJson: String): String
-    private external fun discoverCatalogCacheKeyNative(requestJson: String): String
-    private external fun streamDiscoveryPlanJsonNative(requestJson: String): String?
-    private external fun streamDiscoveryExecutionPolicyJsonNative(requestJson: String): String?
-    private external fun streamDiscoveryCachePrefixNative(type: String, id: String, language: String): String
-    private external fun buildBillboardPoolJsonNative(enrichedJson: String, candidatesJson: String): String?
-    private external fun normalizeHomeCatalogItemsJsonNative(
-        itemsJson: String,
-        catalogId: String,
-        genre: String,
-        todayIso: String
-    ): String?
-    private external fun curateHomeItemsJsonNative(categoryJson: String): String
-    private external fun homeOverlapRatioNative(firstCategoryJson: String, secondCategoryJson: String): Float
-    private external fun homePersonalizationScoreNative(
-        categoryJson: String,
-        preferredGenresJson: String,
-        preferredTypesJson: String,
-        priorityLabelsJson: String
-    ): Int
-    private external fun prioritizeHomeRowsJsonNative(
-        categoriesJson: String,
-        preferredOrderLabelsJson: String,
-        preferredGenresJson: String,
-        preferredTypesJson: String,
-        priorityLabelsJson: String
-    ): String
-    private external fun optimizeHomeRowsJsonNative(requestJson: String): String
-    private external fun playerProgressPercentNative(positionMs: Long, durationMs: Long): Float
-    private external fun playerShouldSendScrobbleStartNative(
-        token: String,
-        isPlaying: Boolean,
-        hasScrobbledStart: Boolean,
-        progress: Float
-    ): Boolean
-    private external fun playerShouldMarkScrobbleStoppedNative(hasScrobbledStop: Boolean, progress: Float): Boolean
-    private external fun playerShouldQueueScrobblePauseNative(
-        token: String,
-        wasPlayWhenReady: Boolean,
-        hasScrobbledStart: Boolean,
-        hasScrobbledStop: Boolean
-    ): Boolean
-    private external fun playerShouldEnqueueDurableScrobbleNative(
-        action: String,
-        token: String,
-        progress: Float
-    ): Boolean
-    private external fun playerShouldSavePeriodicProgressNative(
-        isPlaying: Boolean,
-        nowMs: Long,
-        lastSavedAtMs: Long
-    ): Boolean
-    private external fun playerShouldSaveOnDisposeNative(positionMs: Long): Boolean
-    private external fun safePlayerBufferCacheMbNative(value: Int, hasValue: Boolean): Int
-    private external fun safeStreamSourceSelectionModeNative(mode: String): String
-    private external fun playerFlowDispatchJsonNative(stateJson: String, actionJson: String): String?
-    private external fun traktHasClientNative(apiKey: String): Boolean
-    private external fun traktBearerNative(token: String): String
-    private external fun traktScrobbleUrlNative(action: String): String
-    private external fun traktPlaybackUrlNative(type: String): String
-    private external fun traktTokenExpiresAtNative(createdAtSeconds: Long, expiresInSeconds: Long): Long
-    private external fun traktContentIdFromIdsNative(idsJson: String): String
-    private external fun traktIdsFromContentIdJsonNative(rawId: String): String?
-    private external fun traktEpisodeLocatorJsonNative(videoId: String): String?
-    private external fun traktShowIdFromEpisodeIdNative(videoId: String): String
-    private external fun traktScrobbleMediaIdNative(parentId: String, videoId: String, mediaType: String): String
-    private external fun traktOAuthErrorCodeNative(body: String): String
-    private external fun traktHistoryRequestJsonNative(metaJson: String, episodesJson: String): String?
-    private external fun simklScrobbleBodyJsonNative(
-        idsJson: String,
-        isEpisode: Boolean,
-        season: Long,
-        epNumber: Long,
-        timePosSec: Double,
-        durationSec: Double
-    ): String?
-    private external fun simklMatchEpisodeJsonNative(episodesJson: String, targetJson: String): String?
-    private external fun simklWatchingToItemsJsonNative(showsJson: String, moviesJson: String): String?
-    private external fun simklWatchlistToItemsJsonNative(showsJson: String, moviesJson: String): String?
-    private external fun simklWatchedToIdsJsonNative(showsJson: String, moviesJson: String): String?
-    private external fun playbackProgressItemJsonNative(metaJson: String, timeOffset: Long, duration: Long, nowUtc: String): String?
-    private external fun clearPlaybackProgressItemJsonNative(metaJson: String): String?
-    private external fun watchedStateItemsJsonNative(
-        metaJson: String,
-        episodesJson: String,
-        watched: Boolean,
-        watchedAt: String
-    ): String
-    private external fun libraryContinueWatchingItemsJsonNative(itemsJson: String): String
-    private external fun filterHomeContinueWatchingJsonNative(itemsJson: String, traktWatchedJson: String): String
-    private external fun watchedVideoIdsJsonNative(itemsJson: String, imdbId: String): String
-
-    // ── calendar_plan ─────────────────────────────────────────────────────────
-    private external fun calendarContentPlanJsonNative(requestJson: String): String
-    private external fun calendarSeasonCandidatesJsonNative(requestJson: String): String
-    private external fun calendarWidgetRowsJsonNative(requestJson: String): String
-    private external fun calendarNotificationContentJsonNative(requestJson: String): String
-    private external fun calendarReleaseDetectionJsonNative(requestJson: String): String
-
-    // ── profile_contract ──────────────────────────────────────────────────────
-    private external fun activeProfilePlanJsonNative(requestJson: String): String
-    private external fun tokenMergePlanJsonNative(requestJson: String): String
-    private external fun profileDefaultSeedJsonNative(requestJson: String): String
-    private external fun profileSettingsMigrationPlanJsonNative(requestJson: String): String
-    private external fun profileAvatarDefaultJsonNative(requestJson: String): String
-
-    // ── watchlist_plan ────────────────────────────────────────────────────────
-    private external fun watchlistTogglePlanJsonNative(requestJson: String): String
-    private external fun libraryExternalMergePlanJsonNative(requestJson: String): String
-    private external fun libraryCollectionImportValidationJsonNative(requestJson: String): String
-    private external fun libraryOfflineGroupingJsonNative(requestJson: String): String
-    private external fun playbackProgressMergePlanJsonNative(requestJson: String): String
-
-    // ── player_policy ─────────────────────────────────────────────────────────
-    private external fun playerBackendSelectionJsonNative(requestJson: String): String
-    private external fun torrentFallbackFilePolicyJsonNative(requestJson: String): String
-    private external fun playerBufferTargetsJsonNative(requestJson: String): String
-    private external fun playerRetryPolicyJsonNative(requestJson: String): String
-    private external fun playerSourceSidebarPlanJsonNative(requestJson: String): String
-
-    // ── search_plan ───────────────────────────────────────────────────────────
-    private external fun searchResultGroupingJsonNative(requestJson: String): String
-    private external fun discoverSortPlanJsonNative(requestJson: String): String
-    private external fun librarySortPlanJsonNative(requestJson: String): String
-    private external fun detailSeriesLookupIdNative(rawId: String): String
-    private external fun detailSeasonLoadPlanJsonNative(requestJson: String): String
 }
diff --git a/data/src/androidMain/kotlin/com/fluxa/app/data/repository/ExternalLibraryClient.kt b/data/src/androidMain/kotlin/com/fluxa/app/data/repository/ExternalLibraryClient.kt
index bd53f41..0c9862a 100644
--- a/data/src/androidMain/kotlin/com/fluxa/app/data/repository/ExternalLibraryClient.kt
+++ b/data/src/androidMain/kotlin/com/fluxa/app/data/repository/ExternalLibraryClient.kt
@@ -1,10 +1,12 @@
 package com.fluxa.app.data.repository
 
 import android.util.Log
+import com.fluxa.app.core.rust.FluxaCoreUniFfi
 import com.fluxa.app.data.BuildConfig
 import com.fluxa.app.data.local.UserProfile
 import com.fluxa.app.data.local.safeLocalAddons
 import com.fluxa.app.data.local.safeLanguage
+import com.fluxa.app.data.remote.AnilistGraphQlRequest
 import com.fluxa.app.data.remote.Meta
 import com.fluxa.app.data.remote.MetaDetail
 import com.fluxa.app.data.remote.SimklEpisode
@@ -13,6 +15,7 @@ import com.fluxa.app.data.remote.TraktApi
 import com.fluxa.app.data.remote.TraktEpisode
 import com.fluxa.app.common.AppStrings
 import com.fluxa.app.domain.ContentIdentity
+import com.google.gson.JsonParser
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
@@ -25,6 +28,29 @@ import javax.inject.Singleton
 
 private const val EPISODE_PROGRESS_UNIT_MS = 45 * 60_000L
 
+private const val ANILIST_CURRENT_LIST_QUERY = """
+query (${'$'}userId: Int) {
+  MediaListCollection(userId: ${'$'}userId, type: ANIME, status: CURRENT) {
+    lists {
+      entries {
+        status
+        progress
+        updatedAt
+        media {
+          id
+          title { english romaji native }
+          coverImage { extraLarge large }
+          bannerImage
+          episodes
+          seasonYear
+          genres
+        }
+      }
+    }
+  }
+}
+"""
+
 @Singleton
 class ExternalLibraryClient @Inject constructor(
     private val traktApi: TraktApi,
@@ -43,7 +69,8 @@ class ExternalLibraryClient @Inject constructor(
             val trakt = async { getTraktPlaybackItems(profile, language) }
             val mal = async { getMalContinueWatchingItems(profile.malAccessToken) }
             val simkl = async { getSimklContinueWatchingItems(profile.simklAccessToken) }
-            val combined = trakt.await() + mal.await() + simkl.await()
+            val anilist = async { getAnilistContinueWatchingItems(profile.anilistAccessToken) }
+            val combined = trakt.await() + mal.await() + simkl.await() + anilist.await()
             distinctByIdentityKey(combined)
         }
     }
@@ -258,6 +285,75 @@ class ExternalLibraryClient @Inject constructor(
         )
     }
 
+    private suspend fun getAnilistContinueWatchingItems(token: String?): List<Meta> {
+        if (token.isNullOrBlank()) return emptyList()
+        val authorization = "Bearer $token"
+        return try {
+            val viewerResponse = traktApi.anilistGraphQl(
+                authorization,
+                AnilistGraphQlRequest(query = "query { Viewer { id } }")
+            )
+            val viewerId = viewerResponse
+                .getAsJsonObject("data")
+                ?.getAsJsonObject("Viewer")
+                ?.get("id")
+                ?.takeUnless { it.isJsonNull }
+                ?.asInt ?: return emptyList()
+
+            val listResponse = traktApi.anilistGraphQl(
+                authorization,
+                AnilistGraphQlRequest(
+                    query = ANILIST_CURRENT_LIST_QUERY,
+                    variables = mapOf("userId" to viewerId)
+                )
+            )
+            val lists = listResponse
+                .getAsJsonObject("data")
+                ?.getAsJsonObject("MediaListCollection")
+                ?.getAsJsonArray("lists")
+                ?: com.google.gson.JsonArray()
+            val entries = com.google.gson.JsonArray()
+            lists.forEach { list ->
+                list.asJsonObject.getAsJsonArray("entries")?.forEach(entries::add)
+            }
+            if (entries.size() == 0) return emptyList()
+
+            val args = com.google.gson.JsonObject().apply {
+                add("entries", entries)
+                addProperty("nowMs", System.currentTimeMillis())
+            }
+            val envelope = JsonParser.parseString(
+                FluxaCoreUniFfi.coreInvoke("anilistEntriesToSync", args.toString())
+            ).asJsonObject
+            if (envelope.get("ok")?.asBoolean != true) return emptyList()
+            val progress = envelope.getAsJsonObject("value")?.getAsJsonObject("progress") ?: return emptyList()
+            progress.entrySet().mapNotNull { (_, value) -> anilistProgressEntryToMeta(value.asJsonObject) }
+        } catch (e: Exception) {
+            Log.w("ExternalLibraryClient", "Failed to load AniList continue watching items", e)
+            emptyList()
+        }
+    }
+
+    private fun anilistProgressEntryToMeta(entry: com.google.gson.JsonObject): Meta? {
+        val meta = entry.getAsJsonObject("meta") ?: return null
+        val id = meta.get("id")?.takeUnless { it.isJsonNull }?.asString ?: return null
+        val savedAt = entry.get("savedAt")?.takeUnless { it.isJsonNull }?.asString
+        val lastWatchedAt = savedAt?.let { runCatching { java.time.Instant.parse(it).toEpochMilli() }.getOrNull() }
+        return Meta(
+            id = id,
+            name = meta.get("name")?.takeUnless { it.isJsonNull }?.asString ?: id,
+            type = meta.get("type")?.takeUnless { it.isJsonNull }?.asString ?: "series",
+            poster = meta.get("poster")?.takeUnless { it.isJsonNull }?.asString,
+            background = meta.get("background")?.takeUnless { it.isJsonNull }?.asString,
+            timeOffset = entry.get("timeOffset")?.takeUnless { it.isJsonNull }?.asLong,
+            duration = entry.get("duration")?.takeUnless { it.isJsonNull }?.asLong,
+            lastVideoId = entry.get("lastVideoId")?.takeUnless { it.isJsonNull }?.asString,
+            lastEpisodeName = entry.get("lastEpisodeName")?.takeUnless { it.isJsonNull }?.asString,
+            lastWatchedAt = lastWatchedAt,
+            reason = "AniList"
+        )
+    }
+
     private fun findEpisodeArtwork(detail: MetaDetail?, lastVideoId: String?, episode: TraktEpisode?): String? {
         val videos = detail?.videos.orEmpty()
         if (videos.isEmpty()) return null
diff --git a/data/src/androidMain/kotlin/com/fluxa/app/data/repository/NuvioCoreBridge.kt b/data/src/androidMain/kotlin/com/fluxa/app/data/repository/NuvioCoreBridge.kt
new file mode 100644
index 0000000..181bb8c
--- /dev/null
+++ b/data/src/androidMain/kotlin/com/fluxa/app/data/repository/NuvioCoreBridge.kt
@@ -0,0 +1,61 @@
+package com.fluxa.app.data.repository
+
+import com.fluxa.app.core.rust.FluxaCoreUniFfi
+import com.google.gson.JsonArray
+import com.google.gson.JsonElement
+import com.google.gson.JsonObject
+
+object NuvioCoreBridge {
+    fun buildLocalProfiles(
+        sessionProfile: JsonObject,
+        nuvioProfiles: JsonElement,
+        avatarCatalog: JsonElement,
+        existingProfiles: JsonElement
+    ): JsonArray = invoke(
+        "nuvioBuildLocalProfiles",
+        JsonObject().apply {
+            add("sessionProfile", sessionProfile)
+            add("nuvioProfiles", nuvioProfiles)
+            add("avatarCatalog", avatarCatalog)
+            add("existingProfiles", existingProfiles)
+        }
+    ).asJsonArray
+
+    fun libraryToWatchlist(library: JsonElement): JsonArray = invoke(
+        "nuvioLibraryToWatchlist",
+        JsonObject().apply { add("library", library) }
+    ).asJsonArray
+
+    fun progressMetaNeeds(watchProgress: JsonElement, library: JsonElement): JsonArray = invoke(
+        "nuvioProgressMetaNeeds",
+        JsonObject().apply {
+            add("watchProgress", watchProgress)
+            add("library", library)
+        }
+    ).asJsonArray
+
+    fun importMergePlan(
+        library: JsonElement,
+        addonMetas: JsonObject,
+        watchProgress: JsonElement,
+        watchHistory: JsonElement
+    ): JsonObject = invoke(
+        "nuvioImportMergePlan",
+        JsonObject().apply {
+            add("progress", JsonObject())
+            add("watched", JsonObject())
+            add("library", library)
+            add("addonMetas", addonMetas)
+            add("watchProgress", watchProgress)
+            add("watchHistory", watchHistory)
+        }
+    ).asJsonObject
+
+    fun mapCollections(collections: JsonElement): JsonArray = invoke(
+        "nuvioMapCollections",
+        JsonObject().apply { add("collections", collections) }
+    ).asJsonArray
+
+    private fun invoke(method: String, args: JsonObject): JsonElement =
+        FluxaCoreUniFfi.coreInvokeValue(method, args.toString())
+}