@sigx/lynx-dev-client 0.1.0

package/android/src/main/kotlin/com/sigx/devclient/DevMenu.kt

@@ -0,0 +1,278 @@
+package com.sigx.devclient
+
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import android.widget.Toast
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.unit.dp
+
+data class DevMenuActions(
+    val onReload: () -> Unit,
+    val onChangeUrl: (String) -> Unit,
+    val onGoHome: (() -> Unit)? = null,
+    val onTogglePerfHud: () -> Unit,
+    val onToggleLogBox: () -> Unit,
+    val onToggleInspector: () -> Unit,
+    val currentUrl: String,
+    val perfHudEnabled: Boolean,
+    val logBoxEnabled: Boolean,
+    val inspectorEnabled: Boolean,
+    /** Optional list of native module names to display. */
+    val nativeModules: List<String> = emptyList()
+)
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun DevMenu(
+    visible: Boolean,
+    onDismiss: () -> Unit,
+    actions: DevMenuActions
+) {
+    if (!visible) return
+
+    val context = LocalContext.current
+    var showUrlInput by remember { mutableStateOf(false) }
+    var newUrl by remember(actions.currentUrl) { mutableStateOf(actions.currentUrl) }
+    val sheetState = rememberModalBottomSheetState()
+
+    ModalBottomSheet(
+        onDismissRequest = {
+            showUrlInput = false
+            onDismiss()
+        },
+        sheetState = sheetState,
+        containerColor = MaterialTheme.colorScheme.surface
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(bottom = 32.dp)
+        ) {
+            Text(
+                "sigx Dev Menu",
+                style = MaterialTheme.typography.titleMedium,
+                modifier = Modifier.padding(horizontal = 24.dp, vertical = 8.dp),
+                color = MaterialTheme.colorScheme.primary
+            )
+
+            HorizontalDivider(modifier = Modifier.padding(vertical = 8.dp))
+
+            // Reload
+            DevMenuItem(
+                icon = Icons.Default.Refresh,
+                label = "Reload",
+                subtitle = "Full reload of current bundle"
+            ) {
+                actions.onReload()
+                onDismiss()
+            }
+
+            // Change Server URL
+            DevMenuItem(
+                icon = Icons.Default.Edit,
+                label = "Change Dev Server",
+                subtitle = if (showUrlInput) null else actions.currentUrl
+            ) {
+                showUrlInput = !showUrlInput
+            }
+
+            if (showUrlInput) {
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(horizontal = 24.dp, vertical = 4.dp),
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    OutlinedTextField(
+                        value = newUrl,
+                        onValueChange = { newUrl = it },
+                        modifier = Modifier.weight(1f),
+                        singleLine = true,
+                        label = { Text("Server URL") },
+                        keyboardOptions = KeyboardOptions(
+                            keyboardType = KeyboardType.Uri,
+                            imeAction = ImeAction.Go
+                        ),
+                        keyboardActions = KeyboardActions(
+                            onGo = {
+                                actions.onChangeUrl(newUrl)
+                                showUrlInput = false
+                                onDismiss()
+                            }
+                        )
+                    )
+                    Spacer(modifier = Modifier.width(8.dp))
+                    FilledTonalButton(onClick = {
+                        actions.onChangeUrl(newUrl)
+                        showUrlInput = false
+                        onDismiss()
+                    }) {
+                        Text("Go")
+                    }
+                }
+            }
+
+            // Copy URL
+            DevMenuItem(
+                icon = Icons.Default.Share,
+                label = "Copy URL",
+                subtitle = "Copy current server URL to clipboard"
+            ) {
+                val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+                clipboard.setPrimaryClip(ClipData.newPlainText("Dev Server URL", actions.currentUrl))
+                Toast.makeText(context, "URL copied", Toast.LENGTH_SHORT).show()
+                onDismiss()
+            }
+
+            HorizontalDivider(modifier = Modifier.padding(vertical = 8.dp))
+
+            // Performance HUD toggle
+            DevMenuToggleItem(
+                icon = Icons.Default.Info,
+                label = "Performance HUD",
+                enabled = actions.perfHudEnabled
+            ) {
+                actions.onTogglePerfHud()
+                onDismiss()
+            }
+
+            // LogBox toggle
+            DevMenuToggleItem(
+                icon = Icons.Default.Warning,
+                label = "LogBox",
+                enabled = actions.logBoxEnabled
+            ) {
+                actions.onToggleLogBox()
+                onDismiss()
+            }
+
+            // Element Inspector toggle
+            DevMenuToggleItem(
+                icon = Icons.Default.List,
+                label = "Element Inspector",
+                enabled = actions.inspectorEnabled
+            ) {
+                actions.onToggleInspector()
+                onDismiss()
+            }
+
+            // Native Modules info (if provided)
+            if (actions.nativeModules.isNotEmpty()) {
+                HorizontalDivider(modifier = Modifier.padding(vertical = 8.dp))
+
+                DevMenuItem(
+                    icon = Icons.Default.Build,
+                    label = "Native Modules (${actions.nativeModules.size})",
+                    subtitle = actions.nativeModules.joinToString(", ")
+                ) {
+                    Toast.makeText(
+                        context,
+                        "Available: ${actions.nativeModules.joinToString(", ")}",
+                        Toast.LENGTH_LONG
+                    ).show()
+                }
+            }
+
+            // Go Home (optional)
+            if (actions.onGoHome != null) {
+                HorizontalDivider(modifier = Modifier.padding(vertical = 8.dp))
+
+                DevMenuItem(
+                    icon = Icons.Default.Home,
+                    label = "Go Home",
+                    subtitle = "Return to URL input screen"
+                ) {
+                    actions.onGoHome!!()
+                    onDismiss()
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun DevMenuItem(
+    icon: ImageVector,
+    label: String,
+    subtitle: String? = null,
+    onClick: () -> Unit
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable(onClick = onClick)
+            .padding(horizontal = 24.dp, vertical = 12.dp),
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Icon(
+            imageVector = icon,
+            contentDescription = label,
+            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.size(24.dp)
+        )
+        Spacer(modifier = Modifier.width(16.dp))
+        Column(modifier = Modifier.weight(1f)) {
+            Text(
+                label,
+                style = MaterialTheme.typography.bodyLarge,
+                color = MaterialTheme.colorScheme.onSurface
+            )
+            if (subtitle != null) {
+                Text(
+                    subtitle,
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    maxLines = 1
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun DevMenuToggleItem(
+    icon: ImageVector,
+    label: String,
+    enabled: Boolean,
+    onToggle: () -> Unit
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable(onClick = onToggle)
+            .padding(horizontal = 24.dp, vertical = 12.dp),
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Icon(
+            imageVector = icon,
+            contentDescription = label,
+            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.size(24.dp)
+        )
+        Spacer(modifier = Modifier.width(16.dp))
+        Text(
+            label,
+            style = MaterialTheme.typography.bodyLarge,
+            color = MaterialTheme.colorScheme.onSurface,
+            modifier = Modifier.weight(1f)
+        )
+        Switch(
+            checked = enabled,
+            onCheckedChange = { onToggle() }
+        )
+    }
+}

package/android/src/main/kotlin/com/sigx/devclient/DevQRScanner.kt

@@ -0,0 +1,174 @@
+package com.sigx.devclient
+
+import android.Manifest
+import android.content.pm.PackageManager
+import android.util.Log
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.camera.core.CameraSelector
+import androidx.camera.core.ImageAnalysis
+import androidx.camera.core.Preview
+import androidx.camera.lifecycle.ProcessCameraProvider
+import androidx.camera.mlkit.vision.MlKitAnalyzer
+import androidx.camera.view.PreviewView
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.core.content.ContextCompat
+import androidx.lifecycle.compose.LocalLifecycleOwner
+import com.google.mlkit.vision.barcode.BarcodeScannerOptions
+import com.google.mlkit.vision.barcode.BarcodeScanning
+import com.google.mlkit.vision.barcode.common.Barcode
+
+/**
+ * Camera-driven QR scanner for `DevHomeScreen`. Uses CameraX's `MlKitAnalyzer`
+ * (the canonical CameraX × ML Kit bridge — no manual `imageProxy.image`
+ * wrangling) plus ML Kit barcode-scanning. Reports the first scanned URL/text
+ * via `onCodeScanned`; `onBack` is invoked when the user taps the back arrow.
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun DevQRScanner(
+    onCodeScanned: (String) -> Unit,
+    onBack: () -> Unit,
+) {
+    val context = LocalContext.current
+    val lifecycleOwner = LocalLifecycleOwner.current
+    var hasCameraPermission by remember {
+        mutableStateOf(
+            ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA)
+                == PackageManager.PERMISSION_GRANTED,
+        )
+    }
+    val scannedOnce = remember { mutableStateOf(false) }
+
+    val permissionLauncher = rememberLauncherForActivityResult(
+        ActivityResultContracts.RequestPermission(),
+    ) { granted ->
+        hasCameraPermission = granted
+    }
+
+    LaunchedEffect(Unit) {
+        if (!hasCameraPermission) {
+            permissionLauncher.launch(Manifest.permission.CAMERA)
+        }
+    }
+
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = { Text("Scan QR Code") },
+                navigationIcon = {
+                    IconButton(onClick = onBack) {
+                        Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Back")
+                    }
+                },
+            )
+        },
+    ) { padding ->
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(padding),
+        ) {
+            if (hasCameraPermission) {
+                AndroidView(
+                    modifier = Modifier.fillMaxSize(),
+                    factory = { ctx ->
+                        val previewView = PreviewView(ctx)
+                        val cameraProviderFuture = ProcessCameraProvider.getInstance(ctx)
+
+                        cameraProviderFuture.addListener({
+                            val cameraProvider = cameraProviderFuture.get()
+
+                            val preview = Preview.Builder().build().also {
+                                it.surfaceProvider = previewView.surfaceProvider
+                            }
+
+                            // Restrict to QR codes for faster processing — the dev
+                            // server URL is the only thing we expect to scan here.
+                            val barcodeScanner = BarcodeScanning.getClient(
+                                BarcodeScannerOptions.Builder()
+                                    .setBarcodeFormats(Barcode.FORMAT_QR_CODE)
+                                    .build(),
+                            )
+
+                            val imageAnalysis = ImageAnalysis.Builder()
+                                .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+                                .build()
+
+                            val mainExecutor = ContextCompat.getMainExecutor(ctx)
+                            // COORDINATE_SYSTEM_ORIGINAL is the right choice when
+                            // wiring ImageAnalysis directly via bindToLifecycle.
+                            // VIEW_REFERENCED only fires when using
+                            // LifecycleCameraController + PreviewView.controller,
+                            // and would silently never invoke the callback here.
+                            val analyzer = MlKitAnalyzer(
+                                listOf(barcodeScanner),
+                                ImageAnalysis.COORDINATE_SYSTEM_ORIGINAL,
+                                mainExecutor,
+                            ) { result ->
+                                if (scannedOnce.value) return@MlKitAnalyzer
+                                val barcodes = result.getValue(barcodeScanner) ?: return@MlKitAnalyzer
+                                for (barcode in barcodes) {
+                                    val value = barcode.url?.url ?: barcode.rawValue ?: continue
+                                    if (!scannedOnce.value) {
+                                        scannedOnce.value = true
+                                        onCodeScanned(value)
+                                        return@MlKitAnalyzer
+                                    }
+                                }
+                            }
+
+                            imageAnalysis.setAnalyzer(mainExecutor, analyzer)
+
+                            try {
+                                cameraProvider.unbindAll()
+                                cameraProvider.bindToLifecycle(
+                                    lifecycleOwner,
+                                    CameraSelector.DEFAULT_BACK_CAMERA,
+                                    preview,
+                                    imageAnalysis,
+                                )
+                            } catch (e: Exception) {
+                                Log.e("DevQRScanner", "Camera bind failed", e)
+                            }
+                        }, ContextCompat.getMainExecutor(ctx))
+
+                        previewView
+                    },
+                )
+
+                Text(
+                    "Point camera at QR code from dev server",
+                    modifier = Modifier
+                        .align(Alignment.BottomCenter)
+                        .padding(32.dp),
+                    style = MaterialTheme.typography.bodyLarge,
+                    color = MaterialTheme.colorScheme.onSurface,
+                )
+            } else {
+                Column(
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .padding(16.dp),
+                    verticalArrangement = Arrangement.Center,
+                    horizontalAlignment = Alignment.CenterHorizontally,
+                ) {
+                    Text("Camera permission is required to scan QR codes.")
+                    Spacer(modifier = Modifier.height(16.dp))
+                    Button(onClick = { permissionLauncher.launch(Manifest.permission.CAMERA) }) {
+                        Text("Grant Permission")
+                    }
+                }
+            }
+        }
+    }
+}

package/android/src/main/kotlin/com/sigx/devclient/DevSettings.kt

@@ -0,0 +1,61 @@
+package com.sigx.devclient
+
+import android.content.Context
+import android.content.SharedPreferences
+
+/**
+ * Persists dev mode preferences across app restarts.
+ */
+class DevSettings(context: Context) {
+
+    private val prefs: SharedPreferences =
+        context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+
+    var perfHudEnabled: Boolean
+        get() = prefs.getBoolean(KEY_PERF_HUD, false)
+        set(value) = prefs.edit().putBoolean(KEY_PERF_HUD, value).apply()
+
+    var logBoxEnabled: Boolean
+        get() = prefs.getBoolean(KEY_LOGBOX, true)
+        set(value) = prefs.edit().putBoolean(KEY_LOGBOX, value).apply()
+
+    var lastConnectedUrl: String
+        get() = prefs.getString(KEY_LAST_URL, "") ?: ""
+        set(value) = prefs.edit().putString(KEY_LAST_URL, value).apply()
+
+    /** History of dev-server URLs the user has connected to from `DevHomeScreen`, most-recent first. */
+    val recentUrls: List<String>
+        get() {
+            val raw = prefs.getString(KEY_RECENT_URLS, null) ?: return emptyList()
+            return raw.split('\n').filter { it.isNotBlank() }
+        }
+
+    /** Insert `url` at the front, dedup, trim to the cap, and update lastConnectedUrl. */
+    fun addRecentUrl(url: String) {
+        val trimmed = url.trim()
+        if (trimmed.isBlank()) return
+        val updated = (listOf(trimmed) + recentUrls.filter { it != trimmed }).take(RECENT_URLS_MAX)
+        prefs.edit()
+            .putString(KEY_RECENT_URLS, updated.joinToString("\n"))
+            .putString(KEY_LAST_URL, trimmed)
+            .apply()
+    }
+
+    fun removeRecentUrl(url: String) {
+        val updated = recentUrls.filter { it != url }
+        prefs.edit().putString(KEY_RECENT_URLS, updated.joinToString("\n")).apply()
+    }
+
+    fun clearRecentUrls() {
+        prefs.edit().remove(KEY_RECENT_URLS).apply()
+    }
+
+    companion object {
+        private const val PREFS_NAME = "sigx_dev_client"
+        private const val KEY_PERF_HUD = "perf_hud_enabled"
+        private const val KEY_LOGBOX = "logbox_enabled"
+        private const val KEY_LAST_URL = "last_connected_url"
+        private const val KEY_RECENT_URLS = "recent_urls"
+        private const val RECENT_URLS_MAX = 20
+    }
+}

package/android/src/main/kotlin/com/sigx/devclient/DevTemplateProvider.kt

@@ -0,0 +1,76 @@
+package com.sigx.devclient
+
+import android.content.Context
+import android.util.Log
+import com.lynx.tasm.provider.AbsTemplateProvider
+import java.io.ByteArrayOutputStream
+import java.net.HttpURLConnection
+import java.net.URL
+
+private const val TAG = "SigxDevClient"
+
+/**
+ * Loads Lynx bundles from HTTP URLs (dev server) or assets (production).
+ */
+class DevTemplateProvider(context: Context) : AbsTemplateProvider() {
+
+    private val appContext: Context = context.applicationContext
+
+    override fun loadTemplate(uri: String, callback: Callback) {
+        Log.d(TAG, "Loading template: $uri")
+        Thread {
+            try {
+                if (uri.startsWith("http://") || uri.startsWith("https://")) {
+                    loadFromUrl(uri, callback)
+                } else {
+                    loadFromAssets(uri, callback)
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to load template: $uri", e)
+                callback.onFailed(e.message ?: "Unknown error loading template")
+            }
+        }.start()
+    }
+
+    private fun loadFromUrl(urlString: String, callback: Callback) {
+        val url = URL(urlString)
+        val connection = url.openConnection() as HttpURLConnection
+        try {
+            connection.connectTimeout = 10_000
+            connection.readTimeout = 30_000
+            connection.requestMethod = "GET"
+
+            if (connection.responseCode != HttpURLConnection.HTTP_OK) {
+                Log.e(TAG, "Template fetch failed: HTTP ${connection.responseCode} from $urlString")
+                callback.onFailed("HTTP ${connection.responseCode}: ${connection.responseMessage}")
+                return
+            }
+
+            connection.inputStream.use { inputStream ->
+                ByteArrayOutputStream().use { output ->
+                    val buffer = ByteArray(8192)
+                    var length: Int
+                    while (inputStream.read(buffer).also { length = it } != -1) {
+                        output.write(buffer, 0, length)
+                    }
+                    callback.onSuccess(output.toByteArray())
+                }
+            }
+        } finally {
+            connection.disconnect()
+        }
+    }
+
+    private fun loadFromAssets(uri: String, callback: Callback) {
+        appContext.assets.open(uri).use { inputStream ->
+            ByteArrayOutputStream().use { output ->
+                val buffer = ByteArray(8192)
+                var length: Int
+                while (inputStream.read(buffer).also { length = it } != -1) {
+                    output.write(buffer, 0, length)
+                }
+                callback.onSuccess(output.toByteArray())
+            }
+        }
+    }
+}

package/android/src/main/kotlin/com/sigx/devclient/DevTemplateResourceFetcher.kt

@@ -0,0 +1,113 @@
+package com.sigx.devclient
+
+import android.content.Context
+import android.util.Log
+import com.lynx.tasm.resourceprovider.LynxResourceCallback
+import com.lynx.tasm.resourceprovider.LynxResourceRequest
+import com.lynx.tasm.resourceprovider.LynxResourceResponse
+import com.lynx.tasm.resourceprovider.template.LynxTemplateResourceFetcher
+import com.lynx.tasm.resourceprovider.template.TemplateProviderResult
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import java.io.IOException
+import java.util.concurrent.TimeUnit
+
+/**
+ * Handles template and HMR hot-update fetching for LynxView.
+ * Required for HMR to work — the AbsTemplateProvider only handles initial loads.
+ */
+@Suppress("UNCHECKED_CAST")
+class DevTemplateResourceFetcher(context: Context) : LynxTemplateResourceFetcher() {
+
+    private val appContext: Context = context.applicationContext
+
+    private val httpClient = OkHttpClient.Builder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .build()
+
+    override fun fetchTemplate(
+        request: LynxResourceRequest,
+        callback: LynxResourceCallback<TemplateProviderResult>
+    ) {
+        if (request == null) {
+            callback.onResponse(failed("request is null"))
+            return
+        }
+
+        val url = request.url
+        if (url.startsWith("file://") || (!url.startsWith("http://") && !url.startsWith("https://"))) {
+            fetchFromAssets(url.removePrefix("file://"), callback)
+            return
+        }
+
+        val httpRequest = Request.Builder().url(url).build()
+        httpClient.newCall(httpRequest).enqueue(object : Callback {
+            override fun onResponse(call: Call, response: Response) {
+                response.use {
+                    if (it.isSuccessful && it.body != null) {
+                        val bytes = it.body!!.bytes()
+                        val result = TemplateProviderResult.fromBinary(bytes)
+                        callback.onResponse(LynxResourceResponse.onSuccess(result))
+                    } else {
+                        callback.onResponse(failed("HTTP ${it.code}: ${it.message}"))
+                    }
+                }
+            }
+
+            override fun onFailure(call: Call, e: IOException) {
+                Log.e("SigxDevClient", "Template resource fetch failed: ${request.url}", e)
+                callback.onResponse(failed(e))
+            }
+        })
+    }
+
+    override fun fetchSSRData(
+        request: LynxResourceRequest,
+        callback: LynxResourceCallback<ByteArray>
+    ) {
+        if (request == null) {
+            callback.onResponse(failed("request is null"))
+            return
+        }
+
+        val httpRequest = Request.Builder().url(request.url).build()
+        httpClient.newCall(httpRequest).enqueue(object : Callback {
+            override fun onResponse(call: Call, response: Response) {
+                response.use {
+                    if (it.isSuccessful && it.body != null) {
+                        callback.onResponse(LynxResourceResponse.onSuccess(it.body!!.bytes()))
+                    } else {
+                        callback.onResponse(failed("HTTP ${it.code}: ${it.message}"))
+                    }
+                }
+            }
+
+            override fun onFailure(call: Call, e: IOException) {
+                callback.onResponse(failed(e))
+            }
+        })
+    }
+
+    private fun fetchFromAssets(
+        path: String,
+        callback: LynxResourceCallback<TemplateProviderResult>
+    ) {
+        try {
+            val bytes = appContext.assets.open(path).use { it.readBytes() }
+            val result = TemplateProviderResult.fromBinary(bytes)
+            callback.onResponse(LynxResourceResponse.onSuccess(result))
+        } catch (e: Exception) {
+            callback.onResponse(failed(e))
+        }
+    }
+
+    private fun <T> failed(message: String): LynxResourceResponse<T> =
+        LynxResourceResponse.onFailed(Throwable(message)) as LynxResourceResponse<T>
+
+    private fun <T> failed(e: Throwable): LynxResourceResponse<T> =
+        LynxResourceResponse.onFailed(e) as LynxResourceResponse<T>
+}