*: that's me, I'm a Monarch butterfly now

.idea/.name

···
-Jerry No
+Monarch

app/build.gradle.kts

···
 }
 
 android {
-    namespace = "industries.geesawra.jerryno"
+    namespace = "industries.geesawra.monarch"
     compileSdk = 36
 
     defaultConfig {
-        applicationId = "industries.geesawra.jerryno"
+        applicationId = "industries.geesawra.monarch"
         minSdk = 36
         targetSdk = 36
         versionCode = 1

app/src/androidTest/java/industries/geesawra/jerryno/ExampleInstrumentedTest.kt app/src/androidTest/java/industries/geesawra/monarch/ExampleInstrumentedTest.kt

···
-package industries.geesawra.jerryno
+package industries.geesawra.monarch
 
-import androidx.test.platform.app.InstrumentationRegistry
 import androidx.test.ext.junit.runners.AndroidJUnit4
-
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Assert.assertEquals
 import org.junit.Test
 import org.junit.runner.RunWith
-
-import org.junit.Assert.*
 
 /**
  * Instrumented test, which will execute on an Android device.
···
     fun useAppContext() {
         // Context of the app under test.
         val appContext = InstrumentationRegistry.getInstrumentation().targetContext
-        assertEquals("industries.geesawra.jerryno", appContext.packageName)
+        assertEquals("industries.geesawra.monarch", appContext.packageName)
     }
 }

app/src/main/AndroidManifest.xml

···
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
-        android:screenOrientation="portrait"
         android:supportsRtl="true"
-        android:theme="@style/Theme.JerryNo">
+        android:theme="@style/Theme.Monarch">
         <activity
             android:name=".MainActivity"
             android:exported="true"
-            android:theme="@style/Theme.JerryNo"
+            android:theme="@style/Theme.Monarch"
             android:windowSoftInputMode="adjustResize">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />

app/src/main/java/industries/geesawra/jerryno/ComposeView.kt app/src/main/java/industries/geesawra/monarch/ComposeView.kt

···
-package industries.geesawra.jerryno
-
-import android.content.Context
-import android.net.Uri
-import android.widget.Toast
-import androidx.activity.compose.ManagedActivityResultLauncher
-import androidx.activity.compose.rememberLauncherForActivityResult
-import androidx.activity.result.PickVisualMediaRequest
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.ExperimentalFoundationApi
-import androidx.compose.foundation.ScrollState
-import androidx.compose.foundation.background
-import androidx.compose.foundation.content.MediaType
-import androidx.compose.foundation.content.ReceiveContentListener
-import androidx.compose.foundation.content.consume
-import androidx.compose.foundation.content.contentReceiver
-import androidx.compose.foundation.content.hasMediaType
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.WindowInsets
-import androidx.compose.foundation.layout.add
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.heightIn
-import androidx.compose.foundation.layout.ime
-import androidx.compose.foundation.layout.navigationBars
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.windowInsetsPadding
-import androidx.compose.foundation.text.input.TextFieldLineLimits
-import androidx.compose.foundation.text.input.clearText
-import androidx.compose.foundation.text.input.rememberTextFieldState
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.automirrored.filled.Send
-import androidx.compose.material.icons.filled.CameraRoll
-import androidx.compose.material3.BottomSheetScaffoldState
-import androidx.compose.material3.Button
-import androidx.compose.material3.ButtonDefaults
-import androidx.compose.material3.Card
-import androidx.compose.material3.CircularProgressIndicator
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.OutlinedCard
-import androidx.compose.material3.OutlinedTextField
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.MutableState
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalSoftwareKeyboardController
-import androidx.compose.ui.unit.dp
-import industries.geesawra.jerryno.datalayer.SkeetData
-import industries.geesawra.jerryno.datalayer.TimelineViewModel
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
-
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
-@Composable
-fun ComposeView(
-    context: Context,
-    coroutineScope: CoroutineScope,
-    timelineViewModel: TimelineViewModel,
-    inReplyTo: MutableState<SkeetData?>,
-    scaffoldState: BottomSheetScaffoldState,
-    scrollState: ScrollState
-) {
-    val focusRequester = remember { FocusRequester() }
-    val keyboardController = LocalSoftwareKeyboardController.current
-    val charCount = remember { mutableIntStateOf(0) }
-    val wasEdited = remember { mutableStateOf(false) }
-    val maxChars = 300
-    val composeFieldState = rememberTextFieldState(
-        ""
-    )
-    val mediaSelected = remember { mutableStateOf(mapOf<Uri, String?>()) }
-    val mediaSelectedIsVideo = remember { mutableStateOf(false) }
-
-    LaunchedEffect(scaffoldState.bottomSheetState.isVisible) {
-        if (scaffoldState.bottomSheetState.isVisible) {
-            keyboardController?.show()
-            focusRequester.requestFocus()
-        } else {
-            keyboardController?.hide()
-            // Reset state when sheet is hidden
-            composeFieldState.clearText()
-            charCount.intValue = 0
-            inReplyTo.value = null
-            mediaSelected.value = mapOf()
-            mediaSelectedIsVideo.value = false
-
-        }
-    }
-
-    // Remember the ReceiveContentListener object as it is created inside a Composable scope
-    val receiveContentListener = remember {
-        ReceiveContentListener { transferableContent ->
-            when (transferableContent.hasMediaType(MediaType.Image)) {
-                true -> transferableContent.consume {
-                    val uri = it.uri
-                    val mimeType: String? = context.contentResolver.getType(uri)
-                    mediaSelected.value = mapOf(Pair(uri, mimeType))
-                    true
-                }
-
-
-                false -> transferableContent
-            }
-        }
-    }
-
-
-    val pickMedia =
-        rememberLauncherForActivityResult(ActivityResultContracts.PickMultipleVisualMedia(maxItems = 4)) { uris ->
-            if (uris.isEmpty()) {
-                return@rememberLauncherForActivityResult
-            }
-
-            val urisMap = uris.associateWith { uri ->
-                val mimeType: String? = context.contentResolver.getType(uri)
-                mimeType?.let {
-                    if (it.startsWith("image/")) {
-                        return@associateWith "image"
-                    } else if (it.startsWith("video/")) {
-                        return@associateWith "video"
-                    }
-                }
-                null
-            }
-
-            val containsVideo = urisMap.values.any { it == "video" }
-
-            if (urisMap.size > 1 && containsVideo) {
-                Toast.makeText(
-                    context,
-                    "Can only post up to 1 video or 4 pictures. Video cannot be mixed with other media.",
-                    Toast.LENGTH_LONG
-                ).show()
-                return@rememberLauncherForActivityResult
-            }
-            if (containsVideo && urisMap.any { it.value == "image" }) {
-                Toast.makeText(
-                    context,
-                    "Video cannot be mixed with other media.",
-                    Toast.LENGTH_LONG
-                ).show()
-                return@rememberLauncherForActivityResult
-            }
-
-            mediaSelectedIsVideo.value = containsVideo && urisMap.size == 1
-            mediaSelected.value = urisMap.filterValues { it != null }
-        }
-
-    val uploadingPost = remember { mutableStateOf(false) }
-
-    // Outer Box: Handles IME padding and general content padding for the whole sheet content
-    Box(
-        modifier = Modifier
-            .fillMaxWidth() // Takes full width of the bottom sheet
-            .windowInsetsPadding(WindowInsets.ime.add(WindowInsets.navigationBars))
-            .verticalScroll(scrollState)
-            .padding(16.dp) // General padding around all content inside the sheet
-    ) {
-        // Inner Box: Fills the space provided by Outer Box, used for layering scrollable content and fixed buttons
-        Box(modifier = Modifier.fillMaxSize()) {
-            // Scrollable Content Column
-            Column(
-                modifier = Modifier
-                    .fillMaxWidth(), // Takes full width of the Inner Box
-                horizontalAlignment = Alignment.CenterHorizontally
-            ) {
-                Row {
-                    Text(
-                        "New Post",
-                        style = MaterialTheme.typography.titleLarge,
-                        modifier = Modifier.padding(bottom = 16.dp)
-                    )
-                }
-
-                inReplyTo.value?.let {
-                    OutlinedCard(
-                        modifier = Modifier.padding(8.dp)
-                    ) {
-                        SkeetView(
-                            modifier = Modifier
-                                .padding(8.dp)
-                                .background(Color.Transparent),
-                            skeet = it,
-                            nested = true,
-                            disableEmbeds = true
-                        )
-                    }
-                }
-
-                LaunchedEffect(composeFieldState.text) {
-                    if (composeFieldState.text.isEmpty()) {
-                        wasEdited.value = false
-                    } else {
-                        wasEdited.value = true
-                        charCount.intValue = composeFieldState.text.length
-                    }
-                }
-
-                OutlinedTextField(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .heightIn(min = 250.dp)
-                        .focusRequester(focusRequester)
-                        .contentReceiver(receiveContentListener),
-                    label = {
-                        if (wasEdited.value) {
-                            Text(
-                                text = "${maxChars - charCount.intValue}",
-                                color = if (composeFieldState.text.length > maxChars) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurface
-                            )
-                        } else {
-                            Text(
-                                text = "Less cringe this time, okay?",
-                            )
-                        }
-                    },
-                    isError = composeFieldState.text.length > maxChars,
-                    lineLimits = TextFieldLineLimits.MultiLine(maxHeightInLines = 10),
-                    state = composeFieldState
-                )
-
-                ActionRow(
-                    context,
-                    uploadingPost,
-                    pickMedia,
-                    composeFieldState.text.toString(),
-                    mediaSelected,
-                    mediaSelectedIsVideo,
-                    coroutineScope,
-                    maxChars,
-                    timelineViewModel,
-                    scaffoldState,
-                    inReplyTo.value
-                )
-
-                Spacer(modifier = Modifier.height(8.dp))
-
-                if (mediaSelected.value.isNotEmpty()) {
-                    Card(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(vertical = 8.dp)
-                    ) {
-                        PostImageGallery(
-                            modifier = Modifier
-                                .fillMaxWidth() // Gallery should fill card width
-                                .padding(8.dp),
-                            images = mediaSelected.value.keys.map { uri ->
-                                Image(url = uri.toString(), alt = "Selected media")
-                            },
-                        )
-                    }
-                }
-
-                // Spacer at the end of scrollable content to prevent overlap with fixed buttons
-                Spacer(modifier = Modifier.height(80.dp))
-            }
-        }
-    }
-}
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun ActionRow(
-    context: Context,
-    uploadingPost: MutableState<Boolean>,
-    pickMedia: ManagedActivityResultLauncher<PickVisualMediaRequest, List<@JvmSuppressWildcards Uri>>,
-    postText: String,
-    mediaSelected: MutableState<Map<Uri, String?>>,
-    mediaSelectedIsVideo: MutableState<Boolean>,
-    coroutineScope: CoroutineScope,
-    maxChars: Int,
-    timelineViewModel: TimelineViewModel,
-    scaffoldState: BottomSheetScaffoldState,
-    inReplyToData: SkeetData? = null
-) {
-
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(
-                vertical = 8.dp,
-            ), // Internal padding for the button row
-        horizontalArrangement = Arrangement.SpaceBetween,
-        verticalAlignment = Alignment.CenterVertically
-    ) {
-        TextButton(
-            onClick = {
-                pickMedia.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.ImageAndVideo))
-            }
-        ) {
-            Icon(Icons.Default.CameraRoll, contentDescription = "Attach media")
-        }
-
-        if (uploadingPost.value) {
-            CircularProgressIndicator()
-        }
-
-        val postButtonEnabled = remember(postText, mediaSelected.value) {
-            (postText.isNotBlank() || mediaSelected.value.isNotEmpty()) && postText.length <= maxChars
-        }
-
-        Button(
-            onClick = {
-                if (postText.isNotBlank() && postText.length <= maxChars) {
-                    coroutineScope.launch {
-                        uploadingPost.value = true // Show progress immediately
-                        timelineViewModel.post(
-                            content = postText,
-                            images = if (!mediaSelectedIsVideo.value) mediaSelected.value.keys.toList()
-                                .ifEmpty { null } else null,
-                            video = if (mediaSelectedIsVideo.value) mediaSelected.value.keys.firstOrNull() else null,
-                            replyRef = inReplyToData?.replyRef(),
-                        ).onSuccess {
-                            coroutineScope.launch {
-                                scaffoldState.bottomSheetState.hide()
-                                // State reset is now in LaunchedEffect for isVisible
-                            }
-                        }.onFailure {
-                            Toast.makeText(
-                                context,
-                                "Could not post: ${it.message}",
-                                Toast.LENGTH_LONG
-                            ).show()
-                        }.also {
-                            uploadingPost.value = false // Hide progress after completion
-                        }
-                    }
-                }
-            },
-            modifier = Modifier.padding(end = 8.dp),
-            enabled = postButtonEnabled && !uploadingPost.value // Disable while uploading
-        ) {
-            Icon(Icons.AutoMirrored.Filled.Send, contentDescription = "Post")
-            Spacer(Modifier.size(ButtonDefaults.IconSpacing))
-            Text("Skeet")
-        }
-    }
+package industries.geesawra.monarch
+
+import android.content.Context
+import android.net.Uri
+import android.widget.Toast
+import androidx.activity.compose.ManagedActivityResultLauncher
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.PickVisualMediaRequest
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.ScrollState
+import androidx.compose.foundation.background
+import androidx.compose.foundation.content.MediaType
+import androidx.compose.foundation.content.ReceiveContentListener
+import androidx.compose.foundation.content.consume
+import androidx.compose.foundation.content.contentReceiver
+import androidx.compose.foundation.content.hasMediaType
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.add
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.ime
+import androidx.compose.foundation.layout.navigationBars
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.windowInsetsPadding
+import androidx.compose.foundation.text.input.TextFieldLineLimits
+import androidx.compose.foundation.text.input.clearText
+import androidx.compose.foundation.text.input.rememberTextFieldState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.Send
+import androidx.compose.material.icons.filled.CameraRoll
+import androidx.compose.material3.BottomSheetScaffoldState
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Card
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedCard
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.unit.dp
+import industries.geesawra.monarch.datalayer.SkeetData
+import industries.geesawra.monarch.datalayer.TimelineViewModel
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
+@Composable
+fun ComposeView(
+    context: Context,
+    coroutineScope: CoroutineScope,
+    timelineViewModel: TimelineViewModel,
+    inReplyTo: MutableState<SkeetData?>,
+    scaffoldState: BottomSheetScaffoldState,
+    scrollState: ScrollState
+) {
+    val focusRequester = remember { FocusRequester() }
+    val keyboardController = LocalSoftwareKeyboardController.current
+    val charCount = remember { mutableIntStateOf(0) }
+    val wasEdited = remember { mutableStateOf(false) }
+    val maxChars = 300
+    val composeFieldState = rememberTextFieldState(
+        ""
+    )
+    val mediaSelected = remember { mutableStateOf(mapOf<Uri, String?>()) }
+    val mediaSelectedIsVideo = remember { mutableStateOf(false) }
+
+    LaunchedEffect(scaffoldState.bottomSheetState.isVisible) {
+        if (scaffoldState.bottomSheetState.isVisible) {
+            keyboardController?.show()
+            focusRequester.requestFocus()
+        } else {
+            keyboardController?.hide()
+            // Reset state when sheet is hidden
+            composeFieldState.clearText()
+            charCount.intValue = 0
+            inReplyTo.value = null
+            mediaSelected.value = mapOf()
+            mediaSelectedIsVideo.value = false
+
+        }
+    }
+
+    // Remember the ReceiveContentListener object as it is created inside a Composable scope
+    val receiveContentListener = remember {
+        ReceiveContentListener { transferableContent ->
+            when (transferableContent.hasMediaType(MediaType.Image)) {
+                true -> transferableContent.consume {
+                    val uri = it.uri
+                    val mimeType: String? = context.contentResolver.getType(uri)
+                    mediaSelected.value = mapOf(Pair(uri, mimeType))
+                    true
+                }
+
+
+                false -> transferableContent
+            }
+        }
+    }
+
+
+    val pickMedia =
+        rememberLauncherForActivityResult(ActivityResultContracts.PickMultipleVisualMedia(maxItems = 4)) { uris ->
+            if (uris.isEmpty()) {
+                return@rememberLauncherForActivityResult
+            }
+
+            val urisMap = uris.associateWith { uri ->
+                val mimeType: String? = context.contentResolver.getType(uri)
+                mimeType?.let {
+                    if (it.startsWith("image/")) {
+                        return@associateWith "image"
+                    } else if (it.startsWith("video/")) {
+                        return@associateWith "video"
+                    }
+                }
+                null
+            }
+
+            val containsVideo = urisMap.values.any { it == "video" }
+
+            if (urisMap.size > 1 && containsVideo) {
+                Toast.makeText(
+                    context,
+                    "Can only post up to 1 video or 4 pictures. Video cannot be mixed with other media.",
+                    Toast.LENGTH_LONG
+                ).show()
+                return@rememberLauncherForActivityResult
+            }
+            if (containsVideo && urisMap.any { it.value == "image" }) {
+                Toast.makeText(
+                    context,
+                    "Video cannot be mixed with other media.",
+                    Toast.LENGTH_LONG
+                ).show()
+                return@rememberLauncherForActivityResult
+            }
+
+            mediaSelectedIsVideo.value = containsVideo && urisMap.size == 1
+            mediaSelected.value = urisMap.filterValues { it != null }
+        }
+
+    val uploadingPost = remember { mutableStateOf(false) }
+
+    // Outer Box: Handles IME padding and general content padding for the whole sheet content
+    Box(
+        modifier = Modifier
+            .fillMaxWidth() // Takes full width of the bottom sheet
+            .windowInsetsPadding(WindowInsets.ime.add(WindowInsets.navigationBars))
+            .verticalScroll(scrollState)
+            .padding(16.dp) // General padding around all content inside the sheet
+    ) {
+        // Inner Box: Fills the space provided by Outer Box, used for layering scrollable content and fixed buttons
+        Box(modifier = Modifier.fillMaxSize()) {
+            // Scrollable Content Column
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth(), // Takes full width of the Inner Box
+                horizontalAlignment = Alignment.CenterHorizontally
+            ) {
+                Row {
+                    Text(
+                        "New Post",
+                        style = MaterialTheme.typography.titleLarge,
+                        modifier = Modifier.padding(bottom = 16.dp)
+                    )
+                }
+
+                inReplyTo.value?.let {
+                    OutlinedCard(
+                        modifier = Modifier.padding(8.dp)
+                    ) {
+                        SkeetView(
+                            modifier = Modifier
+                                .padding(8.dp)
+                                .background(Color.Transparent),
+                            skeet = it,
+                            nested = true,
+                            disableEmbeds = true
+                        )
+                    }
+                }
+
+                LaunchedEffect(composeFieldState.text) {
+                    if (composeFieldState.text.isEmpty()) {
+                        wasEdited.value = false
+                    } else {
+                        wasEdited.value = true
+                        charCount.intValue = composeFieldState.text.length
+                    }
+                }
+
+                OutlinedTextField(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .heightIn(min = 250.dp)
+                        .focusRequester(focusRequester)
+                        .contentReceiver(receiveContentListener),
+                    label = {
+                        if (wasEdited.value) {
+                            Text(
+                                text = "${maxChars - charCount.intValue}",
+                                color = if (composeFieldState.text.length > maxChars) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurface
+                            )
+                        } else {
+                            Text(
+                                text = "Less cringe this time, okay?",
+                            )
+                        }
+                    },
+                    isError = composeFieldState.text.length > maxChars,
+                    lineLimits = TextFieldLineLimits.MultiLine(maxHeightInLines = 10),
+                    state = composeFieldState
+                )
+
+                ActionRow(
+                    context,
+                    uploadingPost,
+                    pickMedia,
+                    composeFieldState.text.toString(),
+                    mediaSelected,
+                    mediaSelectedIsVideo,
+                    coroutineScope,
+                    maxChars,
+                    timelineViewModel,
+                    scaffoldState,
+                    inReplyTo.value
+                )
+
+                Spacer(modifier = Modifier.height(8.dp))
+
+                if (mediaSelected.value.isNotEmpty()) {
+                    Card(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(vertical = 8.dp)
+                    ) {
+                        PostImageGallery(
+                            modifier = Modifier
+                                .fillMaxWidth() // Gallery should fill card width
+                                .padding(8.dp),
+                            images = mediaSelected.value.keys.map { uri ->
+                                Image(url = uri.toString(), alt = "Selected media")
+                            },
+                        )
+                    }
+                }
+
+                // Spacer at the end of scrollable content to prevent overlap with fixed buttons
+                Spacer(modifier = Modifier.height(80.dp))
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun ActionRow(
+    context: Context,
+    uploadingPost: MutableState<Boolean>,
+    pickMedia: ManagedActivityResultLauncher<PickVisualMediaRequest, List<@JvmSuppressWildcards Uri>>,
+    postText: String,
+    mediaSelected: MutableState<Map<Uri, String?>>,
+    mediaSelectedIsVideo: MutableState<Boolean>,
+    coroutineScope: CoroutineScope,
+    maxChars: Int,
+    timelineViewModel: TimelineViewModel,
+    scaffoldState: BottomSheetScaffoldState,
+    inReplyToData: SkeetData? = null
+) {
+
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(
+                vertical = 8.dp,
+            ), // Internal padding for the button row
+        horizontalArrangement = Arrangement.SpaceBetween,
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        TextButton(
+            onClick = {
+                pickMedia.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.ImageAndVideo))
+            }
+        ) {
+            Icon(Icons.Default.CameraRoll, contentDescription = "Attach media")
+        }
+
+        if (uploadingPost.value) {
+            CircularProgressIndicator()
+        }
+
+        val postButtonEnabled = remember(postText, mediaSelected.value) {
+            (postText.isNotBlank() || mediaSelected.value.isNotEmpty()) && postText.length <= maxChars
+        }
+
+        Button(
+            onClick = {
+                if (postText.isNotBlank() && postText.length <= maxChars) {
+                    coroutineScope.launch {
+                        uploadingPost.value = true // Show progress immediately
+                        timelineViewModel.post(
+                            content = postText,
+                            images = if (!mediaSelectedIsVideo.value) mediaSelected.value.keys.toList()
+                                .ifEmpty { null } else null,
+                            video = if (mediaSelectedIsVideo.value) mediaSelected.value.keys.firstOrNull() else null,
+                            replyRef = inReplyToData?.replyRef(),
+                        ).onSuccess {
+                            coroutineScope.launch {
+                                scaffoldState.bottomSheetState.hide()
+                                // State reset is now in LaunchedEffect for isVisible
+                            }
+                        }.onFailure {
+                            Toast.makeText(
+                                context,
+                                "Could not post: ${it.message}",
+                                Toast.LENGTH_LONG
+                            ).show()
+                        }.also {
+                            uploadingPost.value = false // Hide progress after completion
+                        }
+                    }
+                }
+            },
+            modifier = Modifier.padding(end = 8.dp),
+            enabled = postButtonEnabled && !uploadingPost.value // Disable while uploading
+        ) {
+            Icon(Icons.AutoMirrored.Filled.Send, contentDescription = "Post")
+            Spacer(Modifier.size(ButtonDefaults.IconSpacing))
+            Text("Skeet")
+        }
+    }
 }

app/src/main/java/industries/geesawra/jerryno/GalleryViewer.kt app/src/main/java/industries/geesawra/monarch/GalleryViewer.kt

···
-package industries.geesawra.jerryno
+package industries.geesawra.monarch
 
 import android.content.Context
 import android.widget.Toast

app/src/main/java/industries/geesawra/jerryno/LoginView.kt app/src/main/java/industries/geesawra/monarch/LoginView.kt

···
-package industries.geesawra.jerryno
+package industries.geesawra.monarch
 
 import android.util.Log
 import android.widget.Toast
···
 import androidx.compose.ui.text.input.PasswordVisualTransformation
 import androidx.compose.ui.text.input.VisualTransformation
 import androidx.compose.ui.unit.dp
-import industries.geesawra.jerryno.datalayer.BlueskyConn
+import industries.geesawra.monarch.datalayer.BlueskyConn
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch

app/src/main/java/industries/geesawra/jerryno/MainActivity.kt app/src/main/java/industries/geesawra/monarch/MainActivity.kt

···
-package industries.geesawra.jerryno
+package industries.geesawra.monarch
 
 import android.app.Application
 import android.os.Bundle
···
 import coil3.network.okhttp.OkHttpNetworkFetcherFactory
 import dagger.hilt.android.AndroidEntryPoint
 import dagger.hilt.android.HiltAndroidApp
-import industries.geesawra.jerryno.datalayer.BlueskyConn
-import industries.geesawra.jerryno.datalayer.TimelineViewModel
-import industries.geesawra.jerryno.ui.theme.JerryNoTheme
+import industries.geesawra.monarch.datalayer.BlueskyConn
+import industries.geesawra.monarch.datalayer.TimelineViewModel
+import industries.geesawra.monarch.ui.theme.MonarchTheme
 
 
 @HiltAndroidApp
···
 
 
         setContent {
-            JerryNoTheme {
+            MonarchTheme {
                 val context = LocalContext.current
                 SingletonImageLoader.setSafe {
                     ImageLoader.Builder(context)

app/src/main/java/industries/geesawra/jerryno/PostImageGallery.kt app/src/main/java/industries/geesawra/monarch/PostImageGallery.kt

···
-package industries.geesawra.jerryno
+package industries.geesawra.monarch
 
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement

app/src/main/java/industries/geesawra/jerryno/ShowSkeets.kt app/src/main/java/industries/geesawra/monarch/ShowSkeets.kt

···
-package industries.geesawra.jerryno
+package industries.geesawra.monarch
 
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
···
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
-import industries.geesawra.jerryno.datalayer.SkeetData
-import industries.geesawra.jerryno.datalayer.TimelineViewModel
+import industries.geesawra.monarch.datalayer.SkeetData
+import industries.geesawra.monarch.datalayer.TimelineViewModel
 
 @Composable
 fun ShowSkeets(

app/src/main/java/industries/geesawra/jerryno/SkeetView.kt app/src/main/java/industries/geesawra/monarch/SkeetView.kt

···
-package industries.geesawra.jerryno
+package industries.geesawra.monarch
 
 import androidx.browser.customtabs.CustomTabsIntent
 import androidx.compose.foundation.clickable
···
 import coil3.compose.AsyncImage
 import coil3.request.ImageRequest
 import coil3.request.crossfade
-import industries.geesawra.jerryno.datalayer.SkeetData
-import industries.geesawra.jerryno.datalayer.TimelineViewModel
+import industries.geesawra.monarch.datalayer.SkeetData
+import industries.geesawra.monarch.datalayer.TimelineViewModel
 import io.sanghun.compose.video.RepeatMode
 import io.sanghun.compose.video.VideoPlayer
 import io.sanghun.compose.video.controller.VideoPlayerControllerConfig

app/src/main/java/industries/geesawra/jerryno/TimelinePostActionsView.kt app/src/main/java/industries/geesawra/monarch/TimelinePostActionsView.kt

···
-package industries.geesawra.jerryno
-
-import android.content.Intent
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.automirrored.filled.Reply
-import androidx.compose.material.icons.automirrored.filled.ReplyAll
-import androidx.compose.material.icons.filled.Repeat
-import androidx.compose.material.icons.filled.RepeatOn
-import androidx.compose.material.icons.filled.Share
-import androidx.compose.material.icons.filled.ThumbUp
-import androidx.compose.material.icons.filled.ThumbUpOffAlt
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.MutableLongState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableLongStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.unit.dp
-import androidx.core.net.toUri
-import industries.geesawra.jerryno.datalayer.SkeetData
-import industries.geesawra.jerryno.datalayer.TimelineViewModel
-import sh.christian.ozone.api.AtUri
-import sh.christian.ozone.api.RKey
-
-
-@Composable
-private fun IconWithNumber(
-    imageVector: ImageVector,
-    contentDescription: String,
-    number: MutableLongState,
-    tint: Color
-) {
-    Row(
-        horizontalArrangement = Arrangement.Center,
-        verticalAlignment = Alignment.CenterVertically
-    ) {
-        var fontSize by remember {
-            mutableStateOf(10.dp)
-        }
-        Icon(
-            imageVector,
-            contentDescription = contentDescription,
-            modifier = Modifier.size(15.dp),
-            tint = tint
-        )
-        Text(
-            modifier = Modifier.padding(start = 2.dp),
-            text = number.longValue.toString(),
-            color = tint,
-            maxLines = 1,
-            onTextLayout = { textLayout ->
-                if (textLayout.multiParagraph.didExceedMaxLines) {
-                    fontSize -= 1.dp
-                }
-            }
-        )
-    }
-}
-
-fun AtUri.rkey(): RKey {
-    return RKey(this.atUri.toUri().lastPathSegment!!)
-}
-
-@Composable
-fun TimelinePostActionsView(
-    modifier: Modifier = Modifier,
-    timelineViewModel: TimelineViewModel?,
-    onReplyTap: (SkeetData) -> Unit = {},
-    skeet: SkeetData
-) {
-    val likes = remember { mutableLongStateOf(skeet.likes ?: 0) }
-    val reposts = remember { mutableLongStateOf(skeet.reposts ?: 0) }
-    val replies = remember { mutableLongStateOf(skeet.replies ?: 0) }
-
-
-    Row(
-        horizontalArrangement = Arrangement.End,
-        modifier = modifier,
-    ) {
-        val ctx = LocalContext.current
-        IconButton(
-            onClick = {
-                val sendIntent: Intent = Intent().apply {
-                    action = Intent.ACTION_SEND
-                    type = "text/plain"
-                    putExtra(Intent.EXTRA_TEXT, skeet.shareURL())
-                }
-                ctx.startActivity(
-                    Intent.createChooser(sendIntent, "Share Bluesky post")
-                )
-            }
-        ) {
-            Icon(
-                modifier = Modifier.size(15.dp),
-                imageVector = Icons.Default.Share,
-                contentDescription = "Share",
-                tint = MaterialTheme.colorScheme.onSurfaceVariant
-            )
-        }
-
-        IconButton(
-            onClick = {
-                onReplyTap(skeet)
-            }
-        ) {
-            IconWithNumber(
-                imageVector = {
-                    if (replies.longValue == 0.toLong()) {
-                        Icons.AutoMirrored.Filled.Reply
-                    }
-
-                    val r = replies
-                    if (r.longValue > 0) {
-                        Icons.AutoMirrored.Filled.ReplyAll
-                    } else {
-                        Icons.AutoMirrored.Filled.Reply
-                    }
-
-                }(),
-                contentDescription = "Reply",
-                number = replies,
-                MaterialTheme.colorScheme.onSurfaceVariant
-            )
-        }
-
-        var isLiked by rememberSaveable { mutableStateOf(skeet.didLike) }
-        IconButton(
-            onClick = {
-                when (isLiked) {
-                    false -> timelineViewModel?.like(skeet.uri, skeet.cid) {
-                        isLiked = true
-                        likes.longValue++
-                    }
-
-                    true -> timelineViewModel?.deleteLike(skeet.cid) {
-                        isLiked = false
-                        likes.longValue--
-                    }
-                }
-            }
-        ) {
-            IconWithNumber(
-                if (isLiked) Icons.Default.ThumbUp else Icons.Default.ThumbUpOffAlt,
-                contentDescription = "Like",
-                number = likes,
-                tint = if (isLiked) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurfaceVariant
-            )
-        }
-
-        var isReposted by rememberSaveable { mutableStateOf(skeet.didRepost) }
-        IconButton(
-            onClick = {
-                when (isReposted) {
-                    false -> timelineViewModel?.repost(skeet.uri, skeet.cid) {
-                        isReposted = true
-                        reposts.longValue++
-                    }
-
-                    true -> timelineViewModel?.deleteRepost(skeet.cid) {
-                        isReposted = false
-                        reposts.longValue--
-                    }
-                }
-
-            }
-        ) {
-            IconWithNumber(
-                if (isReposted) Icons.Default.RepeatOn else Icons.Default.Repeat,
-                contentDescription = "Repost",
-                number = reposts,
-                if (isLiked) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurfaceVariant
-            )
-        }
-    }
+package industries.geesawra.monarch
+
+import android.content.Intent
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.Reply
+import androidx.compose.material.icons.automirrored.filled.ReplyAll
+import androidx.compose.material.icons.filled.Repeat
+import androidx.compose.material.icons.filled.RepeatOn
+import androidx.compose.material.icons.filled.Share
+import androidx.compose.material.icons.filled.ThumbUp
+import androidx.compose.material.icons.filled.ThumbUpOffAlt
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableLongState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableLongStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import androidx.core.net.toUri
+import industries.geesawra.monarch.datalayer.SkeetData
+import industries.geesawra.monarch.datalayer.TimelineViewModel
+import sh.christian.ozone.api.AtUri
+import sh.christian.ozone.api.RKey
+
+
+@Composable
+private fun IconWithNumber(
+    imageVector: ImageVector,
+    contentDescription: String,
+    number: MutableLongState,
+    tint: Color
+) {
+    Row(
+        horizontalArrangement = Arrangement.Center,
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        var fontSize by remember {
+            mutableStateOf(10.dp)
+        }
+        Icon(
+            imageVector,
+            contentDescription = contentDescription,
+            modifier = Modifier.size(15.dp),
+            tint = tint
+        )
+        Text(
+            modifier = Modifier.padding(start = 2.dp),
+            text = number.longValue.toString(),
+            color = tint,
+            maxLines = 1,
+            onTextLayout = { textLayout ->
+                if (textLayout.multiParagraph.didExceedMaxLines) {
+                    fontSize -= 1.dp
+                }
+            }
+        )
+    }
+}
+
+fun AtUri.rkey(): RKey {
+    return RKey(this.atUri.toUri().lastPathSegment!!)
+}
+
+@Composable
+fun TimelinePostActionsView(
+    modifier: Modifier = Modifier,
+    timelineViewModel: TimelineViewModel?,
+    onReplyTap: (SkeetData) -> Unit = {},
+    skeet: SkeetData
+) {
+    val likes = remember { mutableLongStateOf(skeet.likes ?: 0) }
+    val reposts = remember { mutableLongStateOf(skeet.reposts ?: 0) }
+    val replies = remember { mutableLongStateOf(skeet.replies ?: 0) }
+
+
+    Row(
+        horizontalArrangement = Arrangement.End,
+        modifier = modifier,
+    ) {
+        val ctx = LocalContext.current
+        IconButton(
+            onClick = {
+                val sendIntent: Intent = Intent().apply {
+                    action = Intent.ACTION_SEND
+                    type = "text/plain"
+                    putExtra(Intent.EXTRA_TEXT, skeet.shareURL())
+                }
+                ctx.startActivity(
+                    Intent.createChooser(sendIntent, "Share Bluesky post")
+                )
+            }
+        ) {
+            Icon(
+                modifier = Modifier.size(15.dp),
+                imageVector = Icons.Default.Share,
+                contentDescription = "Share",
+                tint = MaterialTheme.colorScheme.onSurfaceVariant
+            )
+        }
+
+        IconButton(
+            onClick = {
+                onReplyTap(skeet)
+            }
+        ) {
+            IconWithNumber(
+                imageVector = {
+                    if (replies.longValue == 0.toLong()) {
+                        Icons.AutoMirrored.Filled.Reply
+                    }
+
+                    val r = replies
+                    if (r.longValue > 0) {
+                        Icons.AutoMirrored.Filled.ReplyAll
+                    } else {
+                        Icons.AutoMirrored.Filled.Reply
+                    }
+
+                }(),
+                contentDescription = "Reply",
+                number = replies,
+                MaterialTheme.colorScheme.onSurfaceVariant
+            )
+        }
+
+        var isLiked by rememberSaveable { mutableStateOf(skeet.didLike) }
+        IconButton(
+            onClick = {
+                when (isLiked) {
+                    false -> timelineViewModel?.like(skeet.uri, skeet.cid) {
+                        isLiked = true
+                        likes.longValue++
+                    }
+
+                    true -> timelineViewModel?.deleteLike(skeet.cid) {
+                        isLiked = false
+                        likes.longValue--
+                    }
+                }
+            }
+        ) {
+            IconWithNumber(
+                if (isLiked) Icons.Default.ThumbUp else Icons.Default.ThumbUpOffAlt,
+                contentDescription = "Like",
+                number = likes,
+                tint = if (isLiked) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurfaceVariant
+            )
+        }
+
+        var isReposted by rememberSaveable { mutableStateOf(skeet.didRepost) }
+        IconButton(
+            onClick = {
+                when (isReposted) {
+                    false -> timelineViewModel?.repost(skeet.uri, skeet.cid) {
+                        isReposted = true
+                        reposts.longValue++
+                    }
+
+                    true -> timelineViewModel?.deleteRepost(skeet.cid) {
+                        isReposted = false
+                        reposts.longValue--
+                    }
+                }
+
+            }
+        ) {
+            IconWithNumber(
+                if (isReposted) Icons.Default.RepeatOn else Icons.Default.Repeat,
+                contentDescription = "Repost",
+                number = reposts,
+                if (isLiked) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurfaceVariant
+            )
+        }
+    }
 }

app/src/main/java/industries/geesawra/jerryno/TimelineView.kt app/src/main/java/industries/geesawra/monarch/TimelineView.kt

···
-package industries.geesawra.jerryno
+package industries.geesawra.monarch
 
 // import androidx.compose.foundation.layout.height // Will be removed for the sheet content Box
 import android.widget.Toast
···
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import coil3.compose.AsyncImage
-import industries.geesawra.jerryno.datalayer.SkeetData
-import industries.geesawra.jerryno.datalayer.TimelineViewModel
+import industries.geesawra.monarch.datalayer.SkeetData
+import industries.geesawra.monarch.datalayer.TimelineViewModel
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 

app/src/main/java/industries/geesawra/jerryno/datalayer/Bluesky.kt app/src/main/java/industries/geesawra/monarch/datalayer/Bluesky.kt

···
-package industries.geesawra.jerryno.datalayer
-
-import android.content.Context
-import android.net.Uri
-import android.util.Log
-import androidx.compose.ui.text.intl.Locale
-import androidx.compose.ui.text.toLowerCase
-import androidx.core.net.toUri
-import androidx.datastore.preferences.core.edit
-import androidx.datastore.preferences.core.stringPreferencesKey
-import androidx.datastore.preferences.preferencesDataStore
-import app.bsky.actor.PreferencesUnion
-import app.bsky.embed.Images
-import app.bsky.embed.ImagesImage
-import app.bsky.embed.Video
-import app.bsky.feed.GeneratorView
-import app.bsky.feed.GetFeedGeneratorsQueryParams
-import app.bsky.feed.GetTimelineQueryParams
-import app.bsky.feed.GetTimelineResponse
-import app.bsky.feed.Like
-import app.bsky.feed.Post
-import app.bsky.feed.PostEmbedUnion
-import app.bsky.feed.PostReplyRef
-import app.bsky.feed.Repost
-import com.atproto.identity.ResolveHandleQueryParams
-import com.atproto.identity.ResolveHandleResponse
-import com.atproto.repo.CreateRecordRequest
-import com.atproto.repo.CreateRecordResponse
-import com.atproto.repo.DeleteRecordRequest
-import com.atproto.repo.StrongRef
-import com.atproto.repo.UploadBlobResponse
-import com.atproto.server.CreateSessionRequest
-import com.atproto.server.CreateSessionResponse
-import com.atproto.server.RefreshSessionResponse
-import industries.geesawra.jerryno.rkey
-import io.ktor.client.HttpClient
-import io.ktor.client.call.body
-import io.ktor.client.engine.okhttp.OkHttp
-import io.ktor.client.plugins.HttpTimeout
-import io.ktor.client.plugins.defaultRequest
-import io.ktor.client.request.get
-import io.ktor.client.request.post
-import io.ktor.http.HttpStatusCode
-import io.ktor.http.URLProtocol
-import io.ktor.http.path
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.datetime.Clock
-import kotlinx.serialization.Serializable
-import sh.christian.ozone.BlueskyJson
-import sh.christian.ozone.XrpcBlueskyApi
-import sh.christian.ozone.api.AtUri
-import sh.christian.ozone.api.AuthenticatedXrpcBlueskyApi
-import sh.christian.ozone.api.BlueskyAuthPlugin
-import sh.christian.ozone.api.Cid
-import sh.christian.ozone.api.Did
-import sh.christian.ozone.api.Handle
-import sh.christian.ozone.api.Nsid
-import sh.christian.ozone.api.RKey
-import sh.christian.ozone.api.model.Blob
-import sh.christian.ozone.api.model.JsonContent.Companion.encodeAsJsonContent
-import sh.christian.ozone.api.response.AtpResponse
-
-enum class AuthData {
-    PDSHost,
-    SessionData,
-}
-
-class LoginException(message: String?) : Exception(message)
-
-@Serializable // Added annotation
-data class SessionData(
-    val accessJwt: String,
-    val refreshJwt: String,
-    val handle: Handle,
-    val did: Did,
-    val active: Boolean? = null,
-) {
-    fun encodeToJson(): String {
-        return BlueskyJson.encodeToString(serializer(), this)
-    }
-
-    companion object {
-        fun decodeFromJson(jsonString: String): SessionData {
-            return BlueskyJson.decodeFromString(serializer(), jsonString)
-        }
-
-        fun fromCreateSessionResponse(session: CreateSessionResponse): SessionData {
-            return SessionData(
-                accessJwt = session.accessJwt,
-                refreshJwt = session.refreshJwt,
-                handle = session.handle,
-                did = session.did,
-                active = session.active,
-            )
-        }
-
-        fun fromRefreshSessionResponse(session: RefreshSessionResponse): SessionData {
-            return SessionData(
-                accessJwt = session.accessJwt,
-                refreshJwt = session.refreshJwt,
-                handle = session.handle,
-                did = session.did,
-                active = session.active,
-            )
-        }
-    }
-}
-
-
-class BlueskyConn(val context: Context) {
-    companion object {
-        private val Context.dataStore by preferencesDataStore("bluesky")
-        private val SESSION = stringPreferencesKey(AuthData.SessionData.name)
-        private val PDSHOST = stringPreferencesKey(AuthData.PDSHost.name)
-
-        suspend fun pdsForHandle(handle: String): Result<String> {
-            return runCatching {
-                val api = XrpcBlueskyApi()
-
-                val rawId = api.resolveHandle(
-                    ResolveHandleQueryParams(
-                        handle = Handle(handle)
-                    )
-                )
-
-                val did = when (rawId) {
-                    is AtpResponse.Failure<*> -> {
-                        return Result.failure(Exception("Failed to resolve handle: ${rawId.error?.message}"))
-                    }
-
-                    is AtpResponse.Success<ResolveHandleResponse> -> {
-                        rawId.response.did.did
-                    }
-                }
-
-                val httpClient = HttpClient(OkHttp) {
-                    install(HttpTimeout) {
-                        requestTimeoutMillis = 15000
-                        connectTimeoutMillis = 15000
-                        socketTimeoutMillis = 15000
-                    }
-                }
-
-                val rawDoc = httpClient.get {
-                    url {
-                        protocol = URLProtocol.HTTPS
-                        host = "plc.directory"
-                        path(did)
-                    }
-                }
-
-                if (rawDoc.status != HttpStatusCode.OK) {
-                    return Result.failure(Exception("PLC lookup HTTP status code ${rawDoc.status}"))
-                }
-
-                val body: String = rawDoc.body()
-
-                val solvedDoc: didDoc = BlueskyJson.decodeFromString(didDoc.serializer(), body)
-
-                for (ps in solvedDoc.service) {
-                    if (ps.id == "#atproto_pds" && ps.type == "AtprotoPersonalDataServer") {
-                        return Result.success(ps.serviceEndpoint)
-                    }
-                }
-
-                return Result.failure(Exception("No PDS service defined in the DID document associated with ${handle}"))
-            }
-        }
-    }
-
-    @Serializable
-    private data class service(
-        val id: String,
-        val type: String,
-        val serviceEndpoint: String
-    )
-
-    @Serializable
-    private data class didDoc(
-        val service: List<service>
-    )
-
-    var client: AuthenticatedXrpcBlueskyApi? = null
-    var session: SessionData? = null
-    var createMutex: Mutex = Mutex()
-
-    suspend fun storeSessionData(pdsURL: String, session: SessionData) {
-        context.dataStore.edit { settings ->
-            settings[SESSION] = session.encodeToJson()
-            settings[PDSHOST] = pdsURL
-        }
-    }
-
-    suspend fun cleanSessionData() {
-        context.dataStore.edit { settings ->
-            settings.remove(SESSION)
-            settings.remove(PDSHOST)
-        }
-    }
-
-    suspend fun hasSession(): Boolean {
-        val pdsURLFlow: Flow<String> = context.dataStore.data.map { settings ->
-            settings[PDSHOST] ?: ""
-        }
-        val sessionDataStringFlow: Flow<String> = context.dataStore.data.map { settings ->
-            settings[SESSION] ?: ""
-        }
-
-        val pdsURL = pdsURLFlow.first()
-        val sessionDataString = sessionDataStringFlow.first()
-
-        return !(pdsURL.isEmpty() || sessionDataString.isEmpty())
-    }
-
-    suspend fun login(pdsURL: String, handle: String, password: String): Result<Unit> {
-        createMutex.lock()
-        val httpClient = HttpClient(OkHttp) {
-            defaultRequest {
-                url(pdsURL)
-            }
-            install(HttpTimeout) {
-                requestTimeoutMillis = 15000
-                connectTimeoutMillis = 15000
-                socketTimeoutMillis = 15000
-            }
-        }
-
-        val client = XrpcBlueskyApi(httpClient)
-
-        val s = client.createSession(CreateSessionRequest(handle, password))
-        val sessionResponse: CreateSessionResponse = when (s) {
-            is AtpResponse.Failure<*> -> {
-                createMutex.unlock()
-                return Result.failure(
-                    Exception(
-                        "Failed to create session: ${
-                            s.error?.message?.toLowerCase(
-                                Locale.current
-                            )
-                        }"
-                    )
-                )
-            }
-
-            is AtpResponse.Success<CreateSessionResponse> -> s.response
-        }
-
-        storeSessionData(pdsURL, SessionData.fromCreateSessionResponse(sessionResponse))
-        session = null
-        this.client = null
-
-        createMutex.unlock()
-        return Result.success(Unit)
-    }
-
-    @Serializable
-    private data class atpError(
-        val error: String?,
-        val message: String?,
-    )
-
-    private suspend fun refreshIfNeeded(pdsURL: String, token: SessionData): Result<Unit> {
-        return runCatching {
-            val httpClient = HttpClient(OkHttp) {
-                defaultRequest {
-                    url(pdsURL)
-                }
-                install(HttpTimeout) {
-                    requestTimeoutMillis = 15000
-                    connectTimeoutMillis = 15000
-                    socketTimeoutMillis = 15000
-                }
-            }
-
-            val gs = httpClient.get {
-                headers["Authorization"] = "Bearer " + token.accessJwt
-                url {
-                    protocol = URLProtocol.HTTPS
-                    path("/xrpc/com.atproto.server.getSession")
-                }
-            }
-
-            when (gs.status) {
-
-                HttpStatusCode.OK -> run {
-                    this.session = token
-                    val tokens =
-                        BlueskyAuthPlugin.Tokens(token.accessJwt, token.refreshJwt)
-                    this.client = AuthenticatedXrpcBlueskyApi(httpClient, tokens)
-                    return Result.success(Unit)
-                }
-
-                else -> run {
-                    val body: String = gs.body()
-
-                    val error: atpError =
-                        BlueskyJson.decodeFromString(
-                            atpError.serializer(),
-                            body
-                        )
-                    if (error.error == "ExpiredToken") {
-                        return@run
-                    }
-                    cleanSessionData()
-                    return Result.failure(Exception("Session checking failed, status code ${gs.status}: ${error.message}"))
-                }
-            }
-
-            val rs = httpClient.post {
-                headers["Authorization"] = "Bearer " + token.refreshJwt
-                url {
-                    protocol = URLProtocol.HTTPS
-                    path("/xrpc/com.atproto.server.refreshSession")
-                }
-            }
-
-            when (rs.status) {
-
-                HttpStatusCode.OK -> run {
-                    val body: String = rs.body()
-                    val rs: RefreshSessionResponse =
-                        BlueskyJson.decodeFromString(
-                            RefreshSessionResponse.serializer(),
-                            body
-                        )
-
-                    this.session = SessionData.fromRefreshSessionResponse(rs)
-                    storeSessionData(pdsURL, this.session!!)
-                    return Result.success(Unit)
-                }
-
-                else -> run {
-                    val body: String = rs.body()
-
-                    val error: atpError =
-                        BlueskyJson.decodeFromString(
-                            atpError.serializer(),
-                            body
-                        )
-                    cleanSessionData()
-                    return Result.failure(Exception("Login refresh failed, status code ${rs.status}: ${error.message}"))
-                }
-            }
-
-        }
-    }
-
-    suspend fun create(): Result<Unit> {
-        return runCatching {
-            createMutex.lock()
-            if (session != null && client != null) {
-                createMutex.unlock()
-                return Result.success(Unit)
-            }
-
-            Log.d("Bluesky", "create called without session or client")
-            val pdsURLFlow: Flow<String> = context.dataStore.data.map { settings ->
-                settings[PDSHOST] ?: ""
-            }
-            val sessionDataStringFlow: Flow<String> = context.dataStore.data.map { settings ->
-                settings[SESSION] ?: ""
-            }
-
-            val pdsURL = pdsURLFlow.first()
-            val sessionDataString = sessionDataStringFlow.first()
-
-            if (pdsURL.isEmpty() || sessionDataString.isEmpty()) {
-                createMutex.unlock()
-                return Result.failure(Exception("No session data found"))
-            }
-
-            val sessionData = SessionData.decodeFromJson(sessionDataString)
-
-            refreshIfNeeded(pdsURL, sessionData).onFailure {
-                createMutex.unlock()
-                return Result.failure(it)
-            }
-
-            createMutex.unlock()
-        }
-    }
-
-    suspend fun fetchTimeline(
-        algorithm: String,
-        cursor: String? = null
-    ): Result<GetTimelineResponse> {
-        return runCatching {
-            create().onFailure {
-                return Result.failure(LoginException(it.message))
-            }
-
-            val timeline = client!!.getTimeline(
-                GetTimelineQueryParams(
-                    algorithm = algorithm,
-                    limit = 25,
-                    cursor = cursor
-                )
-            )
-            val feed = when (timeline) {
-                is AtpResponse.Failure<*> -> {
-                    return Result.failure(Exception("Failed to fetch timeline: ${timeline.error}"))
-                }
-
-                is AtpResponse.Success<GetTimelineResponse> -> timeline.response
-            }
-
-            return Result.success(feed)
-        }
-    }
-
-    suspend fun post(
-        content: String,
-        images: List<Uri>? = null,
-        video: Uri? = null,
-        replyRef: PostReplyRef? = null
-    ): Result<Unit> {
-        // TODO: videos need to be uploaded through a different API.
-        return runCatching {
-            create().onFailure {
-                return Result.failure(LoginException(it.message))
-            }
-
-            var postEmbed: PostEmbedUnion? = null
-
-            if (images != null) {
-                val blobs = uploadImages(images).getOrThrow()
-                postEmbed = PostEmbedUnion.Images(
-                    value = Images(
-                        images = blobs.map {
-                            ImagesImage(
-                                image = it,
-                                alt = "",
-                            )
-                        }
-                    )
-                )
-            }
-
-            if (video != null) {
-                val blob = uploadVideo(video).getOrThrow()
-                postEmbed = PostEmbedUnion.Video(
-                    value = Video(
-                        video = blob,
-                        alt = "",
-                    )
-                )
-            }
-
-            val r = BlueskyJson.encodeAsJsonContent(
-                Post(
-                    text = content,
-                    createdAt = Clock.System.now(),
-                    embed = postEmbed,
-                    reply = replyRef
-                )
-            )
-
-            val postRes = client!!.createRecord(
-                CreateRecordRequest(
-                    repo = session!!.handle, // Use handle from the session
-                    collection = Nsid("app.bsky.feed.post"),
-                    record = r,
-                )
-            )
-            return when (postRes) {
-                is AtpResponse.Failure<*> -> Result.failure(Exception("Could not create post: ${postRes.error?.message}"))
-                is AtpResponse.Success<*> -> Result.success(Unit)
-            }
-        }
-    }
-
-    suspend fun uploadImages(images: List<Uri>): Result<List<Blob>> {
-        return runCatching {
-            create().onFailure {
-                return Result.failure(LoginException(it.message))
-            }
-
-            val uploadedBlobs = mutableListOf<Blob>()
-
-            images.forEach {
-                context.contentResolver.openInputStream(it)?.use { inputStream ->
-                    val byteArray = inputStream.readBytes()
-                    val blob = client!!.uploadBlob(byteArray)
-                    when (blob) {
-                        is AtpResponse.Failure<*> -> return Result.failure(Exception("Failed uploading image: ${blob.error}"))
-                        is AtpResponse.Success<UploadBlobResponse> -> {
-                            uploadedBlobs.add(blob.response.blob)
-                        }
-                    }
-                }
-            }
-
-            return Result.success(uploadedBlobs)
-        }
-    }
-
-    suspend fun uploadVideo(video: Uri): Result<Blob> {
-        return runCatching {
-            create().onFailure {
-                return Result.failure(LoginException(it.message))
-            }
-
-            val uploadedBlobs = mutableListOf<Blob>()
-
-            context.contentResolver.openInputStream(video)?.use { inputStream ->
-                val byteArray = inputStream.readBytes()
-                val blob = client!!.uploadBlob(byteArray)
-                when (blob) {
-                    is AtpResponse.Failure<*> -> return Result.failure(Exception("Failed uploading video: ${blob.error}"))
-                    is AtpResponse.Success<UploadBlobResponse> -> {
-                        uploadedBlobs.add(blob.response.blob)
-                    }
-                }
-            }
-
-
-            return Result.success(uploadedBlobs.first())
-        }
-    }
-
-    suspend fun feeds(): Result<List<GeneratorView>> {
-        return runCatching {
-            create().onFailure {
-                return Result.failure(LoginException(it.message))
-            }
-            val prefs = client!!.getPreferences().requireResponse()
-            val feedUris = (prefs.preferences.first {
-                when (it) {
-                    is PreferencesUnion.SavedFeedsPrefV2 -> true
-                    else -> false
-                }
-            } as PreferencesUnion.SavedFeedsPrefV2).value.items.filter {
-                it.type.value != "timeline"
-            }.map { AtUri(it.value) }
-
-            val resp = client!!.getFeedGenerators(
-                GetFeedGeneratorsQueryParams(
-                    feedUris
-                )
-            ).requireResponse()
-
-            return Result.success(resp.feeds)
-        }
-    }
-
-    suspend fun like(uri: AtUri, cid: Cid): Result<RKey> {
-        return runCatching {
-            create().onFailure {
-                return Result.failure(LoginException(it.message))
-            }
-
-            val like = BlueskyJson.encodeAsJsonContent(
-                Like(
-                    subject = StrongRef(uri, cid),
-                    createdAt = Clock.System.now(),
-                )
-            )
-
-
-            val likeRes = client!!.createRecord(
-                CreateRecordRequest(
-                    repo = session!!.handle,
-                    collection = Nsid("app.bsky.feed.like"),
-                    record = like,
-                )
-            )
-
-            return when (likeRes) {
-                is AtpResponse.Failure<*> -> Result.failure(Exception("Could not like post: ${likeRes.error?.message}"))
-                is AtpResponse.Success<CreateRecordResponse> -> Result.success(
-                    RKey(likeRes.response.uri.atUri.toUri().lastPathSegment!!)
-                )
-            }
-        }
-    }
-
-    suspend fun repost(uri: AtUri, cid: Cid): Result<RKey> {
-        return runCatching {
-            create().onFailure {
-                return Result.failure(LoginException(it.message))
-            }
-
-            val like = BlueskyJson.encodeAsJsonContent(
-                Repost(
-                    subject = StrongRef(uri, cid),
-                    createdAt = Clock.System.now(),
-                )
-            )
-
-
-            val likeRes = client!!.createRecord(
-                CreateRecordRequest(
-                    repo = session!!.handle,
-                    collection = Nsid("app.bsky.feed.repost"),
-                    record = like,
-                )
-            )
-
-            return when (likeRes) {
-                is AtpResponse.Failure<*> -> Result.failure(Exception("Could not repost: ${likeRes.error?.message}"))
-                is AtpResponse.Success<CreateRecordResponse> -> Result.success(
-                    likeRes.response.uri.rkey()
-                )
-            }
-        }
-    }
-
-    suspend fun deleteLike(rKey: RKey): Result<Unit> {
-        return deleteRecord(rKey, "app.bsky.feed.like")
-    }
-
-    suspend fun deleteRepost(rKey: RKey): Result<Unit> {
-        return deleteRecord(rKey, "app.bsky.feed.repost")
-    }
-
-    private suspend fun deleteRecord(rKey: RKey, collection: String): Result<Unit> {
-        return runCatching {
-            create().onFailure {
-                return Result.failure(LoginException(it.message))
-            }
-
-            val delRes = client!!.deleteRecord(
-                DeleteRecordRequest(
-                    repo = session!!.handle,
-                    collection = Nsid(collection),
-                    rkey = rKey,
-                )
-            )
-
-            return when (delRes) {
-                is AtpResponse.Failure<*> -> Result.failure(Exception("Could not delete record: ${delRes.error?.message}"))
-                is AtpResponse.Success<*> -> Result.success(Unit)
-            }
-
-        }
-    }
+package industries.geesawra.monarch.datalayer
+
+import android.content.Context
+import android.net.Uri
+import android.util.Log
+import androidx.compose.ui.text.intl.Locale
+import androidx.compose.ui.text.toLowerCase
+import androidx.core.net.toUri
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.datastore.preferences.preferencesDataStore
+import app.bsky.actor.PreferencesUnion
+import app.bsky.embed.Images
+import app.bsky.embed.ImagesImage
+import app.bsky.embed.Video
+import app.bsky.feed.GeneratorView
+import app.bsky.feed.GetFeedGeneratorsQueryParams
+import app.bsky.feed.GetTimelineQueryParams
+import app.bsky.feed.GetTimelineResponse
+import app.bsky.feed.Like
+import app.bsky.feed.Post
+import app.bsky.feed.PostEmbedUnion
+import app.bsky.feed.PostReplyRef
+import app.bsky.feed.Repost
+import com.atproto.identity.ResolveHandleQueryParams
+import com.atproto.identity.ResolveHandleResponse
+import com.atproto.repo.CreateRecordRequest
+import com.atproto.repo.CreateRecordResponse
+import com.atproto.repo.DeleteRecordRequest
+import com.atproto.repo.StrongRef
+import com.atproto.repo.UploadBlobResponse
+import com.atproto.server.CreateSessionRequest
+import com.atproto.server.CreateSessionResponse
+import com.atproto.server.RefreshSessionResponse
+import industries.geesawra.monarch.rkey
+import io.ktor.client.HttpClient
+import io.ktor.client.call.body
+import io.ktor.client.engine.okhttp.OkHttp
+import io.ktor.client.plugins.HttpTimeout
+import io.ktor.client.plugins.defaultRequest
+import io.ktor.client.request.get
+import io.ktor.client.request.post
+import io.ktor.http.HttpStatusCode
+import io.ktor.http.URLProtocol
+import io.ktor.http.path
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.datetime.Clock
+import kotlinx.serialization.Serializable
+import sh.christian.ozone.BlueskyJson
+import sh.christian.ozone.XrpcBlueskyApi
+import sh.christian.ozone.api.AtUri
+import sh.christian.ozone.api.AuthenticatedXrpcBlueskyApi
+import sh.christian.ozone.api.BlueskyAuthPlugin
+import sh.christian.ozone.api.Cid
+import sh.christian.ozone.api.Did
+import sh.christian.ozone.api.Handle
+import sh.christian.ozone.api.Nsid
+import sh.christian.ozone.api.RKey
+import sh.christian.ozone.api.model.Blob
+import sh.christian.ozone.api.model.JsonContent.Companion.encodeAsJsonContent
+import sh.christian.ozone.api.response.AtpResponse
+
+enum class AuthData {
+    PDSHost,
+    SessionData,
+}
+
+class LoginException(message: String?) : Exception(message)
+
+@Serializable // Added annotation
+data class SessionData(
+    val accessJwt: String,
+    val refreshJwt: String,
+    val handle: Handle,
+    val did: Did,
+    val active: Boolean? = null,
+) {
+    fun encodeToJson(): String {
+        return BlueskyJson.encodeToString(serializer(), this)
+    }
+
+    companion object {
+        fun decodeFromJson(jsonString: String): SessionData {
+            return BlueskyJson.decodeFromString(serializer(), jsonString)
+        }
+
+        fun fromCreateSessionResponse(session: CreateSessionResponse): SessionData {
+            return SessionData(
+                accessJwt = session.accessJwt,
+                refreshJwt = session.refreshJwt,
+                handle = session.handle,
+                did = session.did,
+                active = session.active,
+            )
+        }
+
+        fun fromRefreshSessionResponse(session: RefreshSessionResponse): SessionData {
+            return SessionData(
+                accessJwt = session.accessJwt,
+                refreshJwt = session.refreshJwt,
+                handle = session.handle,
+                did = session.did,
+                active = session.active,
+            )
+        }
+    }
+}
+
+
+class BlueskyConn(val context: Context) {
+    companion object {
+        private val Context.dataStore by preferencesDataStore("bluesky")
+        private val SESSION = stringPreferencesKey(AuthData.SessionData.name)
+        private val PDSHOST = stringPreferencesKey(AuthData.PDSHost.name)
+
+        suspend fun pdsForHandle(handle: String): Result<String> {
+            return runCatching {
+                val api = XrpcBlueskyApi()
+
+                val rawId = api.resolveHandle(
+                    ResolveHandleQueryParams(
+                        handle = Handle(handle)
+                    )
+                )
+
+                val did = when (rawId) {
+                    is AtpResponse.Failure<*> -> {
+                        return Result.failure(Exception("Failed to resolve handle: ${rawId.error?.message}"))
+                    }
+
+                    is AtpResponse.Success<ResolveHandleResponse> -> {
+                        rawId.response.did.did
+                    }
+                }
+
+                val httpClient = HttpClient(OkHttp) {
+                    install(HttpTimeout) {
+                        requestTimeoutMillis = 15000
+                        connectTimeoutMillis = 15000
+                        socketTimeoutMillis = 15000
+                    }
+                }
+
+                val rawDoc = httpClient.get {
+                    url {
+                        protocol = URLProtocol.HTTPS
+                        host = "plc.directory"
+                        path(did)
+                    }
+                }
+
+                if (rawDoc.status != HttpStatusCode.OK) {
+                    return Result.failure(Exception("PLC lookup HTTP status code ${rawDoc.status}"))
+                }
+
+                val body: String = rawDoc.body()
+
+                val solvedDoc: didDoc = BlueskyJson.decodeFromString(didDoc.serializer(), body)
+
+                for (ps in solvedDoc.service) {
+                    if (ps.id == "#atproto_pds" && ps.type == "AtprotoPersonalDataServer") {
+                        return Result.success(ps.serviceEndpoint)
+                    }
+                }
+
+                return Result.failure(Exception("No PDS service defined in the DID document associated with ${handle}"))
+            }
+        }
+    }
+
+    @Serializable
+    private data class service(
+        val id: String,
+        val type: String,
+        val serviceEndpoint: String
+    )
+
+    @Serializable
+    private data class didDoc(
+        val service: List<service>
+    )
+
+    var client: AuthenticatedXrpcBlueskyApi? = null
+    var session: SessionData? = null
+    var createMutex: Mutex = Mutex()
+
+    suspend fun storeSessionData(pdsURL: String, session: SessionData) {
+        context.dataStore.edit { settings ->
+            settings[SESSION] = session.encodeToJson()
+            settings[PDSHOST] = pdsURL
+        }
+    }
+
+    suspend fun cleanSessionData() {
+        context.dataStore.edit { settings ->
+            settings.remove(SESSION)
+            settings.remove(PDSHOST)
+        }
+    }
+
+    suspend fun hasSession(): Boolean {
+        val pdsURLFlow: Flow<String> = context.dataStore.data.map { settings ->
+            settings[PDSHOST] ?: ""
+        }
+        val sessionDataStringFlow: Flow<String> = context.dataStore.data.map { settings ->
+            settings[SESSION] ?: ""
+        }
+
+        val pdsURL = pdsURLFlow.first()
+        val sessionDataString = sessionDataStringFlow.first()
+
+        return !(pdsURL.isEmpty() || sessionDataString.isEmpty())
+    }
+
+    suspend fun login(pdsURL: String, handle: String, password: String): Result<Unit> {
+        createMutex.lock()
+        val httpClient = HttpClient(OkHttp) {
+            defaultRequest {
+                url(pdsURL)
+            }
+            install(HttpTimeout) {
+                requestTimeoutMillis = 15000
+                connectTimeoutMillis = 15000
+                socketTimeoutMillis = 15000
+            }
+        }
+
+        val client = XrpcBlueskyApi(httpClient)
+
+        val s = client.createSession(CreateSessionRequest(handle, password))
+        val sessionResponse: CreateSessionResponse = when (s) {
+            is AtpResponse.Failure<*> -> {
+                createMutex.unlock()
+                return Result.failure(
+                    Exception(
+                        "Failed to create session: ${
+                            s.error?.message?.toLowerCase(
+                                Locale.current
+                            )
+                        }"
+                    )
+                )
+            }
+
+            is AtpResponse.Success<CreateSessionResponse> -> s.response
+        }
+
+        storeSessionData(pdsURL, SessionData.fromCreateSessionResponse(sessionResponse))
+        session = null
+        this.client = null
+
+        createMutex.unlock()
+        return Result.success(Unit)
+    }
+
+    @Serializable
+    private data class atpError(
+        val error: String?,
+        val message: String?,
+    )
+
+    private suspend fun refreshIfNeeded(pdsURL: String, token: SessionData): Result<Unit> {
+        return runCatching {
+            val httpClient = HttpClient(OkHttp) {
+                defaultRequest {
+                    url(pdsURL)
+                }
+                install(HttpTimeout) {
+                    requestTimeoutMillis = 15000
+                    connectTimeoutMillis = 15000
+                    socketTimeoutMillis = 15000
+                }
+            }
+
+            val gs = httpClient.get {
+                headers["Authorization"] = "Bearer " + token.accessJwt
+                url {
+                    protocol = URLProtocol.HTTPS
+                    path("/xrpc/com.atproto.server.getSession")
+                }
+            }
+
+            when (gs.status) {
+
+                HttpStatusCode.OK -> run {
+                    this.session = token
+                    val tokens =
+                        BlueskyAuthPlugin.Tokens(token.accessJwt, token.refreshJwt)
+                    this.client = AuthenticatedXrpcBlueskyApi(httpClient, tokens)
+                    return Result.success(Unit)
+                }
+
+                else -> run {
+                    val body: String = gs.body()
+
+                    val error: atpError =
+                        BlueskyJson.decodeFromString(
+                            atpError.serializer(),
+                            body
+                        )
+                    if (error.error == "ExpiredToken") {
+                        return@run
+                    }
+                    cleanSessionData()
+                    return Result.failure(Exception("Session checking failed, status code ${gs.status}: ${error.message}"))
+                }
+            }
+
+            val rs = httpClient.post {
+                headers["Authorization"] = "Bearer " + token.refreshJwt
+                url {
+                    protocol = URLProtocol.HTTPS
+                    path("/xrpc/com.atproto.server.refreshSession")
+                }
+            }
+
+            when (rs.status) {
+
+                HttpStatusCode.OK -> run {
+                    val body: String = rs.body()
+                    val rs: RefreshSessionResponse =
+                        BlueskyJson.decodeFromString(
+                            RefreshSessionResponse.serializer(),
+                            body
+                        )
+
+                    this.session = SessionData.fromRefreshSessionResponse(rs)
+                    storeSessionData(pdsURL, this.session!!)
+                    return Result.success(Unit)
+                }
+
+                else -> run {
+                    val body: String = rs.body()
+
+                    val error: atpError =
+                        BlueskyJson.decodeFromString(
+                            atpError.serializer(),
+                            body
+                        )
+                    cleanSessionData()
+                    return Result.failure(Exception("Login refresh failed, status code ${rs.status}: ${error.message}"))
+                }
+            }
+
+        }
+    }
+
+    suspend fun create(): Result<Unit> {
+        return runCatching {
+            createMutex.lock()
+            if (session != null && client != null) {
+                createMutex.unlock()
+                return Result.success(Unit)
+            }
+
+            Log.d("Bluesky", "create called without session or client")
+            val pdsURLFlow: Flow<String> = context.dataStore.data.map { settings ->
+                settings[PDSHOST] ?: ""
+            }
+            val sessionDataStringFlow: Flow<String> = context.dataStore.data.map { settings ->
+                settings[SESSION] ?: ""
+            }
+
+            val pdsURL = pdsURLFlow.first()
+            val sessionDataString = sessionDataStringFlow.first()
+
+            if (pdsURL.isEmpty() || sessionDataString.isEmpty()) {
+                createMutex.unlock()
+                return Result.failure(Exception("No session data found"))
+            }
+
+            val sessionData = SessionData.decodeFromJson(sessionDataString)
+
+            refreshIfNeeded(pdsURL, sessionData).onFailure {
+                createMutex.unlock()
+                return Result.failure(it)
+            }
+
+            createMutex.unlock()
+        }
+    }
+
+    suspend fun fetchTimeline(
+        algorithm: String,
+        cursor: String? = null
+    ): Result<GetTimelineResponse> {
+        return runCatching {
+            create().onFailure {
+                return Result.failure(LoginException(it.message))
+            }
+
+            val timeline = client!!.getTimeline(
+                GetTimelineQueryParams(
+                    algorithm = algorithm,
+                    limit = 25,
+                    cursor = cursor
+                )
+            )
+            val feed = when (timeline) {
+                is AtpResponse.Failure<*> -> {
+                    return Result.failure(Exception("Failed to fetch timeline: ${timeline.error}"))
+                }
+
+                is AtpResponse.Success<GetTimelineResponse> -> timeline.response
+            }
+
+            return Result.success(feed)
+        }
+    }
+
+    suspend fun post(
+        content: String,
+        images: List<Uri>? = null,
+        video: Uri? = null,
+        replyRef: PostReplyRef? = null
+    ): Result<Unit> {
+        // TODO: videos need to be uploaded through a different API.
+        return runCatching {
+            create().onFailure {
+                return Result.failure(LoginException(it.message))
+            }
+
+            var postEmbed: PostEmbedUnion? = null
+
+            if (images != null) {
+                val blobs = uploadImages(images).getOrThrow()
+                postEmbed = PostEmbedUnion.Images(
+                    value = Images(
+                        images = blobs.map {
+                            ImagesImage(
+                                image = it,
+                                alt = "",
+                            )
+                        }
+                    )
+                )
+            }
+
+            if (video != null) {
+                val blob = uploadVideo(video).getOrThrow()
+                postEmbed = PostEmbedUnion.Video(
+                    value = Video(
+                        video = blob,
+                        alt = "",
+                    )
+                )
+            }
+
+            val r = BlueskyJson.encodeAsJsonContent(
+                Post(
+                    text = content,
+                    createdAt = Clock.System.now(),
+                    embed = postEmbed,
+                    reply = replyRef
+                )
+            )
+
+            val postRes = client!!.createRecord(
+                CreateRecordRequest(
+                    repo = session!!.handle, // Use handle from the session
+                    collection = Nsid("app.bsky.feed.post"),
+                    record = r,
+                )
+            )
+            return when (postRes) {
+                is AtpResponse.Failure<*> -> Result.failure(Exception("Could not create post: ${postRes.error?.message}"))
+                is AtpResponse.Success<*> -> Result.success(Unit)
+            }
+        }
+    }
+
+    suspend fun uploadImages(images: List<Uri>): Result<List<Blob>> {
+        return runCatching {
+            create().onFailure {
+                return Result.failure(LoginException(it.message))
+            }
+
+            val uploadedBlobs = mutableListOf<Blob>()
+
+            images.forEach {
+                context.contentResolver.openInputStream(it)?.use { inputStream ->
+                    val byteArray = inputStream.readBytes()
+                    val blob = client!!.uploadBlob(byteArray)
+                    when (blob) {
+                        is AtpResponse.Failure<*> -> return Result.failure(Exception("Failed uploading image: ${blob.error}"))
+                        is AtpResponse.Success<UploadBlobResponse> -> {
+                            uploadedBlobs.add(blob.response.blob)
+                        }
+                    }
+                }
+            }
+
+            return Result.success(uploadedBlobs)
+        }
+    }
+
+    suspend fun uploadVideo(video: Uri): Result<Blob> {
+        return runCatching {
+            create().onFailure {
+                return Result.failure(LoginException(it.message))
+            }
+
+            val uploadedBlobs = mutableListOf<Blob>()
+
+            context.contentResolver.openInputStream(video)?.use { inputStream ->
+                val byteArray = inputStream.readBytes()
+                val blob = client!!.uploadBlob(byteArray)
+                when (blob) {
+                    is AtpResponse.Failure<*> -> return Result.failure(Exception("Failed uploading video: ${blob.error}"))
+                    is AtpResponse.Success<UploadBlobResponse> -> {
+                        uploadedBlobs.add(blob.response.blob)
+                    }
+                }
+            }
+
+
+            return Result.success(uploadedBlobs.first())
+        }
+    }
+
+    suspend fun feeds(): Result<List<GeneratorView>> {
+        return runCatching {
+            create().onFailure {
+                return Result.failure(LoginException(it.message))
+            }
+            val prefs = client!!.getPreferences().requireResponse()
+            val feedUris = (prefs.preferences.first {
+                when (it) {
+                    is PreferencesUnion.SavedFeedsPrefV2 -> true
+                    else -> false
+                }
+            } as PreferencesUnion.SavedFeedsPrefV2).value.items.filter {
+                it.type.value != "timeline"
+            }.map { AtUri(it.value) }
+
+            val resp = client!!.getFeedGenerators(
+                GetFeedGeneratorsQueryParams(
+                    feedUris
+                )
+            ).requireResponse()
+
+            return Result.success(resp.feeds)
+        }
+    }
+
+    suspend fun like(uri: AtUri, cid: Cid): Result<RKey> {
+        return runCatching {
+            create().onFailure {
+                return Result.failure(LoginException(it.message))
+            }
+
+            val like = BlueskyJson.encodeAsJsonContent(
+                Like(
+                    subject = StrongRef(uri, cid),
+                    createdAt = Clock.System.now(),
+                )
+            )
+
+
+            val likeRes = client!!.createRecord(
+                CreateRecordRequest(
+                    repo = session!!.handle,
+                    collection = Nsid("app.bsky.feed.like"),
+                    record = like,
+                )
+            )
+
+            return when (likeRes) {
+                is AtpResponse.Failure<*> -> Result.failure(Exception("Could not like post: ${likeRes.error?.message}"))
+                is AtpResponse.Success<CreateRecordResponse> -> Result.success(
+                    RKey(likeRes.response.uri.atUri.toUri().lastPathSegment!!)
+                )
+            }
+        }
+    }
+
+    suspend fun repost(uri: AtUri, cid: Cid): Result<RKey> {
+        return runCatching {
+            create().onFailure {
+                return Result.failure(LoginException(it.message))
+            }
+
+            val like = BlueskyJson.encodeAsJsonContent(
+                Repost(
+                    subject = StrongRef(uri, cid),
+                    createdAt = Clock.System.now(),
+                )
+            )
+
+
+            val likeRes = client!!.createRecord(
+                CreateRecordRequest(
+                    repo = session!!.handle,
+                    collection = Nsid("app.bsky.feed.repost"),
+                    record = like,
+                )
+            )
+
+            return when (likeRes) {
+                is AtpResponse.Failure<*> -> Result.failure(Exception("Could not repost: ${likeRes.error?.message}"))
+                is AtpResponse.Success<CreateRecordResponse> -> Result.success(
+                    likeRes.response.uri.rkey()
+                )
+            }
+        }
+    }
+
+    suspend fun deleteLike(rKey: RKey): Result<Unit> {
+        return deleteRecord(rKey, "app.bsky.feed.like")
+    }
+
+    suspend fun deleteRepost(rKey: RKey): Result<Unit> {
+        return deleteRecord(rKey, "app.bsky.feed.repost")
+    }
+
+    private suspend fun deleteRecord(rKey: RKey, collection: String): Result<Unit> {
+        return runCatching {
+            create().onFailure {
+                return Result.failure(LoginException(it.message))
+            }
+
+            val delRes = client!!.deleteRecord(
+                DeleteRecordRequest(
+                    repo = session!!.handle,
+                    collection = Nsid(collection),
+                    rkey = rKey,
+                )
+            )
+
+            return when (delRes) {
+                is AtpResponse.Failure<*> -> Result.failure(Exception("Could not delete record: ${delRes.error?.message}"))
+                is AtpResponse.Success<*> -> Result.success(Unit)
+            }
+
+        }
+    }
 }

app/src/main/java/industries/geesawra/jerryno/datalayer/Models.kt app/src/main/java/industries/geesawra/monarch/datalayer/Models.kt

···
-package industries.geesawra.jerryno.datalayer
+package industries.geesawra.monarch.datalayer
 
 import app.bsky.embed.RecordViewRecord
 import app.bsky.embed.RecordViewRecordEmbedUnion

app/src/main/java/industries/geesawra/jerryno/datalayer/TimelineViewModel.kt app/src/main/java/industries/geesawra/monarch/datalayer/TimelineViewModel.kt

···
-package industries.geesawra.jerryno.datalayer
+package industries.geesawra.monarch.datalayer
 
 import android.net.Uri
 import androidx.compose.runtime.getValue

app/src/main/java/industries/geesawra/jerryno/ui/theme/Color.kt app/src/main/java/industries/geesawra/monarch/ui/theme/Color.kt

···
-package industries.geesawra.jerryno.ui.theme
+package industries.geesawra.monarch.ui.theme
 
 import androidx.compose.ui.graphics.Color
 

app/src/main/java/industries/geesawra/jerryno/ui/theme/Theme.kt app/src/main/java/industries/geesawra/monarch/ui/theme/Theme.kt

···
-package industries.geesawra.jerryno.ui.theme
+package industries.geesawra.monarch.ui.theme
 
-import android.app.Activity
 import android.os.Build
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.material3.MaterialTheme
···
 )
 
 @Composable
-fun JerryNoTheme(
+fun MonarchTheme(
     darkTheme: Boolean = isSystemInDarkTheme(),
     // Dynamic color is available on Android 12+
     dynamicColor: Boolean = true,

app/src/main/java/industries/geesawra/jerryno/ui/theme/Type.kt app/src/main/java/industries/geesawra/monarch/ui/theme/Type.kt

···
-package industries.geesawra.jerryno.ui.theme
+package industries.geesawra.monarch.ui.theme
 
 import androidx.compose.material3.Typography
 import androidx.compose.ui.text.TextStyle

app/src/main/res/values/strings.xml

···
 <resources>
-    <string name="app_name">Jerry No</string>
+    <string name="app_name">Monarch</string>
     <string name="timeline">Timeline</string>
     <string name="notifications">Notifications</string>
 </resources>

app/src/main/res/values/themes.xml

···
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
 
-    <style name="Theme.JerryNo" parent="android:Theme.Material.Light.NoActionBar" />
+    <style name="Theme.Monarch" parent="android:Theme.Material.Light.NoActionBar" />
 </resources>

app/src/test/java/industries/geesawra/jerryno/ExampleUnitTest.kt app/src/test/java/industries/geesawra/monarch/ExampleUnitTest.kt

···
-package industries.geesawra.jerryno
+package industries.geesawra.monarch
 
+import org.junit.Assert.assertEquals
 import org.junit.Test
-
-import org.junit.Assert.*
 
 /**
  * Example local unit test, which will execute on the development machine (host).

settings.gradle.kts

···
         maven { url = uri("https://www.jitpack.io") }
     }
 }
-rootProject.name = "Jerry No"
+rootProject.name = "Monarch"
 include(":app")