Merge remote-tracking branch 'upstream/main' into Improve-notification-localization

.editorconfig

@@ -0,0 +1,2 @@
+[*.{kt,kts}]
+indent_size=2

README.md

@@ -10,7 +10,7 @@ Get the app itself:
 
 ## Development Resources
 
-This is a [React Native](https://reactnative.dev/) application, written in the TypeScript programming language. It builds on the `atproto` TypeScript packages (like [`@atproto/api`](https://www.npmjs.com/package/@atproto/api)), code for which is also on open source, but in [a different git repository](https://github.com/bluesky-social/atproto).
+This is a [React Native](https://reactnative.dev/) application, written in the TypeScript programming language. It builds on the `atproto` TypeScript packages (like [`@atproto/api`](https://www.npmjs.com/package/@atproto/api)), code for which is also open source, but in [a different git repository](https://github.com/bluesky-social/atproto).
 
 There is a small amount of Go language source code (in `./bskyweb/`), for a web service that returns the React Native Web application.
 
@@ -42,10 +42,10 @@ The Bluesky Social application encompasses a set of schemas and APIs built in th
 - Open an issue and give some time for discussion before submitting a PR.
 - Stay away from PRs like...
   - Changing "Post" to "Skeet."
-  - Refactoring the codebase, eg to replace mobx with redux or something.
+  - Refactoring the codebase, e.g., to replace MobX with Redux or something.
   - Adding entirely new features without prior discussion. 
 
-Remember, we serve a wide community of users. Our day to day involves us constantly asking "which top priority is our top priority." If you submit well-written PRs that solve problems concisely, that's an awesome contribution. Otherwise, as much as we'd love to accept your ideas and contributions, we really don't have the bandwidth. That's what forking is for!
+Remember, we serve a wide community of users. Our day-to-day involves us constantly asking "which top priority is our top priority." If you submit well-written PRs that solve problems concisely, that's an awesome contribution. Otherwise, as much as we'd love to accept your ideas and contributions, we really don't have the bandwidth. That's what forking is for!
 
 ## Forking guidelines
 
@@ -63,7 +63,7 @@ If you discover any security issues, please send an email to security@bsky.app.
 
 ## Are you a developer interested in building on atproto?
 
-Bluesky is an open social network built on the AT Protocol, a flexible technology that will never lock developers out of the ecosystems that they help build. With atproto, third-party can be as seamless as first-party through custom feeds, federated services, clients, and more.
+Bluesky is an open social network built on the AT Protocol, a flexible technology that will never lock developers out of the ecosystems that they help build. With atproto, third-party integration can be as seamless as first-party through custom feeds, federated services, clients, and more.
 
 ## License (MIT)
 

__e2e__/flows/shared-prefs.yml

@@ -0,0 +1,31 @@
+appId: xyz.blueskyweb.app
+---
+- runScript:
+    file: ../setupServer.js
+    env:
+      SERVER_PATH: "?users&posts&feeds"
+- runFlow:
+    file: ../setupApp.yml
+- tapOn:
+    id: "e2eSignInAlice"
+- tapOn: "/sys/debug"
+- tapOn:
+    id: "sharedPrefsTestOpenBtn"
+- tapOn:
+    id: "setStringBtn"
+- assertVisible: "Hello"
+- tapOn:
+    id: "removeStringBtn"
+- assertVisible: "null"
+- tapOn:
+    id: "setBoolBtn"
+- assertVisible: "true"
+- tapOn:
+    id: "setNumberBtn"
+- assertVisible: "123"
+- tapOn:
+    id: "addToSetBtn"
+- assertVisible: "true"
+- tapOn:
+    id: "removeFromSetBtn"
+- assertVisible: "false"

app.config.js

@@ -221,6 +221,7 @@ module.exports = function (config) {
         './plugins/withAndroidSplashScreenStatusBarTranslucentPlugin.js',
         './plugins/shareExtension/withShareExtensions.js',
         './plugins/notificationsExtension/withNotificationsExtension.js',
+        './plugins/withAppDelegateReferrer.js',
       ].filter(Boolean),
       extra: {
         eas: {

modules/BlueskyNSE/NotificationService.swift

@@ -13,43 +13,43 @@ class NotificationService: UNNotificationServiceExtension {
       contentHandler(request.content)
       return
     }
-    
+
     if reason == "chat-message" {
       mutateWithChatMessage(bestAttempt)
     } else {
       mutateWithBadge(bestAttempt)
     }
-    
+
     contentHandler(bestAttempt)
   }
-  
+
   override func serviceExtensionTimeWillExpire() {
     // If for some reason the alloted time expires, we don't actually want to display a notification
   }
-  
+
   func createCopy(_ content: UNNotificationContent) -> UNMutableNotificationContent? {
     return content.mutableCopy() as? UNMutableNotificationContent
   }
-  
+
   func mutateWithBadge(_ content: UNMutableNotificationContent) {
     var count = prefs?.integer(forKey: "badgeCount") ?? 0
     count += 1
-    
+
     // Set the new badge number for the notification, then store that value for using later
     content.badge = NSNumber(value: count)
     prefs?.setValue(count, forKey: "badgeCount")
   }
-  
+
   func mutateWithChatMessage(_ content: UNMutableNotificationContent) {
     if self.prefs?.bool(forKey: "playSoundChat") == true {
       mutateWithDmSound(content)
     }
   }
-  
+
   func mutateWithDefaultSound(_ content: UNMutableNotificationContent) {
     content.sound = UNNotificationSound.default
   }
-  
+
   func mutateWithDmSound(_ content: UNMutableNotificationContent) {
     content.sound = UNNotificationSound(named: UNNotificationSoundName(rawValue: "dm.aiff"))
   }

modules/Share-with-Bluesky/ShareViewController.swift

@@ -30,12 +30,11 @@ class ShareViewController: UIViewController {
     }
   }
 
-  private func handleText(item: NSItemProvider) async -> Void {
+  private func handleText(item: NSItemProvider) async {
     do {
       if let data = try await item.loadItem(forTypeIdentifier: "public.text") as? String {
         if let encoded = data.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed),
-           let url = URL(string: "\(self.appScheme)://intent/compose?text=\(encoded)")
+           let url = URL(string: "\(self.appScheme)://intent/compose?text=\(encoded)") {
-        {
           _ = self.openURL(url)
         }
       }
@@ -45,12 +44,11 @@ class ShareViewController: UIViewController {
     }
   }
 
-  private func handleUrl(item: NSItemProvider) async -> Void {
+  private func handleUrl(item: NSItemProvider) async {
     do {
       if let data = try await item.loadItem(forTypeIdentifier: "public.url") as? URL {
         if let encoded = data.absoluteString.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed),
-           let url = URL(string: "\(self.appScheme)://intent/compose?text=\(encoded)")
+           let url = URL(string: "\(self.appScheme)://intent/compose?text=\(encoded)") {
-        {
           _ = self.openURL(url)
         }
       }
@@ -60,7 +58,7 @@ class ShareViewController: UIViewController {
     }
   }
 
-  private func handleImages(items: [NSItemProvider]) async -> Void {
+  private func handleImages(items: [NSItemProvider]) async {
     let firstFourItems: [NSItemProvider]
     if items.count < 4 {
       firstFourItems = items
@@ -72,7 +70,7 @@ class ShareViewController: UIViewController {
     var imageUris = ""
 
     for (index, item) in firstFourItems.enumerated() {
-      var imageUriInfo: String? = nil
+      var imageUriInfo: String?
 
       do {
         if let dataUri = try await item.loadItem(forTypeIdentifier: "public.image") as? URL {
@@ -100,8 +98,7 @@ class ShareViewController: UIViewController {
 
     if valid,
        let encoded = imageUris.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed),
-       let url = URL(string: "\(self.appScheme)://intent/compose?imageUris=\(encoded)")
+       let url = URL(string: "\(self.appScheme)://intent/compose?imageUris=\(encoded)") {
-    {
       _ = self.openURL(url)
     }
 
@@ -119,13 +116,11 @@ class ShareViewController: UIViewController {
       // extension does.
       if let dir = FileManager()
         .containerURL(
-          forSecurityApplicationGroupIdentifier: "group.app.bsky")
+          forSecurityApplicationGroupIdentifier: "group.app.bsky") {
-      {
         let filePath = "\(dir.absoluteString)\(ProcessInfo.processInfo.globallyUniqueString).jpeg"
 
         if let newUri = URL(string: filePath),
-           let jpegData = image.jpegData(compressionQuality: 1)
+           let jpegData = image.jpegData(compressionQuality: 1) {
-        {
           try jpegData.write(to: newUri)
           return "\(newUri.absoluteString)|\(image.size.width)|\(image.size.height)"
         }
@@ -136,7 +131,7 @@ class ShareViewController: UIViewController {
     }
   }
 
-  private func completeRequest() -> Void {
+  private func completeRequest() {
     self.extensionContext?.completeRequest(returningItems: nil)
   }
 

modules/expo-background-notification-handler/android/src/main/java/expo/modules/backgroundnotificationhandler/BackgroundNotificationHandler.kt

@@ -5,7 +5,7 @@ import com.google.firebase.messaging.RemoteMessage
 
 class BackgroundNotificationHandler(
   private val context: Context,
-  private val notifInterface: BackgroundNotificationHandlerInterface
+  private val notifInterface: BackgroundNotificationHandlerInterface,
 ) {
   fun handleMessage(remoteMessage: RemoteMessage) {
     if (ExpoBackgroundNotificationHandlerModule.isForegrounded) {

modules/expo-background-notification-handler/android/src/main/java/expo/modules/backgroundnotificationhandler/ExpoBackgroundNotificationHandlerModule.kt

@@ -8,67 +8,68 @@ class ExpoBackgroundNotificationHandlerModule : Module() {
     var isForegrounded = false
   }
 
-  override fun definition() = ModuleDefinition {
+  override fun definition() =
-    Name("ExpoBackgroundNotificationHandler")
+    ModuleDefinition {
+      Name("ExpoBackgroundNotificationHandler")
 
-    OnCreate {
+      OnCreate {
-      NotificationPrefs(appContext.reactContext).initialize()
+        NotificationPrefs(appContext.reactContext).initialize()
-    }
+      }
 
-    OnActivityEntersForeground {
+      OnActivityEntersForeground {
-      isForegrounded = true
+        isForegrounded = true
-    }
+      }
 
-    OnActivityEntersBackground {
+      OnActivityEntersBackground {
-      isForegrounded = false
+        isForegrounded = false
-    }
+      }
 
-    AsyncFunction("getAllPrefsAsync") {
+      AsyncFunction("getAllPrefsAsync") {
-      return@AsyncFunction NotificationPrefs(appContext.reactContext).getAllPrefs()
+        return@AsyncFunction NotificationPrefs(appContext.reactContext).getAllPrefs()
-    }
+      }
 
-    AsyncFunction("getBoolAsync") { forKey: String ->
+      AsyncFunction("getBoolAsync") { forKey: String ->
-      return@AsyncFunction NotificationPrefs(appContext.reactContext).getBoolean(forKey)
+        return@AsyncFunction NotificationPrefs(appContext.reactContext).getBoolean(forKey)
-    }
+      }
 
-    AsyncFunction("getStringAsync") { forKey: String ->
+      AsyncFunction("getStringAsync") { forKey: String ->
-      return@AsyncFunction NotificationPrefs(appContext.reactContext).getString(forKey)
+        return@AsyncFunction NotificationPrefs(appContext.reactContext).getString(forKey)
-    }
+      }
 
-    AsyncFunction("getStringArrayAsync") { forKey: String ->
+      AsyncFunction("getStringArrayAsync") { forKey: String ->
-      return@AsyncFunction NotificationPrefs(appContext.reactContext).getStringArray(forKey)
+        return@AsyncFunction NotificationPrefs(appContext.reactContext).getStringArray(forKey)
-    }
+      }
 
-    AsyncFunction("setBoolAsync") { forKey: String, value: Boolean ->
+      AsyncFunction("setBoolAsync") { forKey: String, value: Boolean ->
-      NotificationPrefs(appContext.reactContext).setBoolean(forKey, value)
+        NotificationPrefs(appContext.reactContext).setBoolean(forKey, value)
-    }
+      }
 
-    AsyncFunction("setStringAsync") { forKey: String, value: String ->
+      AsyncFunction("setStringAsync") { forKey: String, value: String ->
-      NotificationPrefs(appContext.reactContext).setString(forKey, value)
+        NotificationPrefs(appContext.reactContext).setString(forKey, value)
-    }
+      }
 
-    AsyncFunction("setStringArrayAsync") { forKey: String, value: Array<String> ->
+      AsyncFunction("setStringArrayAsync") { forKey: String, value: Array<String> ->
-      NotificationPrefs(appContext.reactContext).setStringArray(forKey, value)
+        NotificationPrefs(appContext.reactContext).setStringArray(forKey, value)
-    }
+      }
 
-    AsyncFunction("addToStringArrayAsync") { forKey: String, string: String ->
+      AsyncFunction("addToStringArrayAsync") { forKey: String, string: String ->
-      NotificationPrefs(appContext.reactContext).addToStringArray(forKey, string)
+        NotificationPrefs(appContext.reactContext).addToStringArray(forKey, string)
-    }
+      }
 
-    AsyncFunction("removeFromStringArrayAsync") { forKey: String, string: String ->
+      AsyncFunction("removeFromStringArrayAsync") { forKey: String, string: String ->
-      NotificationPrefs(appContext.reactContext).removeFromStringArray(forKey, string)
+        NotificationPrefs(appContext.reactContext).removeFromStringArray(forKey, string)
-    }
+      }
 
-    AsyncFunction("addManyToStringArrayAsync") { forKey: String, strings: Array<String> ->
+      AsyncFunction("addManyToStringArrayAsync") { forKey: String, strings: Array<String> ->
-      NotificationPrefs(appContext.reactContext).addManyToStringArray(forKey, strings)
+        NotificationPrefs(appContext.reactContext).addManyToStringArray(forKey, strings)
-    }
+      }
 
-    AsyncFunction("removeManyFromStringArrayAsync") { forKey: String, strings: Array<String> ->
+      AsyncFunction("removeManyFromStringArrayAsync") { forKey: String, strings: Array<String> ->
-      NotificationPrefs(appContext.reactContext).removeManyFromStringArray(forKey, strings)
+        NotificationPrefs(appContext.reactContext).removeManyFromStringArray(forKey, strings)
-    }
+      }
 
-    AsyncFunction("setBadgeCountAsync") { _: Int ->
+      AsyncFunction("setBadgeCountAsync") { _: Int ->
-      // This does nothing on Android
+        // This does nothing on Android
+      }
     }
-  }
 }

modules/expo-background-notification-handler/android/src/main/java/expo/modules/backgroundnotificationhandler/NotificationPrefs.kt

@@ -2,20 +2,24 @@ package expo.modules.backgroundnotificationhandler
 
 import android.content.Context
 
-val DEFAULTS = mapOf<String, Any>(
+val DEFAULTS =
-  "playSoundChat" to true,
+  mapOf<String, Any>(
-  "playSoundFollow" to false,
+    "playSoundChat" to true,
-  "playSoundLike" to false,
+    "playSoundFollow" to false,
-  "playSoundMention" to false,
+    "playSoundLike" to false,
-  "playSoundQuote" to false,
+    "playSoundMention" to false,
-  "playSoundReply" to false,
+    "playSoundQuote" to false,
-  "playSoundRepost" to false,
+    "playSoundReply" to false,
-  "mutedThreads" to mapOf<String, List<String>>()
+    "playSoundRepost" to false,
-)
+    "mutedThreads" to mapOf<String, List<String>>(),
+  )
 
-class NotificationPrefs (private val context: Context?) {
+class NotificationPrefs(
-  private val prefs = context?.getSharedPreferences("xyz.blueskyweb.app", Context.MODE_PRIVATE)
+  private val context: Context?,
-    ?: throw Error("Context is null")
+) {
+  private val prefs =
+    context?.getSharedPreferences("xyz.blueskyweb.app", Context.MODE_PRIVATE)
+      ?: throw Error("Context is null")
 
   fun initialize() {
     prefs
@@ -41,94 +45,99 @@ class NotificationPrefs (private val context: Context?) {
             }
           }
         }
-      }
+      }.apply()
-      .apply()
   }
 
-  fun getAllPrefs(): MutableMap<String, *> {
+  fun getAllPrefs(): MutableMap<String, *> = prefs.all
-    return prefs.all
-  }
 
-  fun getBoolean(key: String): Boolean {
+  fun getBoolean(key: String): Boolean = prefs.getBoolean(key, false)
-    return prefs.getBoolean(key, false)
-  }
 
-  fun getString(key: String): String? {
+  fun getString(key: String): String? = prefs.getString(key, null)
-    return prefs.getString(key, null)
-  }
 
-  fun getStringArray(key: String): Array<String>? {
+  fun getStringArray(key: String): Array<String>? = prefs.getStringSet(key, null)?.toTypedArray()
-    return prefs.getStringSet(key, null)?.toTypedArray()
-  }
 
-  fun setBoolean(key: String, value: Boolean) {
+  fun setBoolean(
+    key: String,
+    value: Boolean,
+  ) {
     prefs
       .edit()
       .apply {
         putBoolean(key, value)
-      }
+      }.apply()
-      .apply()
   }
 
-  fun setString(key: String, value: String) {
+  fun setString(
+    key: String,
+    value: String,
+  ) {
     prefs
       .edit()
       .apply {
         putString(key, value)
-      }
+      }.apply()
-      .apply()
   }
 
-  fun setStringArray(key: String, value: Array<String>) {
+  fun setStringArray(
+    key: String,
+    value: Array<String>,
+  ) {
     prefs
       .edit()
       .apply {
         putStringSet(key, value.toSet())
-      }
+      }.apply()
-      .apply()
   }
 
-  fun addToStringArray(key: String, string: String) {
+  fun addToStringArray(
+    key: String,
+    string: String,
+  ) {
     prefs
       .edit()
       .apply {
         val set = prefs.getStringSet(key, null)?.toMutableSet() ?: mutableSetOf()
         set.add(string)
         putStringSet(key, set)
-      }
+      }.apply()
-      .apply()
   }
 
-  fun removeFromStringArray(key: String, string: String) {
+  fun removeFromStringArray(
+    key: String,
+    string: String,
+  ) {
     prefs
       .edit()
       .apply {
         val set = prefs.getStringSet(key, null)?.toMutableSet() ?: mutableSetOf()
         set.remove(string)
         putStringSet(key, set)
-      }
+      }.apply()
-      .apply()
   }
 
-  fun addManyToStringArray(key: String, strings: Array<String>) {
+  fun addManyToStringArray(
+    key: String,
+    strings: Array<String>,
+  ) {
     prefs
       .edit()
       .apply {
         val set = prefs.getStringSet(key, null)?.toMutableSet() ?: mutableSetOf()
         set.addAll(strings.toSet())
         putStringSet(key, set)
-      }
+      }.apply()
-      .apply()
   }
 
-  fun removeManyFromStringArray(key: String, strings: Array<String>) {
+  fun removeManyFromStringArray(
+    key: String,
+    strings: Array<String>,
+  ) {
     prefs
       .edit()
       .apply {
         val set = prefs.getStringSet(key, null)?.toMutableSet() ?: mutableSetOf()
         set.removeAll(strings.toSet())
         putStringSet(key, set)
-      }
+      }.apply()
-      .apply()
   }
-}
+}

modules/expo-background-notification-handler/ios/ExpoBackgroundNotificationHandlerModule.swift

@@ -2,16 +2,16 @@ import ExpoModulesCore
 
 let APP_GROUP = "group.app.bsky"
 
-let DEFAULTS: [String:Any] = [
+let DEFAULTS: [String: Any] = [
-  "playSoundChat" : true,
+  "playSoundChat": true,
   "playSoundFollow": false,
   "playSoundLike": false,
   "playSoundMention": false,
   "playSoundQuote": false,
   "playSoundReply": false,
   "playSoundRepost": false,
-  "mutedThreads": [:] as! [String:[String]],
+  "mutedThreads": [:] as! [String: [String]],
-  "badgeCount": 0,
+  "badgeCount": 0
 ]
 
 /*
@@ -23,10 +23,10 @@ let DEFAULTS: [String:Any] = [
  */
 public class ExpoBackgroundNotificationHandlerModule: Module {
   let userDefaults = UserDefaults(suiteName: APP_GROUP)
-  
+
   public func definition() -> ModuleDefinition {
     Name("ExpoBackgroundNotificationHandler")
-    
+
     OnCreate {
       DEFAULTS.forEach { p in
         if userDefaults?.value(forKey: p.key) == nil {
@@ -34,57 +34,56 @@ public class ExpoBackgroundNotificationHandlerModule: Module {
         }
       }
     }
-    
+
-    AsyncFunction("getAllPrefsAsync") { () -> [String:Any]? in
+    AsyncFunction("getAllPrefsAsync") { () -> [String: Any]? in
       var keys: [String] = []
       DEFAULTS.forEach { p in
         keys.append(p.key)
       }
       return userDefaults?.dictionaryWithValues(forKeys: keys)
     }
-    
+
     AsyncFunction("getBoolAsync") { (forKey: String) -> Bool in
       if let pref = userDefaults?.bool(forKey: forKey) {
         return pref
       }
       return false
     }
-    
+
     AsyncFunction("getStringAsync") { (forKey: String) -> String? in
       if let pref = userDefaults?.string(forKey: forKey) {
         return pref
       }
       return nil
     }
-    
+
     AsyncFunction("getStringArrayAsync") { (forKey: String) -> [String]? in
       if let pref = userDefaults?.stringArray(forKey: forKey) {
         return pref
       }
       return nil
     }
-    
+
-    AsyncFunction("setBoolAsync") { (forKey: String, value: Bool) -> Void in
+    AsyncFunction("setBoolAsync") { (forKey: String, value: Bool) in
       userDefaults?.setValue(value, forKey: forKey)
     }
-    
+
-    AsyncFunction("setStringAsync") { (forKey: String, value: String) -> Void in
+    AsyncFunction("setStringAsync") { (forKey: String, value: String) in
       userDefaults?.setValue(value, forKey: forKey)
     }
-    
+
-    AsyncFunction("setStringArrayAsync") { (forKey: String, value: [String]) -> Void in
+    AsyncFunction("setStringArrayAsync") { (forKey: String, value: [String]) in
       userDefaults?.setValue(value, forKey: forKey)
     }
-    
+
     AsyncFunction("addToStringArrayAsync") { (forKey: String, string: String) in
       if var curr = userDefaults?.stringArray(forKey: forKey),
-         !curr.contains(string)
+         !curr.contains(string) {
-      {
         curr.append(string)
         userDefaults?.setValue(curr, forKey: forKey)
       }
     }
-    
+
     AsyncFunction("removeFromStringArrayAsync") { (forKey: String, string: String) in
       if var curr = userDefaults?.stringArray(forKey: forKey) {
         curr.removeAll { s in
@@ -93,7 +92,7 @@ public class ExpoBackgroundNotificationHandlerModule: Module {
         userDefaults?.setValue(curr, forKey: forKey)
       }
     }
-    
+
     AsyncFunction("addManyToStringArrayAsync") { (forKey: String, strings: [String]) in
       if var curr = userDefaults?.stringArray(forKey: forKey) {
         strings.forEach { s in
@@ -104,7 +103,7 @@ public class ExpoBackgroundNotificationHandlerModule: Module {
         userDefaults?.setValue(curr, forKey: forKey)
       }
     }
-    
+
     AsyncFunction("removeManyFromStringArrayAsync") { (forKey: String, strings: [String]) in
       if var curr = userDefaults?.stringArray(forKey: forKey) {
         strings.forEach { s in
@@ -113,7 +112,7 @@ public class ExpoBackgroundNotificationHandlerModule: Module {
         userDefaults?.setValue(curr, forKey: forKey)
       }
     }
-    
+
     AsyncFunction("setBadgeCountAsync") { (count: Int) in
       userDefaults?.setValue(count, forKey: "badgeCount")
     }

modules/expo-bluesky-gif-view/android/src/main/java/expo/modules/blueskygifview/AppCompatImageViewExtended.kt

@@ -5,7 +5,10 @@ import android.graphics.Canvas
 import android.graphics.drawable.Animatable
 import androidx.appcompat.widget.AppCompatImageView
 
-class AppCompatImageViewExtended(context: Context, private val parent: GifView): AppCompatImageView(context) {
+class AppCompatImageViewExtended(
+  context: Context,
+  private val parent: GifView,
+) : AppCompatImageView(context) {
   override fun onDraw(canvas: Canvas) {
     super.onDraw(canvas)
 
@@ -34,4 +37,4 @@ class AppCompatImageViewExtended(context: Context, private val parent: GifView):
       drawable.start()
     }
   }
-}
+}

modules/expo-bluesky-gif-view/android/src/main/java/expo/modules/blueskygifview/ExpoBlueskyGifViewModule.kt

@@ -6,49 +6,50 @@ import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
 
 class ExpoBlueskyGifViewModule : Module() {
-  override fun definition() = ModuleDefinition {
+  override fun definition() =
-    Name("ExpoBlueskyGifView")
+    ModuleDefinition {
+      Name("ExpoBlueskyGifView")
 
-    AsyncFunction("prefetchAsync") { sources: List<String> ->
+      AsyncFunction("prefetchAsync") { sources: List<String> ->
-      val activity = appContext.currentActivity ?: return@AsyncFunction
+        val activity = appContext.currentActivity ?: return@AsyncFunction
-      val glide = Glide.with(activity)
+        val glide = Glide.with(activity)
 
-      sources.forEach { source ->
+        sources.forEach { source ->
-        glide
+          glide
-          .download(source)
+            .download(source)
-          .diskCacheStrategy(DiskCacheStrategy.DATA)
+            .diskCacheStrategy(DiskCacheStrategy.DATA)
-          .submit()
+            .submit()
+        }
+      }
+
+      View(GifView::class) {
+        Events(
+          "onPlayerStateChange",
+        )
+
+        Prop("source") { view: GifView, source: String ->
+          view.source = source
+        }
+
+        Prop("placeholderSource") { view: GifView, source: String ->
+          view.placeholderSource = source
+        }
+
+        Prop("autoplay") { view: GifView, autoplay: Boolean ->
+          view.autoplay = autoplay
+        }
+
+        AsyncFunction("playAsync") { view: GifView ->
+          view.play()
+        }
+
+        AsyncFunction("pauseAsync") { view: GifView ->
+          view.pause()
+        }
+
+        AsyncFunction("toggleAsync") { view: GifView ->
+          view.toggle()
+        }
       }
     }
-
-    View(GifView::class) {
-      Events(
-        "onPlayerStateChange"
-      )
-
-      Prop("source") { view: GifView, source: String ->
-        view.source = source
-      }
-
-      Prop("placeholderSource") { view: GifView, source: String ->
-        view.placeholderSource = source
-      }
-
-      Prop("autoplay") { view: GifView, autoplay: Boolean ->
-        view.autoplay = autoplay
-      }
-
-      AsyncFunction("playAsync") { view: GifView ->
-        view.play()
-      }
-
-      AsyncFunction("pauseAsync") { view: GifView ->
-        view.pause()
-      }
-
-      AsyncFunction("toggleAsync") { view: GifView ->
-        view.toggle()
-      }
-    }
-  }
 }

modules/expo-bluesky-gif-view/android/src/main/java/expo/modules/blueskygifview/GifView.kt

@@ -1,6 +1,5 @@
 package expo.modules.blueskygifview
 
-
 import android.content.Context
 import android.graphics.Color
 import android.graphics.drawable.Animatable
@@ -15,7 +14,10 @@ import expo.modules.kotlin.exception.Exceptions
 import expo.modules.kotlin.viewevent.EventDispatcher
 import expo.modules.kotlin.views.ExpoView
 
-class GifView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
+class GifView(
+  context: Context,
+  appContext: AppContext,
+) : ExpoView(context, appContext) {
   // Events
   private val onPlayerStateChange by EventDispatcher()
 
@@ -44,8 +46,7 @@ class GifView(context: Context, appContext: AppContext) : ExpoView(context, appC
       }
     }
 
-
+  // <editor-fold desc="Lifecycle">
-  //<editor-fold desc="Lifecycle">
 
   init {
     this.setBackgroundColor(Color.TRANSPARENT)
@@ -70,80 +71,82 @@ class GifView(context: Context, appContext: AppContext) : ExpoView(context, appC
     super.onDetachedFromWindow()
   }
 
-  //</editor-fold>
+  // </editor-fold>
 
-  //<editor-fold desc="Loading">
+  // <editor-fold desc="Loading">
 
   private fun load() {
     if (placeholderSource == null || source == null) {
       return
     }
 
-    this.webpRequest = glide.load(source)
+    this.webpRequest =
-      .diskCacheStrategy(DiskCacheStrategy.DATA)
+      glide
-      .skipMemoryCache(false)
+        .load(source)
-      .listener(object: RequestListener<Drawable> {
+        .diskCacheStrategy(DiskCacheStrategy.DATA)
-        override fun onResourceReady(
+        .skipMemoryCache(false)
-          resource: Drawable?,
+        .listener(
-          model: Any?,
+          object : RequestListener<Drawable> {
-          target: Target<Drawable>?,
+            override fun onResourceReady(
-          dataSource: com.bumptech.glide.load.DataSource?,
+              resource: Drawable?,
-          isFirstResource: Boolean
+              model: Any?,
-        ): Boolean {
+              target: Target<Drawable>?,
-          if (placeholderRequest != null) {
+              dataSource: com.bumptech.glide.load.DataSource?,
-            glide.clear(placeholderRequest)
+              isFirstResource: Boolean,
-          }
+            ): Boolean {
-          return false
+              if (placeholderRequest != null) {
-        }
+                glide.clear(placeholderRequest)
+              }
+              return false
+            }
 
-        override fun onLoadFailed(
+            override fun onLoadFailed(
-          e: GlideException?,
+              e: GlideException?,
-          model: Any?,
+              model: Any?,
-          target: Target<Drawable>?,
+              target: Target<Drawable>?,
-          isFirstResource: Boolean
+              isFirstResource: Boolean,
-        ): Boolean {
+            ): Boolean = true
-          return true
+          },
-        }
+        ).into(this.imageView)
-      })
-      .into(this.imageView)
 
     if (this.imageView.drawable == null || this.imageView.drawable !is Animatable) {
-      this.placeholderRequest = glide.load(placeholderSource)
+      this.placeholderRequest =
-        .diskCacheStrategy(DiskCacheStrategy.DATA)
+        glide
-        // Let's not bloat the memory cache with placeholders
+          .load(placeholderSource)
-        .skipMemoryCache(true)
+          .diskCacheStrategy(DiskCacheStrategy.DATA)
-        .listener(object: RequestListener<Drawable> {
+          // Let's not bloat the memory cache with placeholders
-          override fun onResourceReady(
+          .skipMemoryCache(true)
-            resource: Drawable?,
+          .listener(
-            model: Any?,
+            object : RequestListener<Drawable> {
-            target: Target<Drawable>?,
+              override fun onResourceReady(
-            dataSource: com.bumptech.glide.load.DataSource?,
+                resource: Drawable?,
-            isFirstResource: Boolean
+                model: Any?,
-          ): Boolean {
+                target: Target<Drawable>?,
-            // Incase this request finishes after the webp, let's just not set
+                dataSource: com.bumptech.glide.load.DataSource?,
-            // the drawable. This shouldn't happen because the request should get cancelled
+                isFirstResource: Boolean,
-            if (imageView.drawable == null) {
+              ): Boolean {
-              imageView.setImageDrawable(resource)
+                // Incase this request finishes after the webp, let's just not set
-            }
+                // the drawable. This shouldn't happen because the request should get cancelled
-            return true
+                if (imageView.drawable == null) {
-          }
+                  imageView.setImageDrawable(resource)
+                }
+                return true
+              }
 
-          override fun onLoadFailed(
+              override fun onLoadFailed(
-            e: GlideException?,
+                e: GlideException?,
-            model: Any?,
+                model: Any?,
-            target: Target<Drawable>?,
+                target: Target<Drawable>?,
-            isFirstResource: Boolean
+                isFirstResource: Boolean,
-          ): Boolean {
+              ): Boolean = true
-            return true
+            },
-          }
+          ).submit()
-        })
-        .submit()
     }
   }
 
-  //</editor-fold>
+  // </editor-fold>
 
-  //<editor-fold desc="Controls">
+  // <editor-fold desc="Controls">
 
   fun play() {
     this.imageView.play()
@@ -165,16 +168,18 @@ class GifView(context: Context, appContext: AppContext) : ExpoView(context, appC
     }
   }
 
-  //</editor-fold>
+  // </editor-fold>
 
-  //<editor-fold desc="Util">
+  // <editor-fold desc="Util">
 
   fun firePlayerStateChange() {
-    onPlayerStateChange(mapOf(
+    onPlayerStateChange(
-      "isPlaying" to this.isPlaying,
+      mapOf(
-      "isLoaded" to this.isLoaded,
+        "isPlaying" to this.isPlaying,
-    ))
+        "isLoaded" to this.isLoaded,
+      ),
+    )
   }
 
-  //</editor-fold>
+  // </editor-fold>
 }

modules/expo-bluesky-gif-view/ios/ExpoBlueskyGifViewModule.swift

@@ -5,11 +5,11 @@ import SDWebImageWebPCoder
 public class ExpoBlueskyGifViewModule: Module {
   public func definition() -> ModuleDefinition {
     Name("ExpoBlueskyGifView")
-    
+
     OnCreate {
       SDImageCodersManager.shared.addCoder(SDImageGIFCoder.shared)
     }
-    
+
     AsyncFunction("prefetchAsync") { (sources: [URL]) in
       SDWebImagePrefetcher.shared.prefetchURLs(sources, context: Util.createContext(), progress: nil)
     }
@@ -18,27 +18,27 @@ public class ExpoBlueskyGifViewModule: Module {
       Events(
         "onPlayerStateChange"
       )
-      
+
       Prop("source") { (view: GifView, prop: String) in
         view.source = prop
       }
-      
+
       Prop("placeholderSource") { (view: GifView, prop: String) in
         view.placeholderSource = prop
       }
-      
+
       Prop("autoplay") { (view: GifView, prop: Bool) in
         view.autoplay = prop
       }
-      
+
       AsyncFunction("toggleAsync") { (view: GifView) in
         view.toggle()
       }
-      
+
       AsyncFunction("playAsync") { (view: GifView) in
         view.play()
       }
-      
+
       AsyncFunction("pauseAsync") { (view: GifView) in
         view.pause()
       }

modules/expo-bluesky-gif-view/ios/GifView.swift

@@ -16,14 +16,14 @@ public class GifView: ExpoView, AVPlayerViewControllerDelegate {
   )
   private var isPlaying = true
   private var isLoaded = false
-  
+
   // Requests
   private var webpOperation: SDWebImageCombinedOperation?
   private var placeholderOperation: SDWebImageCombinedOperation?
 
   // Props
-  var source: String? = nil
+  var source: String?
-  var placeholderSource: String? = nil
+  var placeholderSource: String?
   var autoplay = true {
     didSet {
       if !autoplay {
@@ -78,8 +78,7 @@ public class GifView: ExpoView, AVPlayerViewControllerDelegate {
     // See:
     // https://github.com/SDWebImage/SDWebImage/blob/master/Docs/HowToUse.md#using-asynchronous-image-caching-independently
     if !SDImageCache.shared.diskImageDataExists(withKey: source),
-       let url = URL(string: placeholderSource)
+       let url = URL(string: placeholderSource) {
-    {
       self.placeholderOperation = imageManager.loadImage(
         with: url,
         options: [.retryFailed],
@@ -132,8 +131,7 @@ public class GifView: ExpoView, AVPlayerViewControllerDelegate {
     if let placeholderSource = self.placeholderSource,
        imageUrl?.absoluteString == placeholderSource,
        self.imageView.image == nil,
-       let image = image
+       let image = image {
-    {
       self.setImage(image)
       return
     }
@@ -142,8 +140,7 @@ public class GifView: ExpoView, AVPlayerViewControllerDelegate {
        imageUrl?.absoluteString == source,
        // UIImage perf suckssss if the image is animated
        let data = data,
-       let animatedImage = SDAnimatedImage(data: data)
+       let animatedImage = SDAnimatedImage(data: data) {
-    {
       self.placeholderOperation?.cancel()
       self.isPlaying = self.autoplay
       self.isLoaded = true

modules/expo-bluesky-swiss-army/android/src/main/java/expo/modules/blueskyswissarmy/deviceprefs/ExpoBlueskyDevicePrefsModule.kt

@@ -1,10 +0,0 @@
-package expo.modules.blueskyswissarmy.deviceprefs
-
-import expo.modules.kotlin.modules.Module
-import expo.modules.kotlin.modules.ModuleDefinition
-
-class ExpoBlueskyDevicePrefsModule : Module() {
-  override fun definition() = ModuleDefinition {
-    Name("ExpoBlueskyDevicePrefs")
-  }
-}

modules/expo-bluesky-swiss-army/android/src/main/java/expo/modules/blueskyswissarmy/referrer/ExpoBlueskyReferrerModule.kt

@@ -1,54 +1,103 @@
 package expo.modules.blueskyswissarmy.referrer
 
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
 import android.util.Log
 import com.android.installreferrer.api.InstallReferrerClient
 import com.android.installreferrer.api.InstallReferrerStateListener
+import expo.modules.kotlin.Promise
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
-import expo.modules.kotlin.Promise
 
 class ExpoBlueskyReferrerModule : Module() {
-  override fun definition() = ModuleDefinition {
+  private var intent: Intent? = null
-    Name("ExpoBlueskyReferrer")
+  private var activityReferrer: Uri? = null
 
-    AsyncFunction("getGooglePlayReferrerInfoAsync") { promise: Promise ->
+  override fun definition() =
-      val referrerClient = InstallReferrerClient.newBuilder(appContext.reactContext).build()
+    ModuleDefinition {
-      referrerClient.startConnection(object : InstallReferrerStateListener {
+      Name("ExpoBlueskyReferrer")
-        override fun onInstallReferrerSetupFinished(responseCode: Int) {
-          if (responseCode == InstallReferrerClient.InstallReferrerResponse.OK) {
-            Log.d("ExpoGooglePlayReferrer", "Successfully retrieved referrer info.")
 
-            val response = referrerClient.installReferrer
+      OnNewIntent {
-            Log.d("ExpoGooglePlayReferrer", "Install referrer: ${response.installReferrer}")
+        intent = it
+        activityReferrer = appContext.currentActivity?.referrer
+      }
 
-            promise.resolve(
+      AsyncFunction("getReferrerInfoAsync") {
-              mapOf(
+        val intentReferrer =
-                "installReferrer" to response.installReferrer,
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                "clickTimestamp" to response.referrerClickTimestampSeconds,
+            intent?.getParcelableExtra(Intent.EXTRA_REFERRER, Uri::class.java)
-                "installTimestamp" to response.installBeginTimestampSeconds
-              )
-            )
           } else {
-            Log.d("ExpoGooglePlayReferrer", "Failed to get referrer info. Unknown error.")
+            intent?.getParcelableExtra(Intent.EXTRA_REFERRER)
-            promise.reject(
-              "ERR_GOOGLE_PLAY_REFERRER_UNKNOWN",
-              "Failed to get referrer info",
-              Exception("Failed to get referrer info")
-            )
           }
-          referrerClient.endConnection()
+
+        // Some apps explicitly set a referrer, like Chrome. In these cases, we prefer this since
+        // it's the actual website that the user came from rather than the app.
+        if (intentReferrer is Uri) {
+          val res =
+            mapOf(
+              "referrer" to intentReferrer.toString(),
+              "hostname" to intentReferrer.host,
+            )
+          intent = null
+          return@AsyncFunction res
         }
 
-        override fun onInstallReferrerServiceDisconnected() {
+        // In all other cases, we'll just record the app that sent the intent.
-          Log.d("ExpoGooglePlayReferrer", "Failed to get referrer info. Service disconnected.")
+        if (activityReferrer != null) {
-          referrerClient.endConnection()
+          // referrer could become null here. `.toString()` though can be called on null
-          promise.reject(
+          val res =
-            "ERR_GOOGLE_PLAY_REFERRER_DISCONNECTED",
+            mapOf(
-            "Failed to get referrer info",
+              "referrer" to activityReferrer.toString(),
-            Exception("Failed to get referrer info")
+              "hostname" to (activityReferrer?.host ?: ""),
-          )
+            )
+          activityReferrer = null
+          return@AsyncFunction res
         }
-      })
+
+        return@AsyncFunction null
+      }
+
+      AsyncFunction("getGooglePlayReferrerInfoAsync") { promise: Promise ->
+        val referrerClient = InstallReferrerClient.newBuilder(appContext.reactContext).build()
+        referrerClient.startConnection(
+          object : InstallReferrerStateListener {
+            override fun onInstallReferrerSetupFinished(responseCode: Int) {
+              if (responseCode == InstallReferrerClient.InstallReferrerResponse.OK) {
+                Log.d("ExpoGooglePlayReferrer", "Successfully retrieved referrer info.")
+
+                val response = referrerClient.installReferrer
+                Log.d("ExpoGooglePlayReferrer", "Install referrer: ${response.installReferrer}")
+
+                promise.resolve(
+                  mapOf(
+                    "installReferrer" to response.installReferrer,
+                    "clickTimestamp" to response.referrerClickTimestampSeconds,
+                    "installTimestamp" to response.installBeginTimestampSeconds,
+                  ),
+                )
+              } else {
+                Log.d("ExpoGooglePlayReferrer", "Failed to get referrer info. Unknown error.")
+                promise.reject(
+                  "ERR_GOOGLE_PLAY_REFERRER_UNKNOWN",
+                  "Failed to get referrer info",
+                  Exception("Failed to get referrer info"),
+                )
+              }
+              referrerClient.endConnection()
+            }
+
+            override fun onInstallReferrerServiceDisconnected() {
+              Log.d("ExpoGooglePlayReferrer", "Failed to get referrer info. Service disconnected.")
+              referrerClient.endConnection()
+              promise.reject(
+                "ERR_GOOGLE_PLAY_REFERRER_DISCONNECTED",
+                "Failed to get referrer info",
+                Exception("Failed to get referrer info"),
+              )
+            }
+          },
+        )
+      }
     }
-  }
+}
-}

modules/expo-bluesky-swiss-army/android/src/main/java/expo/modules/blueskyswissarmy/sharedprefs/ExpoBlueskySharedPrefsModule.kt

@@ -0,0 +1,69 @@
+package expo.modules.blueskyswissarmy.sharedprefs
+
+import android.content.Context
+import android.util.Log
+import expo.modules.kotlin.jni.JavaScriptValue
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class ExpoBlueskySharedPrefsModule : Module() {
+  private fun getContext(): Context {
+    val context = appContext.reactContext ?: throw Error("Context is null")
+    return context
+  }
+
+  override fun definition() =
+    ModuleDefinition {
+      Name("ExpoBlueskySharedPrefs")
+
+      Function("setString") { key: String, value: String ->
+        return@Function SharedPrefs(getContext()).setValue(key, value)
+      }
+
+      Function("setValue") { key: String, value: JavaScriptValue ->
+        val context = getContext()
+        Log.d("ExpoBlueskySharedPrefs", "Setting value for key: $key")
+        try {
+          if (value.isNumber()) {
+            SharedPrefs(context).setValue(key, value.getFloat())
+          } else if (value.isBool()) {
+            SharedPrefs(context).setValue(key, value.getBool())
+          } else if (value.isNull() || value.isUndefined()) {
+            SharedPrefs(context).removeValue(key)
+          } else {
+            Log.d(NAME, "Unsupported type: ${value.kind()}")
+          }
+        } catch (e: Error) {
+          Log.d(NAME, "Error setting value: $e")
+        }
+      }
+
+      Function("removeValue") { key: String ->
+        return@Function SharedPrefs(getContext()).removeValue(key)
+      }
+
+      Function("getString") { key: String ->
+        return@Function SharedPrefs(getContext()).getString(key)
+      }
+
+      Function("getNumber") { key: String ->
+        return@Function SharedPrefs(getContext()).getFloat(key)
+      }
+
+      Function("getBool") { key: String ->
+        return@Function SharedPrefs(getContext()).getBoolean(key)
+      }
+
+      Function("addToSet") { key: String, value: String ->
+        return@Function SharedPrefs(getContext()).addToSet(key, value)
+      }
+
+      Function("removeFromSet") { key: String, value: String ->
+        return@Function SharedPrefs(getContext()).removeFromSet(key, value)
+      }
+
+      Function("setContains") { key: String, value: String ->
+        return@Function SharedPrefs(getContext()).setContains(key, value)
+      }
+    }
+}

modules/expo-bluesky-swiss-army/android/src/main/java/expo/modules/blueskyswissarmy/sharedprefs/SharedPrefs.kt

@@ -0,0 +1,241 @@
+package expo.modules.blueskyswissarmy.sharedprefs
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.util.Log
+
+val DEFAULTS =
+  mapOf<String, Any>(
+    "playSoundChat" to true,
+    "playSoundFollow" to false,
+    "playSoundLike" to false,
+    "playSoundMention" to false,
+    "playSoundQuote" to false,
+    "playSoundReply" to false,
+    "playSoundRepost" to false,
+    "badgeCount" to 0,
+  )
+
+const val NAME = "SharedPrefs"
+
+class SharedPrefs(
+  private val context: Context,
+) {
+  companion object {
+    private var hasInitialized = false
+
+    private var instance: SharedPreferences? = null
+
+    fun getInstance(
+      context: Context,
+      info: String? = "(no info)",
+    ): SharedPreferences {
+      if (instance == null) {
+        Log.d(NAME, "No preferences instance found, creating one.")
+        instance = context.getSharedPreferences("xyz.blueskyweb.app", Context.MODE_PRIVATE)
+      }
+
+      val safeInstance = instance ?: throw Error("Preferences is null: $info")
+
+      if (!hasInitialized) {
+        Log.d(NAME, "Preferences instance has not been initialized yet.")
+        initialize(safeInstance)
+        hasInitialized = true
+        Log.d(NAME, "Preferences instance has been initialized.")
+      }
+
+      return safeInstance
+    }
+
+    private fun initialize(instance: SharedPreferences) {
+      instance
+        .edit()
+        .apply {
+          DEFAULTS.forEach { (key, value) ->
+            if (instance.contains(key)) {
+              return@forEach
+            }
+
+            when (value) {
+              is Boolean -> {
+                putBoolean(key, value)
+              }
+
+              is String -> {
+                putString(key, value)
+              }
+
+              is Array<*> -> {
+                putStringSet(key, value.map { it.toString() }.toSet())
+              }
+
+              is Map<*, *> -> {
+                putStringSet(key, value.map { it.toString() }.toSet())
+              }
+            }
+          }
+        }.apply()
+    }
+  }
+
+  fun setValue(
+    key: String,
+    value: String,
+  ) {
+    val safeInstance = getInstance(context)
+    safeInstance
+      .edit()
+      .apply {
+        putString(key, value)
+      }.apply()
+  }
+
+  fun setValue(
+    key: String,
+    value: Float,
+  ) {
+    val safeInstance = getInstance(context)
+    safeInstance
+      .edit()
+      .apply {
+        putFloat(key, value)
+      }.apply()
+  }
+
+  fun setValue(
+    key: String,
+    value: Boolean,
+  ) {
+    val safeInstance = getInstance(context)
+    safeInstance
+      .edit()
+      .apply {
+        putBoolean(key, value)
+      }.apply()
+  }
+
+  fun setValue(
+    key: String,
+    value: Set<String>,
+  ) {
+    val safeInstance = getInstance(context)
+    safeInstance
+      .edit()
+      .apply {
+        putStringSet(key, value)
+      }.apply()
+  }
+
+  fun removeValue(key: String) {
+    val safeInstance = getInstance(context)
+    safeInstance
+      .edit()
+      .apply {
+        remove(key)
+      }.apply()
+  }
+
+  fun getString(key: String): String? {
+    val safeInstance = getInstance(context)
+    return safeInstance.getString(key, null)
+  }
+
+  fun getFloat(key: String): Float? {
+    val safeInstance = getInstance(context)
+    if (!safeInstance.contains(key)) {
+      return null
+    }
+    return safeInstance.getFloat(key, 0.0f)
+  }
+
+  @Suppress("ktlint:standard:function-naming")
+  fun _setAnyValue(
+    key: String,
+    value: Any,
+  ) {
+    val safeInstance = getInstance(context)
+    safeInstance
+      .edit()
+      .apply {
+        when (value) {
+          is String -> putString(key, value)
+          is Float -> putFloat(key, value)
+          is Boolean -> putBoolean(key, value)
+          is Set<*> -> putStringSet(key, value.map { it.toString() }.toSet())
+          else -> throw Error("Unsupported type: ${value::class.java}")
+        }
+      }.apply()
+  }
+
+  fun getBoolean(key: String): Boolean? {
+    val safeInstance = getInstance(context)
+    if (!safeInstance.contains(key)) {
+      return null
+    }
+    Log.d(NAME, "Getting boolean for key: $key")
+    val res = safeInstance.getBoolean(key, false)
+    Log.d(NAME, "Got boolean for key: $key, value: $res")
+    return res
+  }
+
+  fun addToSet(
+    key: String,
+    value: String,
+  ) {
+    val safeInstance = getInstance(context)
+    val set = safeInstance.getStringSet(key, setOf()) ?: setOf()
+    val newSet =
+      set.toMutableSet().apply {
+        add(value)
+      }
+    safeInstance
+      .edit()
+      .apply {
+        putStringSet(key, newSet)
+      }.apply()
+  }
+
+  fun removeFromSet(
+    key: String,
+    value: String,
+  ) {
+    val safeInstance = getInstance(context)
+    val set = safeInstance.getStringSet(key, setOf()) ?: setOf()
+    val newSet =
+      set.toMutableSet().apply {
+        remove(value)
+      }
+    safeInstance
+      .edit()
+      .apply {
+        putStringSet(key, newSet)
+      }.apply()
+  }
+
+  fun setContains(
+    key: String,
+    value: String,
+  ): Boolean {
+    val safeInstance = getInstance(context)
+    val set = safeInstance.getStringSet(key, setOf()) ?: setOf()
+    return set.contains(value)
+  }
+
+  fun hasValue(key: String): Boolean {
+    val safeInstance = getInstance(context)
+    return safeInstance.contains(key)
+  }
+
+  fun getValues(keys: Set<String>): Map<String, Any?> {
+    val safeInstance = getInstance(context)
+    return keys.associateWith { key ->
+      when (val value = safeInstance.all[key]) {
+        is String -> value
+        is Float -> value
+        is Boolean -> value
+        is Set<*> -> value
+        else -> null
+      }
+    }
+  }
+}

modules/expo-bluesky-swiss-army/expo-module.config.json

@@ -1,11 +1,11 @@
 {
   "platforms": ["ios", "tvos", "android", "web"],
   "ios": {
-    "modules": ["ExpoBlueskyDevicePrefsModule", "ExpoBlueskyReferrerModule"]
+    "modules": ["ExpoBlueskySharedPrefsModule", "ExpoBlueskyReferrerModule"]
   },
   "android": {
     "modules": [
-      "expo.modules.blueskyswissarmy.deviceprefs.ExpoBlueskyDevicePrefsModule",
+      "expo.modules.blueskyswissarmy.sharedprefs.ExpoBlueskySharedPrefsModule",
       "expo.modules.blueskyswissarmy.referrer.ExpoBlueskyReferrerModule"
     ]
   }

modules/expo-bluesky-swiss-army/index.ts

@@ -1,4 +1,4 @@
-import * as DevicePrefs from './src/DevicePrefs'
 import * as Referrer from './src/Referrer'
+import * as SharedPrefs from './src/SharedPrefs'
 
-export {DevicePrefs, Referrer}
+export {Referrer, SharedPrefs}

modules/expo-bluesky-swiss-army/ios/DevicePrefs/ExpoBlueskyDevicePrefsModule.swift

@@ -1,23 +0,0 @@
-import ExpoModulesCore
-
-public class ExpoBlueskyDevicePrefsModule: Module {
-  func getDefaults(_ useAppGroup: Bool) -> UserDefaults? {
-    if useAppGroup {
-      return UserDefaults(suiteName: "group.app.bsky")
-    } else {
-      return UserDefaults.standard
-    }
-  }
-
-  public func definition() -> ModuleDefinition {
-    Name("ExpoBlueskyDevicePrefs")
-
-    AsyncFunction("getStringValueAsync") { (key: String, useAppGroup: Bool) in
-      return self.getDefaults(useAppGroup)?.string(forKey: key)
-    }
-
-    AsyncFunction("setStringValueAsync") { (key: String, value: String?, useAppGroup: Bool) in
-      self.getDefaults(useAppGroup)?.setValue(value, forKey: key)
-    }
-  }
-}

modules/expo-bluesky-swiss-army/ios/SharedPrefs/ExpoBlueskySharedPrefsModule.swift

@@ -0,0 +1,62 @@
+import Foundation
+import ExpoModulesCore
+
+public class ExpoBlueskySharedPrefsModule: Module {
+  let defaults = UserDefaults(suiteName: "group.app.bsky")
+
+  func getDefaults(_ info: String = "(no info)") -> UserDefaults? {
+    guard let defaults = self.defaults else {
+      NSLog("Failed to get defaults for app group: \(info)")
+      return nil
+    }
+    return defaults
+  }
+
+  public func definition() -> ModuleDefinition {
+    Name("ExpoBlueskySharedPrefs")
+
+    // JavaScripValue causes a crash when trying to check `isString()`. Let's
+    // explicitly define setString instead.
+    Function("setString") { (key: String, value: String?) in
+      SharedPrefs.shared.setValue(key, value)
+    }
+
+    Function("setValue") { (key: String, value: JavaScriptValue) in
+      if value.isNumber() {
+        SharedPrefs.shared.setValue(key, value.getDouble())
+      } else if value.isBool() {
+        SharedPrefs.shared.setValue(key, value.getBool())
+      } else if value.isNull() || value.isUndefined() {
+        SharedPrefs.shared.removeValue(key)
+      }
+    }
+
+    Function("removeValue") { (key: String) in
+      SharedPrefs.shared.removeValue(key)
+    }
+
+    Function("getString") { (key: String) in
+      return SharedPrefs.shared.getString(key)
+    }
+
+    Function("getBool") { (key: String) in
+      return SharedPrefs.shared.getBool(key)
+    }
+
+    Function("getNumber") { (key: String) in
+      return SharedPrefs.shared.getNumber(key)
+    }
+
+    Function("addToSet") { (key: String, value: String) in
+      SharedPrefs.shared.addToSet(key, value)
+    }
+
+    Function("removeFromSet") { (key: String, value: String) in
+      SharedPrefs.shared.removeFromSet(key, value)
+    }
+
+    Function("setContains") { (key: String, value: String) in
+      return SharedPrefs.shared.setContains(key, value)
+    }
+  }
+}

modules/expo-bluesky-swiss-army/ios/SharedPrefs/SharedPrefs.swift

@@ -0,0 +1,89 @@
+import Foundation
+
+public class SharedPrefs {
+  public static let shared = SharedPrefs()
+
+  private let defaults = UserDefaults(suiteName: "group.app.bsky")
+
+  init() {
+    if defaults == nil {
+      NSLog("Failed to get user defaults for app group.")
+    }
+  }
+
+  private func getDefaults(_ info: String = "(no info)") -> UserDefaults? {
+    guard let defaults = self.defaults else {
+      NSLog("Failed to get defaults for app group: \(info)")
+      return nil
+    }
+    return defaults
+  }
+
+  public func setValue(_ key: String, _ value: String?) {
+    getDefaults(key)?.setValue(value, forKey: key)
+  }
+
+  public func setValue(_ key: String, _ value: Double?) {
+    getDefaults(key)?.setValue(value, forKey: key)
+  }
+
+  public func setValue(_ key: String, _ value: Bool?) {
+    getDefaults(key)?.setValue(value, forKey: key)
+  }
+
+  public func _setAnyValue(_ key: String, _ value: Any?) {
+    getDefaults(key)?.setValue(value, forKey: key)
+  }
+
+  public func removeValue(_ key: String) {
+    getDefaults(key)?.removeObject(forKey: key)
+  }
+
+  public func getString(_ key: String) -> String? {
+    return getDefaults(key)?.string(forKey: key)
+  }
+
+  public func getNumber(_ key: String) -> Double? {
+    return getDefaults(key)?.double(forKey: key)
+  }
+
+  public func getBool(_ key: String) -> Bool? {
+    return getDefaults(key)?.bool(forKey: key)
+  }
+
+  public func addToSet(_ key: String, _ value: String) {
+    var dict: [String: Bool]?
+    if var currDict = getDefaults(key)?.dictionary(forKey: key) as? [String: Bool] {
+      currDict[value] = true
+      dict = currDict
+    } else {
+      dict = [
+        value: true
+      ]
+    }
+    getDefaults(key)?.setValue(dict, forKey: key)
+  }
+
+  public func removeFromSet(_ key: String, _ value: String) {
+    guard var dict = getDefaults(key)?.dictionary(forKey: key) as? [String: Bool] else {
+      return
+    }
+    dict.removeValue(forKey: value)
+    getDefaults(key)?.setValue(dict, forKey: key)
+  }
+
+  public func setContains(_ key: String, _ value: String) -> Bool {
+    guard let dict = getDefaults(key)?.dictionary(forKey: key) as? [String: Bool] else {
+      return false
+    }
+    return dict[value] == true
+  }
+
+  public func hasValue(_ key: String) -> Bool {
+    return getDefaults(key)?.value(forKey: key) != nil
+  }
+
+  public func getValues(_ keys: [String]) -> [String: Any?]? {
+    return getDefaults("keys:\(keys)")?.dictionaryWithValues(forKeys: keys)
+  }
+}

modules/expo-bluesky-swiss-army/src/DevicePrefs/index.ios.ts

@@ -1,18 +0,0 @@
-import {requireNativeModule} from 'expo-modules-core'
-
-const NativeModule = requireNativeModule('ExpoBlueskyDevicePrefs')
-
-export function getStringValueAsync(
-  key: string,
-  useAppGroup?: boolean,
-): Promise<string | null> {
-  return NativeModule.getStringValueAsync(key, useAppGroup)
-}
-
-export function setStringValueAsync(
-  key: string,
-  value: string | null,
-  useAppGroup?: boolean,
-): Promise<void> {
-  return NativeModule.setStringValueAsync(key, value, useAppGroup)
-}

modules/expo-bluesky-swiss-army/src/DevicePrefs/index.ts

@@ -1,16 +0,0 @@
-import {NotImplementedError} from '../NotImplemented'
-
-export function getStringValueAsync(
-  key: string,
-  useAppGroup?: boolean,
-): Promise<string | null> {
-  throw new NotImplementedError({key, useAppGroup})
-}
-
-export function setStringValueAsync(
-  key: string,
-  value: string | null,
-  useAppGroup?: boolean,
-): Promise<string | null> {
-  throw new NotImplementedError({key, value, useAppGroup})
-}

modules/expo-bluesky-swiss-army/src/Referrer/index.android.ts

@@ -1,9 +1,13 @@
 import {requireNativeModule} from 'expo'
 
-import {GooglePlayReferrerInfo} from './types'
+import {GooglePlayReferrerInfo, ReferrerInfo} from './types'
 
 export const NativeModule = requireNativeModule('ExpoBlueskyReferrer')
 
-export function getGooglePlayReferrerInfoAsync(): Promise<GooglePlayReferrerInfo> {
+export function getGooglePlayReferrerInfoAsync(): Promise<GooglePlayReferrerInfo | null> {
   return NativeModule.getGooglePlayReferrerInfoAsync()
 }
+
+export function getReferrerInfoAsync(): Promise<ReferrerInfo | null> {
+  return NativeModule.getReferrerInfoAsync()
+}

modules/expo-bluesky-swiss-army/src/Referrer/index.ios.ts

@@ -0,0 +1,37 @@
+import {SharedPrefs} from '../../index'
+import {NotImplementedError} from '../NotImplemented'
+import {GooglePlayReferrerInfo, ReferrerInfo} from './types'
+
+export function getGooglePlayReferrerInfoAsync(): Promise<GooglePlayReferrerInfo> {
+  throw new NotImplementedError()
+}
+
+export function getReferrerInfoAsync(): Promise<ReferrerInfo | null> {
+  const referrer = SharedPrefs.getString('referrer')
+  if (referrer) {
+    SharedPrefs.removeValue('referrer')
+    try {
+      const url = new URL(referrer)
+      return {
+        referrer,
+        hostname: url.hostname,
+      }
+    } catch (e) {
+      return {
+        referrer,
+        hostname: undefined,
+      }
+    }
+  }
+
+  const referrerApp = SharedPrefs.getString('referrerApp')
+  if (referrerApp) {
+    SharedPrefs.removeValue('referrerApp')
+    return {
+      referrer: referrerApp,
+      hostname: referrerApp,
+    }
+  }
+
+  return null
+}

modules/expo-bluesky-swiss-army/src/Referrer/index.ts

@@ -1,7 +1,10 @@
 import {NotImplementedError} from '../NotImplemented'
-import {GooglePlayReferrerInfo} from './types'
+import {GooglePlayReferrerInfo, ReferrerInfo} from './types'
 
-// @ts-ignore throws
 export function getGooglePlayReferrerInfoAsync(): Promise<GooglePlayReferrerInfo> {
   throw new NotImplementedError()
 }
+
+export function getReferrerInfoAsync(): Promise<ReferrerInfo | null> {
+  throw new NotImplementedError()
+}

modules/expo-bluesky-swiss-army/src/Referrer/index.web.ts

@@ -0,0 +1,33 @@
+import {Platform} from 'react-native'
+
+import {NotImplementedError} from '../NotImplemented'
+import {GooglePlayReferrerInfo, ReferrerInfo} from './types'
+
+export function getGooglePlayReferrerInfoAsync(): Promise<GooglePlayReferrerInfo> {
+  throw new NotImplementedError()
+}
+
+export async function getReferrerInfoAsync(): Promise<ReferrerInfo | null> {
+  if (
+    Platform.OS === 'web' &&
+    // for ssr
+    typeof document !== 'undefined' &&
+    document != null &&
+    document.referrer
+  ) {
+    try {
+      const url = new URL(document.referrer)
+      if (url.hostname !== 'bsky.app') {
+        return {
+          referrer: url.href,
+          hostname: url.hostname,
+        }
+      }
+    } catch {
+      // If something happens to the URL parsing, we don't want to actually cause any problems for the user. Just
+      // log the error so we might catch it
+      console.error('Failed to parse referrer URL')
+    }
+  }
+  return null
+}

modules/expo-bluesky-swiss-army/src/Referrer/types.ts

@@ -1,7 +1,10 @@
-export type GooglePlayReferrerInfo =
+export type GooglePlayReferrerInfo = {
-  | {
+  installReferrer?: string
-      installReferrer?: string
+  clickTimestamp?: number
-      clickTimestamp?: number
+  installTimestamp?: number
-      installTimestamp?: number
+}
-    }
+
-  | undefined
+export type ReferrerInfo = {
+  referrer: string
+  hostname: string
+}

modules/expo-bluesky-swiss-army/src/SharedPrefs/index.native.ts

@@ -0,0 +1,51 @@
+import {requireNativeModule} from 'expo-modules-core'
+
+const NativeModule = requireNativeModule('ExpoBlueskySharedPrefs')
+
+export function setValue(
+  key: string,
+  value: string | number | boolean | null | undefined,
+): void {
+  // A bug on Android causes `JavaScripValue.isString()` to cause a crash on some occasions, seemingly because of a
+  // memory violation. Instead, we will use a specific function to set strings on this platform.
+  if (typeof value === 'string') {
+    return NativeModule.setString(key, value)
+  }
+  return NativeModule.setValue(key, value)
+}
+
+export function removeValue(key: string): void {
+  return NativeModule.removeValue(key)
+}
+
+export function getString(key: string): string | undefined {
+  return nullToUndefined(NativeModule.getString(key))
+}
+
+export function getNumber(key: string): number | undefined {
+  return nullToUndefined(NativeModule.getNumber(key))
+}
+
+export function getBool(key: string): boolean | undefined {
+  return nullToUndefined(NativeModule.getBool(key))
+}
+
+export function addToSet(key: string, value: string): void {
+  return NativeModule.addToSet(key, value)
+}
+
+export function removeFromSet(key: string, value: string): void {
+  return NativeModule.removeFromSet(key, value)
+}
+
+export function setContains(key: string, value: string): boolean {
+  return NativeModule.setContains(key, value)
+}
+
+// iOS returns `null` if a value does not exist, and Android returns `undefined. Normalize these here for JS types
+function nullToUndefined(value: any) {
+  if (value == null) {
+    return undefined
+  }
+  return value
+}

modules/expo-bluesky-swiss-army/src/SharedPrefs/index.ts

@@ -0,0 +1,36 @@
+import {NotImplementedError} from '../NotImplemented'
+
+export function setValue(
+  key: string,
+  value: string | number | boolean | null | undefined,
+): void {
+  throw new NotImplementedError({key, value})
+}
+
+export function removeValue(key: string): void {
+  throw new NotImplementedError({key})
+}
+
+export function getString(key: string): string | null {
+  throw new NotImplementedError({key})
+}
+
+export function getNumber(key: string): number | null {
+  throw new NotImplementedError({key})
+}
+
+export function getBool(key: string): boolean | null {
+  throw new NotImplementedError({key})
+}
+
+export function addToSet(key: string, value: string): void {
+  throw new NotImplementedError({key, value})
+}
+
+export function removeFromSet(key: string, value: string): void {
+  throw new NotImplementedError({key, value})
+}
+
+export function setContains(key: string, value: string): boolean {
+  throw new NotImplementedError({key, value})
+}

modules/expo-receive-android-intents/android/src/main/java/xyz/blueskyweb/app/exporeceiveandroidintents/ExpoReceiveAndroidIntentsModule.kt

@@ -13,16 +13,17 @@ import java.io.FileOutputStream
 import java.net.URLEncoder
 
 class ExpoReceiveAndroidIntentsModule : Module() {
-  override fun definition() = ModuleDefinition {
+  override fun definition() =
-    Name("ExpoReceiveAndroidIntents")
+    ModuleDefinition {
+      Name("ExpoReceiveAndroidIntents")
 
-    OnNewIntent {
+      OnNewIntent {
-      handleIntent(it)
+        handleIntent(it)
+      }
     }
-  }
 
   private fun handleIntent(intent: Intent?) {
-    if(appContext.currentActivity == null || intent == null) return
+    if (appContext.currentActivity == null || intent == null) return
 
     if (intent.action == Intent.ACTION_SEND) {
       if (intent.type == "text/plain") {
@@ -40,7 +41,7 @@ class ExpoReceiveAndroidIntentsModule : Module() {
   private fun handleTextIntent(intent: Intent) {
     intent.getStringExtra(Intent.EXTRA_TEXT)?.let {
       val encoded = URLEncoder.encode(it, "UTF-8")
-      "bluesky://intent/compose?text=${encoded}".toUri().let { uri ->
+      "bluesky://intent/compose?text=$encoded".toUri().let { uri ->
         val newIntent = Intent(Intent.ACTION_VIEW, uri)
         appContext.currentActivity?.startActivity(newIntent)
       }
@@ -48,11 +49,12 @@ class ExpoReceiveAndroidIntentsModule : Module() {
   }
 
   private fun handleImageIntent(intent: Intent) {
-    val uri = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+    val uri =
-      intent.getParcelableExtra(Intent.EXTRA_STREAM, Uri::class.java)
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-    } else {
+        intent.getParcelableExtra(Intent.EXTRA_STREAM, Uri::class.java)
-      intent.getParcelableExtra(Intent.EXTRA_STREAM)
+      } else {
-    }
+        intent.getParcelableExtra(Intent.EXTRA_STREAM)
+      }
     if (uri == null) return
 
     handleImageIntents(listOf(uri))
@@ -76,16 +78,16 @@ class ExpoReceiveAndroidIntentsModule : Module() {
     uris.forEachIndexed { index, uri ->
       val info = getImageInfo(uri)
       val params = buildUriData(info)
-      allParams = "${allParams}${params}"
+      allParams = "${allParams}$params"
 
       if (index < uris.count() - 1) {
-        allParams = "${allParams},"
+        allParams = "$allParams,"
       }
     }
 
     val encoded = URLEncoder.encode(allParams, "UTF-8")
 
-    "bluesky://intent/compose?imageUris=${encoded}".toUri().let {
+    "bluesky://intent/compose?imageUris=$encoded".toUri().let {
       val newIntent = Intent(Intent.ACTION_VIEW, it)
       appContext.currentActivity?.startActivity(newIntent)
     }
@@ -104,7 +106,7 @@ class ExpoReceiveAndroidIntentsModule : Module() {
     return mapOf(
       "width" to bitmap.width,
       "height" to bitmap.height,
-      "path" to file.path.toString()
+      "path" to file.path.toString(),
     )
   }
 
@@ -114,6 +116,6 @@ class ExpoReceiveAndroidIntentsModule : Module() {
     val path = info.getValue("path")
     val width = info.getValue("width")
     val height = info.getValue("height")
-    return "file://${path}|${width}|${height}"
+    return "file://$path|$width|$height"
   }
 }

modules/expo-scroll-forwarder/ios/ExpoScrollForwarderModule.swift

@@ -3,7 +3,7 @@ import ExpoModulesCore
 public class ExpoScrollForwarderModule: Module {
   public func definition() -> ModuleDefinition {
     Name("ExpoScrollForwarder")
-    
+
     View(ExpoScrollForwarderView.self) {
       Prop("scrollViewTag") { (view: ExpoScrollForwarderView, prop: Int) in
         view.scrollViewTag = prop

modules/expo-scroll-forwarder/ios/ExpoScrollForwarderView.swift

@@ -8,17 +8,17 @@ class ExpoScrollForwarderView: ExpoView, UIGestureRecognizerDelegate {
       self.tryFindScrollView()
     }
   }
-  
+
   private var rctScrollView: RCTScrollView?
   private var rctRefreshCtrl: RCTRefreshControl?
   private var cancelGestureRecognizers: [UIGestureRecognizer]?
   private var animTimer: Timer?
   private var initialOffset: CGFloat = 0.0
   private var didImpact: Bool = false
-  
+
   required init(appContext: AppContext? = nil) {
     super.init(appContext: appContext)
-    
+
     let pg = UIPanGestureRecognizer(target: self, action: #selector(callOnPan(_:)))
     pg.delegate = self
     self.addGestureRecognizer(pg)
@@ -34,28 +34,27 @@ class ExpoScrollForwarderView: ExpoView, UIGestureRecognizerDelegate {
 
     self.cancelGestureRecognizers = [lpg, tg]
   }
-  
 
   // We don't want to recognize the scroll pan gesture and the swipe back gesture together
   func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
     if gestureRecognizer is UIPanGestureRecognizer, otherGestureRecognizer is UIPanGestureRecognizer {
       return false
     }
-    
+
     return true
   }
-  
+
   // We only want the "scroll" gesture to happen whenever the pan is vertical, otherwise it will
   // interfere with the native swipe back gesture.
   override func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
     guard let gestureRecognizer = gestureRecognizer as? UIPanGestureRecognizer else {
       return true
     }
-    
+
     let velocity = gestureRecognizer.velocity(in: self)
     return abs(velocity.y) > abs(velocity.x)
   }
-  
+
   // This will be used to cancel the scroll animation whenever we tap inside of the header. We don't need another
   // recognizer for this one.
   override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
@@ -64,32 +63,32 @@ class ExpoScrollForwarderView: ExpoView, UIGestureRecognizerDelegate {
 
   // This will be used to cancel the animation whenever we press inside of the scroll view. We don't want to change
   // the scroll view gesture's delegate, so we add an additional recognizer to detect this.
-  @IBAction func callOnPress(_ sender: UITapGestureRecognizer) -> Void {
+  @IBAction func callOnPress(_ sender: UITapGestureRecognizer) {
     self.stopTimer()
   }
-  
+
-  @IBAction func callOnPan(_ sender: UIPanGestureRecognizer) -> Void {
+  @IBAction func callOnPan(_ sender: UIPanGestureRecognizer) {
     guard let rctsv = self.rctScrollView, let sv = rctsv.scrollView else {
       return
     }
 
     let translation = sender.translation(in: self).y
-    
+
     if sender.state == .began {
       if sv.contentOffset.y < 0 {
         sv.contentOffset.y = 0
       }
-      
+
       self.initialOffset = sv.contentOffset.y
     }
 
     if sender.state == .changed {
       sv.contentOffset.y = self.dampenOffset(-translation + self.initialOffset)
-      
+
       if sv.contentOffset.y <= -130, !didImpact {
         let generator = UIImpactFeedbackGenerator(style: .light)
         generator.impactOccurred()
-        
+
         self.didImpact = true
       }
     }
@@ -97,7 +96,7 @@ class ExpoScrollForwarderView: ExpoView, UIGestureRecognizerDelegate {
     if sender.state == .ended {
       let velocity = sender.velocity(in: self).y
       self.didImpact = false
-      
+
       if sv.contentOffset.y <= -130 {
         self.rctRefreshCtrl?.forwarderBeginRefreshing()
         return
@@ -108,40 +107,40 @@ class ExpoScrollForwarderView: ExpoView, UIGestureRecognizerDelegate {
       if abs(velocity) < 250, sv.contentOffset.y >= 0 {
         return
       }
-      
+
       self.startDecayAnimation(translation, velocity)
     }
   }
-  
+
   func startDecayAnimation(_ translation: CGFloat, _ velocity: CGFloat) {
     guard let sv = self.rctScrollView?.scrollView else {
       return
     }
-    
+
     var velocity = velocity
-    
+
     self.enableCancelGestureRecognizers()
-    
+
     if velocity > 0 {
       velocity = min(velocity, 5000)
     } else {
       velocity = max(velocity, -5000)
     }
-    
+
     var animTranslation = -translation
-    self.animTimer = Timer.scheduledTimer(withTimeInterval: 1.0 / 120, repeats: true) { timer in
+    self.animTimer = Timer.scheduledTimer(withTimeInterval: 1.0 / 120, repeats: true) { _ in
       velocity *= 0.9875
       animTranslation = (-velocity / 120) + animTranslation
-      
+
       let nextOffset = self.dampenOffset(animTranslation + self.initialOffset)
-      
+
       if nextOffset <= 0 {
         if self.initialOffset <= 1 {
           self.scrollToOffset(0)
         } else {
           sv.contentOffset.y = 0
         }
-        
+
         self.stopTimer()
         return
       } else {
@@ -153,61 +152,60 @@ class ExpoScrollForwarderView: ExpoView, UIGestureRecognizerDelegate {
       }
     }
   }
-  
+
   func dampenOffset(_ offset: CGFloat) -> CGFloat {
     if offset < 0 {
       return offset - (offset * 0.55)
     }
-    
+
     return offset
   }
-  
+
   func tryFindScrollView() {
     guard let scrollViewTag = scrollViewTag else {
       return
     }
-    
+
     // Before we switch to a different scrollview, we always want to remove the cancel gesture recognizer.
     // Otherwise we might end up with duplicates when we switch back to that scrollview.
     self.removeCancelGestureRecognizers()
-    
+
     self.rctScrollView = self.appContext?
       .findView(withTag: scrollViewTag, ofType: RCTScrollView.self)
     self.rctRefreshCtrl = self.rctScrollView?.scrollView.refreshControl as? RCTRefreshControl
-    
+
     self.addCancelGestureRecognizers()
   }
-  
+
   func addCancelGestureRecognizers() {
     self.cancelGestureRecognizers?.forEach { r in
       self.rctScrollView?.scrollView?.addGestureRecognizer(r)
     }
   }
-  
+
   func removeCancelGestureRecognizers() {
     self.cancelGestureRecognizers?.forEach { r in
       self.rctScrollView?.scrollView?.removeGestureRecognizer(r)
     }
   }
 
-  
   func enableCancelGestureRecognizers() {
     self.cancelGestureRecognizers?.forEach { r in
       r.isEnabled = true
     }
   }
-  
+
   func disableCancelGestureRecognizers() {
     self.cancelGestureRecognizers?.forEach { r in
       r.isEnabled = false
     }
   }
-  
+
-  func scrollToOffset(_ offset: Int, animated: Bool = true) -> Void {
+  func scrollToOffset(_ offset: Int, animated: Bool = true) {
     self.rctScrollView?.scroll(toOffset: CGPoint(x: 0, y: offset), animated: animated)
   }
 
-  func stopTimer() -> Void {
+  func stopTimer() {
     self.disableCancelGestureRecognizers()
     self.animTimer?.invalidate()
     self.animTimer = nil

package.json

@@ -1,6 +1,6 @@
 {
   "name": "bsky.app",
-  "version": "1.88.0",
+  "version": "1.89.0",
   "private": true,
   "engines": {
     "node": ">=18"
@@ -29,9 +29,12 @@
     "test-ci": "NODE_ENV=test jest --ci --forceExit --reporters=default --reporters=jest-junit",
     "test-coverage": "NODE_ENV=test jest --coverage",
     "lint": "eslint --cache --ext .js,.jsx,.ts,.tsx src",
+    "lint-native": "swiftlint ./modules && ktlint ./modules",
+    "lint-native:fix": "swiftlint --fix ./modules && ktlint --format ./modules",
     "typecheck": "tsc --project ./tsconfig.check.json",
     "e2e:mock-server": "./jest/dev-infra/with-test-redis-and-db.sh ts-node --project tsconfig.e2e.json __e2e__/mock-server.ts",
     "e2e:metro": "EXPO_PUBLIC_ENV=e2e NODE_ENV=test RN_SRC_EXT=e2e.ts,e2e.tsx expo run:ios",
+    "e2e:metro-android": "EXPO_PUBLIC_ENV=e2e NODE_ENV=test RN_SRC_EXT=e2e.ts,e2e.tsx expo run:android",
     "e2e:run": "maestro test __e2e__",
     "perf:test": "NODE_ENV=test maestro test",
     "perf:test:run": "NODE_ENV=test maestro test __e2e__/perf-test.yml",

plugins/withAppDelegateReferrer.js

@@ -0,0 +1,41 @@
+const {withAppDelegate} = require('@expo/config-plugins')
+const {mergeContents} = require('@expo/config-plugins/build/utils/generateCode')
+const path = require('path')
+const fs = require('fs')
+
+module.exports = config => {
+  // eslint-disable-next-line no-shadow
+  return withAppDelegate(config, async config => {
+    const delegatePath = path.join(
+      config.modRequest.platformProjectRoot,
+      'AppDelegate.mm',
+    )
+
+    let newContents = config.modResults.contents
+    newContents = mergeContents({
+      src: newContents,
+      anchor: '// Linking API',
+      newSrc: `
+  NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+  [defaults setObject:options[UIApplicationOpenURLOptionsSourceApplicationKey] forKey:@"referrerApp"];\n`,
+      offset: 2,
+      tag: 'referrer info - deep links',
+      comment: '//',
+    }).contents
+
+    newContents = mergeContents({
+      src: newContents,
+      anchor: '// Universal Links',
+      newSrc: `
+  NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+  [defaults setURL:userActivity.referrerURL forKey:@"referrer"];\n`,
+      offset: 2,
+      tag: 'referrer info - universal links',
+      comment: '//',
+    }).contents
+
+    config.modResults.contents = newContents
+
+    return config
+  })
+}

src/Navigation.tsx

@@ -31,7 +31,7 @@ import {
 } from 'lib/routes/types'
 import {RouteParams, State} from 'lib/routes/types'
 import {bskyTitle} from 'lib/strings/headings'
-import {isAndroid, isNative} from 'platform/detection'
+import {isAndroid, isNative, isWeb} from 'platform/detection'
 import {PreferencesExternalEmbeds} from '#/view/screens/PreferencesExternalEmbeds'
 import {AppPasswords} from 'view/screens/AppPasswords'
 import {ModerationBlockedAccounts} from 'view/screens/ModerationBlockedAccounts'
@@ -39,6 +39,7 @@ import {ModerationMutedAccounts} from 'view/screens/ModerationMutedAccounts'
 import {PreferencesFollowingFeed} from 'view/screens/PreferencesFollowingFeed'
 import {PreferencesThreads} from 'view/screens/PreferencesThreads'
 import {SavedFeeds} from 'view/screens/SavedFeeds'
+import {SharedPreferencesTesterScreen} from '#/screens/E2E/SharedPreferencesTesterScreen'
 import HashtagScreen from '#/screens/Hashtag'
 import {ModerationScreen} from '#/screens/Moderation'
 import {ProfileKnownFollowersScreen} from '#/screens/Profile/KnownFollowers'
@@ -48,6 +49,7 @@ import {
   StarterPackScreenShort,
 } from '#/screens/StarterPack/StarterPackScreen'
 import {Wizard} from '#/screens/StarterPack/Wizard'
+import {Referrer} from '../modules/expo-bluesky-swiss-army'
 import {init as initAnalytics} from './lib/analytics/analytics'
 import {useWebScrollRestoration} from './lib/hooks/useWebScrollRestoration'
 import {attachRouteToLogEvents, logEvent} from './lib/statsig/statsig'
@@ -233,6 +235,11 @@ function commonScreens(Stack: typeof HomeTab, unreadCountLabel?: string) {
         getComponent={() => DebugModScreen}
         options={{title: title(msg`Moderation states`), requireAuth: true}}
       />
+      <Stack.Screen
+        name="SharedPreferencesTester"
+        getComponent={() => SharedPreferencesTesterScreen}
+        options={{title: title(msg`Shared Preferences Tester`)}}
+      />
       <Stack.Screen
         name="Log"
         getComponent={() => LogScreen}
@@ -763,6 +770,18 @@ function logModuleInitTime() {
     initMs,
   })
 
+  if (isWeb) {
+    Referrer.getReferrerInfoAsync().then(info => {
+      if (info && info.hostname !== 'bsky.app') {
+        logEvent('deepLink:referrerReceived', {
+          to: window.location.href,
+          referrer: info?.referrer,
+          hostname: info?.hostname,
+        })
+      }
+    })
+  }
+
   if (__DEV__) {
     // This log is noisy, so keep false committed
     const shouldLog = false

src/alf/index.tsx

@@ -1,7 +1,9 @@
 import React from 'react'
 import {Dimensions} from 'react-native'
 
-import * as themes from '#/alf/themes'
+import {createThemes, defaultTheme} from '#/alf/themes'
+import {Theme, ThemeName} from '#/alf/types'
+import {BLUE_HUE, GREEN_HUE, RED_HUE} from '#/alf/util/colorGeneration'
 
 export {atoms} from '#/alf/atoms'
 export * as tokens from '#/alf/tokens'
@@ -39,8 +41,8 @@ function getActiveBreakpoints({width}: {width: number}) {
  * Context
  */
 export const Context = React.createContext<{
-  themeName: themes.ThemeName
+  themeName: ThemeName
-  theme: themes.Theme
+  theme: Theme
   breakpoints: {
     active: BreakpointName | undefined
     gtPhone: boolean
@@ -49,7 +51,7 @@ export const Context = React.createContext<{
   }
 }>({
   themeName: 'light',
-  theme: themes.light,
+  theme: defaultTheme,
   breakpoints: {
     active: undefined,
     gtPhone: false,
@@ -61,7 +63,16 @@ export const Context = React.createContext<{
 export function ThemeProvider({
   children,
   theme: themeName,
-}: React.PropsWithChildren<{theme: themes.ThemeName}>) {
+}: React.PropsWithChildren<{theme: ThemeName}>) {
+  const themes = React.useMemo(() => {
+    return createThemes({
+      hues: {
+        primary: BLUE_HUE,
+        negative: RED_HUE,
+        positive: GREEN_HUE,
+      },
+    })
+  }, [])
   const theme = themes[themeName]
   const [breakpoints, setBreakpoints] = React.useState(() =>
     getActiveBreakpoints({width: Dimensions.get('window').width}),

src/alf/tokens.ts

@@ -1,77 +1,6 @@
-import {
-  BLUE_HUE,
-  generateScale,
-  GREEN_HUE,
-  RED_HUE,
-} from '#/alf/util/colorGeneration'
-
-export const scale = generateScale(6, 100)
-// dim shifted 6% lighter
-export const dimScale = generateScale(12, 100)
-
 export const color = {
-  trueBlack: '#000000',
-
   temp_purple: 'rgb(105 0 255)',
   temp_purple_dark: 'rgb(83 0 202)',
-
-  gray_0: `hsl(${BLUE_HUE}, 20%, ${scale[14]}%)`,
-  gray_25: `hsl(${BLUE_HUE}, 20%, ${scale[13]}%)`,
-  gray_50: `hsl(${BLUE_HUE}, 20%, ${scale[12]}%)`,
-  gray_100: `hsl(${BLUE_HUE}, 20%, ${scale[11]}%)`,
-  gray_200: `hsl(${BLUE_HUE}, 20%, ${scale[10]}%)`,
-  gray_300: `hsl(${BLUE_HUE}, 20%, ${scale[9]}%)`,
-  gray_400: `hsl(${BLUE_HUE}, 20%, ${scale[8]}%)`,
-  gray_500: `hsl(${BLUE_HUE}, 20%, ${scale[7]}%)`,
-  gray_600: `hsl(${BLUE_HUE}, 24%, ${scale[6]}%)`,
-  gray_700: `hsl(${BLUE_HUE}, 24%, ${scale[5]}%)`,
-  gray_800: `hsl(${BLUE_HUE}, 28%, ${scale[4]}%)`,
-  gray_900: `hsl(${BLUE_HUE}, 28%, ${scale[3]}%)`,
-  gray_950: `hsl(${BLUE_HUE}, 28%, ${scale[2]}%)`,
-  gray_975: `hsl(${BLUE_HUE}, 28%, ${scale[1]}%)`,
-  gray_1000: `hsl(${BLUE_HUE}, 28%, ${scale[0]}%)`,
-
-  blue_25: `hsl(${BLUE_HUE}, 99%, 97%)`,
-  blue_50: `hsl(${BLUE_HUE}, 99%, 95%)`,
-  blue_100: `hsl(${BLUE_HUE}, 99%, 90%)`,
-  blue_200: `hsl(${BLUE_HUE}, 99%, 80%)`,
-  blue_300: `hsl(${BLUE_HUE}, 99%, 70%)`,
-  blue_400: `hsl(${BLUE_HUE}, 99%, 60%)`,
-  blue_500: `hsl(${BLUE_HUE}, 99%, 53%)`,
-  blue_600: `hsl(${BLUE_HUE}, 99%, 42%)`,
-  blue_700: `hsl(${BLUE_HUE}, 99%, 34%)`,
-  blue_800: `hsl(${BLUE_HUE}, 99%, 26%)`,
-  blue_900: `hsl(${BLUE_HUE}, 99%, 18%)`,
-  blue_950: `hsl(${BLUE_HUE}, 99%, 10%)`,
-  blue_975: `hsl(${BLUE_HUE}, 99%, 7%)`,
-
-  green_25: `hsl(${GREEN_HUE}, 82%, 97%)`,
-  green_50: `hsl(${GREEN_HUE}, 82%, 95%)`,
-  green_100: `hsl(${GREEN_HUE}, 82%, 90%)`,
-  green_200: `hsl(${GREEN_HUE}, 82%, 80%)`,
-  green_300: `hsl(${GREEN_HUE}, 82%, 70%)`,
-  green_400: `hsl(${GREEN_HUE}, 82%, 60%)`,
-  green_500: `hsl(${GREEN_HUE}, 82%, 50%)`,
-  green_600: `hsl(${GREEN_HUE}, 82%, 42%)`,
-  green_700: `hsl(${GREEN_HUE}, 82%, 34%)`,
-  green_800: `hsl(${GREEN_HUE}, 82%, 26%)`,
-  green_900: `hsl(${GREEN_HUE}, 82%, 18%)`,
-  green_950: `hsl(${GREEN_HUE}, 82%, 10%)`,
-  green_975: `hsl(${GREEN_HUE}, 82%, 7%)`,
-
-  red_25: `hsl(${RED_HUE}, 91%, 97%)`,
-  red_50: `hsl(${RED_HUE}, 91%, 95%)`,
-  red_100: `hsl(${RED_HUE}, 91%, 90%)`,
-  red_200: `hsl(${RED_HUE}, 91%, 80%)`,
-  red_300: `hsl(${RED_HUE}, 91%, 70%)`,
-  red_400: `hsl(${RED_HUE}, 91%, 60%)`,
-  red_500: `hsl(${RED_HUE}, 91%, 50%)`,
-  red_600: `hsl(${RED_HUE}, 91%, 42%)`,
-  red_700: `hsl(${RED_HUE}, 91%, 34%)`,
-  red_800: `hsl(${RED_HUE}, 91%, 26%)`,
-  red_900: `hsl(${RED_HUE}, 91%, 18%)`,
-  red_950: `hsl(${RED_HUE}, 91%, 10%)`,
-  red_975: `hsl(${RED_HUE}, 91%, 7%)`,
 } as const
 
 export const space = {
@@ -178,10 +107,3 @@ export const gradients = {
     hover_value: '#755B62',
   },
 } as const
-
-export type Color = keyof typeof color
-export type Space = keyof typeof space
-export type FontSize = keyof typeof fontSize
-export type LineHeight = keyof typeof lineHeight
-export type BorderRadius = keyof typeof borderRadius
-export type FontWeight = keyof typeof fontWeight

src/alf/types.ts

@@ -1,21 +1,4 @@
-import {StyleProp, ViewStyle, TextStyle} from 'react-native'
+import {StyleProp, TextStyle, ViewStyle} from 'react-native'
-
-type LiteralToCommon<T extends PropertyKey> = T extends number
-  ? number
-  : T extends string
-  ? string
-  : T extends symbol
-  ? symbol
-  : never
-
-/**
- * @see https://stackoverflow.com/questions/68249999/use-as-const-in-typescript-without-adding-readonly-modifiers
- */
-export type Mutable<T> = {
-  -readonly [K in keyof T]: T[K] extends PropertyKey
-    ? LiteralToCommon<T[K]>
-    : Mutable<T[K]>
-}
 
 export type TextStyleProp = {
   style?: StyleProp<TextStyle>
@@ -24,3 +7,156 @@ export type TextStyleProp = {
 export type ViewStyleProp = {
   style?: StyleProp<ViewStyle>
 }
+
+export type ThemeName = 'light' | 'dim' | 'dark'
+export type Palette = {
+  white: string
+  black: string
+
+  contrast_25: string
+  contrast_50: string
+  contrast_100: string
+  contrast_200: string
+  contrast_300: string
+  contrast_400: string
+  contrast_500: string
+  contrast_600: string
+  contrast_700: string
+  contrast_800: string
+  contrast_900: string
+  contrast_950: string
+  contrast_975: string
+
+  primary_25: string
+  primary_50: string
+  primary_100: string
+  primary_200: string
+  primary_300: string
+  primary_400: string
+  primary_500: string
+  primary_600: string
+  primary_700: string
+  primary_800: string
+  primary_900: string
+  primary_950: string
+  primary_975: string
+
+  positive_25: string
+  positive_50: string
+  positive_100: string
+  positive_200: string
+  positive_300: string
+  positive_400: string
+  positive_500: string
+  positive_600: string
+  positive_700: string
+  positive_800: string
+  positive_900: string
+  positive_950: string
+  positive_975: string
+
+  negative_25: string
+  negative_50: string
+  negative_100: string
+  negative_200: string
+  negative_300: string
+  negative_400: string
+  negative_500: string
+  negative_600: string
+  negative_700: string
+  negative_800: string
+  negative_900: string
+  negative_950: string
+  negative_975: string
+}
+export type ThemedAtoms = {
+  text: {
+    color: string
+  }
+  text_contrast_low: {
+    color: string
+  }
+  text_contrast_medium: {
+    color: string
+  }
+  text_contrast_high: {
+    color: string
+  }
+  text_inverted: {
+    color: string
+  }
+  bg: {
+    backgroundColor: string
+  }
+  bg_contrast_25: {
+    backgroundColor: string
+  }
+  bg_contrast_50: {
+    backgroundColor: string
+  }
+  bg_contrast_100: {
+    backgroundColor: string
+  }
+  bg_contrast_200: {
+    backgroundColor: string
+  }
+  bg_contrast_300: {
+    backgroundColor: string
+  }
+  bg_contrast_400: {
+    backgroundColor: string
+  }
+  bg_contrast_500: {
+    backgroundColor: string
+  }
+  bg_contrast_600: {
+    backgroundColor: string
+  }
+  bg_contrast_700: {
+    backgroundColor: string
+  }
+  bg_contrast_800: {
+    backgroundColor: string
+  }
+  bg_contrast_900: {
+    backgroundColor: string
+  }
+  bg_contrast_950: {
+    backgroundColor: string
+  }
+  bg_contrast_975: {
+    backgroundColor: string
+  }
+  border_contrast_low: {
+    borderColor: string
+  }
+  border_contrast_medium: {
+    borderColor: string
+  }
+  border_contrast_high: {
+    borderColor: string
+  }
+  shadow_sm: {
+    shadowRadius: number
+    shadowOpacity: number
+    elevation: number
+    shadowColor: string
+  }
+  shadow_md: {
+    shadowRadius: number
+    shadowOpacity: number
+    elevation: number
+    shadowColor: string
+  }
+  shadow_lg: {
+    shadowRadius: number
+    shadowOpacity: number
+    elevation: number
+    shadowColor: string
+  }
+}
+export type Theme = {
+  name: ThemeName
+  palette: Palette
+  atoms: ThemedAtoms
+}

src/alf/util/colorGeneration.ts

@@ -15,3 +15,7 @@ export function generateScale(start: number, end: number) {
     return start + range * stop
   })
 }
+
+export const defaultScale = generateScale(6, 100)
+// dim shifted 6% lighter
+export const dimScale = generateScale(12, 100)

src/alf/util/themeSelector.ts

@@ -1,4 +1,4 @@
-import {ThemeName} from '#/alf/themes'
+import {ThemeName} from '#/alf/types'
 
 export function select<T>(name: ThemeName, options: Record<ThemeName, T>) {
   switch (name) {

src/alf/util/useColorModeTheme.ts

@@ -4,7 +4,8 @@ import * as SystemUI from 'expo-system-ui'
 
 import {isWeb} from 'platform/detection'
 import {useThemePrefs} from 'state/shell'
-import {dark, dim, light, ThemeName} from '#/alf/themes'
+import {dark, dim, light} from '#/alf/themes'
+import {ThemeName} from '#/alf/types'
 
 export function useColorModeTheme(): ThemeName {
   const theme = useThemeName()

src/components/Button.tsx

@@ -13,7 +13,7 @@ import {
 } from 'react-native'
 import {LinearGradient} from 'expo-linear-gradient'
 
-import {android, atoms as a, flatten, tokens, useTheme} from '#/alf'
+import {android, atoms as a, flatten, select, tokens, useTheme} from '#/alf'
 import {Props as SVGIconProps} from '#/components/icons/common'
 import {normalizeTextStyles} from '#/components/Typography'
 
@@ -152,7 +152,6 @@ export const Button = React.forwardRef<View, ButtonProps>(
     const {baseStyles, hoverStyles} = React.useMemo(() => {
       const baseStyles: ViewStyle[] = []
       const hoverStyles: ViewStyle[] = []
-      const light = t.name === 'light'
 
       if (color === 'primary') {
         if (variant === 'solid') {
@@ -165,7 +164,11 @@ export const Button = React.forwardRef<View, ButtonProps>(
             })
           } else {
             baseStyles.push({
-              backgroundColor: t.palette.primary_700,
+              backgroundColor: select(t.name, {
+                light: t.palette.primary_700,
+                dim: t.palette.primary_300,
+                dark: t.palette.primary_300,
+              }),
             })
           }
         } else if (variant === 'outline') {
@@ -178,24 +181,18 @@ export const Button = React.forwardRef<View, ButtonProps>(
               borderColor: t.palette.primary_500,
             })
             hoverStyles.push(a.border, {
-              backgroundColor: light
+              backgroundColor: t.palette.primary_50,
-                ? t.palette.primary_50
-                : t.palette.primary_950,
             })
           } else {
             baseStyles.push(a.border, {
-              borderColor: light
+              borderColor: t.palette.primary_200,
-                ? t.palette.primary_200
-                : t.palette.primary_900,
             })
           }
         } else if (variant === 'ghost') {
           if (!disabled) {
             baseStyles.push(t.atoms.bg)
             hoverStyles.push({
-              backgroundColor: light
+              backgroundColor: t.palette.primary_100,
-                ? t.palette.primary_100
-                : t.palette.primary_900,
             })
           }
         }
@@ -203,14 +200,26 @@ export const Button = React.forwardRef<View, ButtonProps>(
         if (variant === 'solid') {
           if (!disabled) {
             baseStyles.push({
-              backgroundColor: t.palette.contrast_25,
+              backgroundColor: select(t.name, {
+                light: t.palette.contrast_25,
+                dim: t.palette.contrast_100,
+                dark: t.palette.contrast_100,
+              }),
             })
             hoverStyles.push({
-              backgroundColor: t.palette.contrast_50,
+              backgroundColor: select(t.name, {
+                light: t.palette.contrast_50,
+                dim: t.palette.contrast_200,
+                dark: t.palette.contrast_200,
+              }),
             })
           } else {
             baseStyles.push({
-              backgroundColor: t.palette.contrast_100,
+              backgroundColor: select(t.name, {
+                light: t.palette.contrast_100,
+                dim: t.palette.contrast_25,
+                dark: t.palette.contrast_25,
+              }),
             })
           }
         } else if (variant === 'outline') {
@@ -247,7 +256,7 @@ export const Button = React.forwardRef<View, ButtonProps>(
             })
           } else {
             baseStyles.push({
-              backgroundColor: t.palette.contrast_700,
+              backgroundColor: t.palette.contrast_600,
             })
           }
         } else if (variant === 'outline') {
@@ -284,7 +293,11 @@ export const Button = React.forwardRef<View, ButtonProps>(
             })
           } else {
             baseStyles.push({
-              backgroundColor: t.palette.negative_700,
+              backgroundColor: select(t.name, {
+                light: t.palette.negative_700,
+                dim: t.palette.negative_300,
+                dark: t.palette.negative_300,
+              }),
             })
           }
         } else if (variant === 'outline') {
@@ -297,24 +310,18 @@ export const Button = React.forwardRef<View, ButtonProps>(
               borderColor: t.palette.negative_500,
             })
             hoverStyles.push(a.border, {
-              backgroundColor: light
+              backgroundColor: t.palette.negative_50,
-                ? t.palette.negative_50
-                : t.palette.negative_975,
             })
           } else {
             baseStyles.push(a.border, {
-              borderColor: light
+              borderColor: t.palette.negative_200,
-                ? t.palette.negative_200
-                : t.palette.negative_900,
             })
           }
         } else if (variant === 'ghost') {
           if (!disabled) {
             baseStyles.push(t.atoms.bg)
             hoverStyles.push({
-              backgroundColor: light
+              backgroundColor: t.palette.negative_100,
-                ? t.palette.negative_100
-                : t.palette.negative_975,
             })
           }
         }
@@ -482,7 +489,6 @@ export function useSharedButtonTextStyles() {
   const {color, variant, disabled, size} = useButtonContext()
   return React.useMemo(() => {
     const baseStyles: TextStyle[] = []
-    const light = t.name === 'light'
 
     if (color === 'primary') {
       if (variant === 'solid') {
@@ -494,7 +500,7 @@ export function useSharedButtonTextStyles() {
       } else if (variant === 'outline') {
         if (!disabled) {
           baseStyles.push({
-            color: light ? t.palette.primary_600 : t.palette.primary_500,
+            color: t.palette.primary_600,
           })
         } else {
           baseStyles.push({color: t.palette.primary_600, opacity: 0.5})

src/components/FeedInterstitials.tsx

@@ -13,6 +13,7 @@ import {logger} from '#/logger'
 import {useModerationOpts} from '#/state/preferences/moderation-opts'
 import {useGetPopularFeedsQuery} from '#/state/queries/feed'
 import {useProfilesQuery} from '#/state/queries/profile'
+import {useSession} from '#/state/session'
 import {useProgressGuide} from '#/state/shell/progress-guide'
 import * as userActionHistory from '#/state/userActionHistory'
 import {SeenPost} from '#/state/userActionHistory'
@@ -127,6 +128,7 @@ function sortSeenPosts(postA: SeenPost, postB: SeenPost): 0 | 1 | -1 {
 }
 
 function useExperimentalSuggestedUsersQuery() {
+  const {currentAccount} = useSession()
   const userActionSnapshot = userActionHistory.useActionHistorySnapshot()
   const dids = React.useMemo(() => {
     const {likes, follows, seen} = userActionSnapshot
@@ -138,8 +140,10 @@ function useExperimentalSuggestedUsersQuery() {
       .sort(sortSeenPosts)
       .map(l => new AtUri(l.uri))
       .map(uri => uri.host)
-    return [...new Set([...likeDids, ...seenDids])]
+    return [...new Set([...likeDids, ...seenDids])].filter(
-  }, [userActionSnapshot])
+      did => did !== currentAccount?.did,
+    )
+  }, [userActionSnapshot, currentAccount])
   const {data, isLoading, error} = useProfilesQuery({
     handles: dids.slice(0, 16),
   })

src/components/IconCircle.tsx

@@ -2,14 +2,14 @@ import React from 'react'
 import {View} from 'react-native'
 
 import {
-  useTheme,
   atoms as a,
-  ViewStyleProp,
-  TextStyleProp,
   flatten,
+  TextStyleProp,
+  useTheme,
+  ViewStyleProp,
 } from '#/alf'
-import {Growth_Stroke2_Corner0_Rounded as Growth} from '#/components/icons/Growth'
 import {Props} from '#/components/icons/common'
+import {Growth_Stroke2_Corner0_Rounded as Growth} from '#/components/icons/Growth'
 
 export function IconCircle({
   icon: Icon,
@@ -32,8 +32,7 @@ export function IconCircle({
         {
           width: size === 'lg' ? 52 : 64,
           height: size === 'lg' ? 52 : 64,
-          backgroundColor:
+          backgroundColor: t.palette.primary_50,
-            t.name === 'light' ? t.palette.primary_50 : t.palette.primary_950,
         },
         flatten(style),
       ]}>

src/components/KnownFollowers.tsx

@@ -12,6 +12,7 @@ import {Link, LinkProps} from '#/components/Link'
 import {Text} from '#/components/Typography'
 
 const AVI_SIZE = 30
+const AVI_SIZE_SMALL = 20
 const AVI_BORDER = 1
 
 /**
@@ -30,10 +31,12 @@ export function KnownFollowers({
   profile,
   moderationOpts,
   onLinkPress,
+  minimal,
 }: {
   profile: AppBskyActorDefs.ProfileViewDetailed
   moderationOpts: ModerationOpts
   onLinkPress?: LinkProps['onPress']
+  minimal?: boolean
 }) {
   const cache = React.useRef<Map<string, AppBskyActorDefs.KnownFollowers>>(
     new Map(),
@@ -59,6 +62,7 @@ export function KnownFollowers({
         cachedKnownFollowers={cachedKnownFollowers}
         moderationOpts={moderationOpts}
         onLinkPress={onLinkPress}
+        minimal={minimal}
       />
     )
   }
@@ -71,11 +75,13 @@ function KnownFollowersInner({
   moderationOpts,
   cachedKnownFollowers,
   onLinkPress,
+  minimal,
 }: {
   profile: AppBskyActorDefs.ProfileViewDetailed
   moderationOpts: ModerationOpts
   cachedKnownFollowers: AppBskyActorDefs.KnownFollowers
   onLinkPress?: LinkProps['onPress']
+  minimal?: boolean
 }) {
   const t = useTheme()
   const {_} = useLingui()
@@ -110,6 +116,8 @@ function KnownFollowersInner({
    */
   if (slice.length === 0) return null
 
+  const SIZE = minimal ? AVI_SIZE_SMALL : AVI_SIZE
+
   return (
     <Link
       label={_(
@@ -120,7 +128,7 @@ function KnownFollowersInner({
       style={[
         a.flex_1,
         a.flex_row,
-        a.gap_md,
+        minimal ? a.gap_sm : a.gap_md,
         a.align_center,
         {marginLeft: -AVI_BORDER},
       ]}>
@@ -129,8 +137,8 @@ function KnownFollowersInner({
           <View
             style={[
               {
-                height: AVI_SIZE,
+                height: SIZE,
-                width: AVI_SIZE + (slice.length - 1) * a.gap_md.gap,
+                width: SIZE + (slice.length - 1) * a.gap_md.gap,
               },
               pressed && {
                 opacity: 0.5,
@@ -145,14 +153,14 @@ function KnownFollowersInner({
                   {
                     borderWidth: AVI_BORDER,
                     borderColor: t.atoms.bg.backgroundColor,
-                    width: AVI_SIZE + AVI_BORDER * 2,
+                    width: SIZE + AVI_BORDER * 2,
-                    height: AVI_SIZE + AVI_BORDER * 2,
+                    height: SIZE + AVI_BORDER * 2,
                     left: i * a.gap_md.gap,
                     zIndex: AVI_BORDER - i,
                   },
                 ]}>
                 <UserAvatar
-                  size={AVI_SIZE}
+                  size={SIZE}
                   avatar={prof.avatar}
                   moderation={moderation.ui('avatar')}
                 />

src/components/ProfileCard.tsx

@@ -166,7 +166,9 @@ export function NameAndHandle({
 
   return (
     <View style={[a.flex_1]}>
-      <Text style={[a.text_md, a.font_bold, a.leading_snug]} numberOfLines={1}>
+      <Text
+        style={[a.text_md, a.font_bold, a.leading_snug, a.self_start]}
+        numberOfLines={1}>
         {name}
       </Text>
       <Text

src/components/ProfileHoverCard/index.web.tsx

@@ -462,7 +462,8 @@ function Inner({
 
       <Link to={profileURL} label={_(msg`View profile`)} onPress={hide}>
         <View style={[a.pb_sm, a.flex_1]}>
-          <Text style={[a.pt_md, a.pb_xs, a.text_lg, a.font_bold]}>
+          <Text
+            style={[a.pt_md, a.pb_xs, a.text_lg, a.font_bold, a.self_start]}>
             {sanitizeDisplayName(
               profile.displayName || sanitizeHandle(profile.handle),
               moderation.ui('displayName'),

src/components/ReportDialog/SubmitView.tsx

@@ -6,6 +6,7 @@ import {useLingui} from '@lingui/react'
 
 import {getLabelingServiceTitle} from '#/lib/moderation'
 import {ReportOption} from '#/lib/moderation/useReportOptions'
+import {useGate} from '#/lib/statsig/statsig'
 import {useAgent} from '#/state/session'
 import {CharProgress} from '#/view/com/composer/char-progress/CharProgress'
 import * as Toast from '#/view/com/util/Toast'
@@ -36,6 +37,7 @@ export function SubmitView({
   const t = useTheme()
   const {_} = useLingui()
   const agent = useAgent()
+  const gate = useGate()
   const [details, setDetails] = React.useState<string>('')
   const [submitting, setSubmitting] = React.useState<boolean>(false)
   const [selectedServices, setSelectedServices] = React.useState<string[]>([
@@ -60,15 +62,29 @@ export function SubmitView({
       reason: details,
     }
     const results = await Promise.all(
-      selectedServices.map(did =>
+      selectedServices.map(did => {
-        agent
+        if (gate('session_withproxy_fix')) {
-          .withProxy('atproto_labeler', did)
+          return agent
-          .createModerationReport(report)
+            .createModerationReport(report, {
-          .then(
+              encoding: 'application/json',
-            _ => true,
+              headers: {
-            _ => false,
+                'atproto-proxy': `${did}#atproto_labeler`,
-          ),
+              },
-      ),
+            })
+            .then(
+              _ => true,
+              _ => false,
+            )
+        } else {
+          return agent
+            .withProxy('atproto_labeler', did)
+            .createModerationReport(report)
+            .then(
+              _ => true,
+              _ => false,
+            )
+        }
+      }),
     )
 
     setSubmitting(false)
@@ -92,6 +108,7 @@ export function SubmitView({
     onSubmitComplete,
     setError,
     agent,
+    gate,
   ])
 
   return (

src/components/StarterPack/QrCode.tsx

@@ -110,7 +110,7 @@ export function QrCodeInner({link}: {link: string}) {
       innerEyesOptions={{borderRadius: 3}}
       logo={{
         href: require('../../../assets/logo.png'),
-        scale: 1.2,
+        scale: 0.95,
         padding: 2,
         hidePieces: true,
       }}

src/components/StarterPack/Wizard/WizardListCard.tsx

@@ -78,7 +78,13 @@ function WizardListCard({
       />
       <View style={[a.flex_1, a.gap_2xs]}>
         <Text
-          style={[a.flex_1, a.font_bold, a.text_md, a.leading_tight]}
+          style={[
+            a.flex_1,
+            a.font_bold,
+            a.text_md,
+            a.leading_tight,
+            a.self_start,
+          ]}
           numberOfLines={1}>
           {displayName}
         </Text>

src/components/dialogs/MutedWords.tsx

@@ -357,12 +357,11 @@ function TargetToggle({children}: React.PropsWithChildren<{}>) {
         a.px_sm,
         gtMobile && a.px_md,
         a.rounded_sm,
-        t.atoms.bg_contrast_50,
+        t.atoms.bg_contrast_25,
-        (ctx.hovered || ctx.focused) && t.atoms.bg_contrast_100,
+        (ctx.hovered || ctx.focused) && t.atoms.bg_contrast_50,
         ctx.selected && [
           {
-            backgroundColor:
+            backgroundColor: t.palette.primary_50,
-              t.name === 'light' ? t.palette.primary_50 : t.palette.primary_975,
           },
         ],
         ctx.disabled && {

src/components/dialogs/ThreadgateEditor.tsx

@@ -196,10 +196,7 @@ function Selectable({
             t.atoms.bg_contrast_50,
             (hovered || focused) && t.atoms.bg_contrast_100,
             isSelected && {
-              backgroundColor:
+              backgroundColor: t.palette.primary_100,
-                t.name === 'light'
-                  ? t.palette.primary_50
-                  : t.palette.primary_975,
             },
             style,
           ]}>

src/components/dms/MessageItem.tsx

@@ -72,8 +72,7 @@ let MessageItem = ({
     lastInGroupRef.current = isLastInGroup
   }
 
-  const pendingColor =
+  const pendingColor = t.palette.primary_200
-    t.name === 'light' ? t.palette.primary_200 : t.palette.primary_800
 
   const rt = useMemo(() => {
     return new RichTextAPI({text: message.text, facets: message.facets})
@@ -110,12 +109,7 @@ let MessageItem = ({
             }>
             <RichText
               value={rt}
-              style={[
+              style={[a.text_md, isFromSelf && {color: t.palette.white}]}
-                a.text_md,
-                isFromSelf && {color: t.palette.white},
-                isPending &&
-                  t.name !== 'light' && {color: t.palette.primary_300},
-              ]}
               interactiveStyle={a.underline}
               enableTags
               emojiMultiplier={3}

src/components/dms/MessagesListHeader.tsx

@@ -168,7 +168,12 @@ function HeaderReady({
           </View>
           <View style={a.flex_1}>
             <Text
-              style={[a.text_md, a.font_bold, web(a.leading_normal)]}
+              style={[
+                a.text_md,
+                a.font_bold,
+                a.self_start,
+                web(a.leading_normal),
+              ]}
               numberOfLines={1}>
               {displayName}
             </Text>

src/components/dms/dialogs/SearchablePeopleList.tsx

@@ -395,7 +395,7 @@ function ProfileCard({
           />
           <View style={[a.flex_1, a.gap_2xs]}>
             <Text
-              style={[t.atoms.text, a.font_bold, a.leading_tight]}
+              style={[t.atoms.text, a.font_bold, a.leading_tight, a.self_start]}
               numberOfLines={1}>
               {displayName}
             </Text>

src/components/forms/TextField.tsx

@@ -101,16 +101,13 @@ export function useSharedInputStyles() {
     ]
     const error: ViewStyle[] = [
       {
-        backgroundColor:
+        backgroundColor: t.palette.negative_25,
-          t.name === 'light' ? t.palette.negative_25 : t.palette.negative_900,
+        borderColor: t.palette.negative_300,
-        borderColor:
-          t.name === 'light' ? t.palette.negative_300 : t.palette.negative_800,
       },
     ]
     const errorHover: ViewStyle[] = [
       {
-        backgroundColor:
+        backgroundColor: t.palette.negative_25,
-          t.name === 'light' ? t.palette.negative_25 : t.palette.negative_900,
         borderColor: t.palette.negative_500,
       },
     ]

src/components/forms/Toggle.tsx

@@ -281,24 +281,20 @@ export function createSharedToggleStyles({
 
   if (selected) {
     base.push({
-      backgroundColor:
+      backgroundColor: t.palette.primary_25,
-        t.name === 'light' ? t.palette.primary_25 : t.palette.primary_900,
       borderColor: t.palette.primary_500,
     })
 
     if (hovered) {
       baseHover.push({
-        backgroundColor:
+        backgroundColor: t.palette.primary_100,
-          t.name === 'light' ? t.palette.primary_100 : t.palette.primary_800,
+        borderColor: t.palette.primary_600,
-        borderColor:
-          t.name === 'light' ? t.palette.primary_600 : t.palette.primary_400,
       })
     }
   } else {
     if (hovered) {
       baseHover.push({
-        backgroundColor:
+        backgroundColor: t.palette.contrast_50,
-          t.name === 'light' ? t.palette.contrast_50 : t.palette.contrast_100,
         borderColor: t.palette.contrast_500,
       })
     }
@@ -306,16 +302,13 @@ export function createSharedToggleStyles({
 
   if (isInvalid) {
     base.push({
-      backgroundColor:
+      backgroundColor: t.palette.negative_25,
-        t.name === 'light' ? t.palette.negative_25 : t.palette.negative_975,
+      borderColor: t.palette.negative_300,
-      borderColor:
-        t.name === 'light' ? t.palette.negative_300 : t.palette.negative_800,
     })
 
     if (hovered) {
       baseHover.push({
-        backgroundColor:
+        backgroundColor: t.palette.negative_25,
-          t.name === 'light' ? t.palette.negative_25 : t.palette.negative_900,
         borderColor: t.palette.negative_600,
       })
     }

src/components/hooks/useStarterPackEntry.native.ts

@@ -7,7 +7,7 @@ import {
 import {isAndroid} from 'platform/detection'
 import {useHasCheckedForStarterPack} from 'state/preferences/used-starter-packs'
 import {useSetActiveStarterPack} from 'state/shell/starter-pack'
-import {DevicePrefs, Referrer} from '../../../modules/expo-bluesky-swiss-army'
+import {Referrer, SharedPrefs} from '../../../modules/expo-bluesky-swiss-army'
 
 export function useStarterPackEntry() {
   const [ready, setReady] = React.useState(false)
@@ -39,14 +39,10 @@ export function useStarterPackEntry() {
           uri = createStarterPackLinkFromAndroidReferrer(res.installReferrer)
         }
       } else {
-        const res = await DevicePrefs.getStringValueAsync(
+        const starterPackUri = SharedPrefs.getString('starterPackUri')
-          'starterPackUri',
+        if (starterPackUri) {
-          true,
+          uri = httpStarterPackUriToAtUri(starterPackUri)
-        )
+          SharedPrefs.setValue('starterPackUri', null)
-
-        if (res) {
-          uri = httpStarterPackUriToAtUri(res)
-          DevicePrefs.setStringValueAsync('starterPackUri', null, true)
         }
       }
 

src/components/icons/common.tsx

@@ -4,7 +4,7 @@ import type {PathProps, SvgProps} from 'react-native-svg'
 import {Defs, LinearGradient, Stop} from 'react-native-svg'
 import {nanoid} from 'nanoid/non-secure'
 
-import {tokens} from '#/alf'
+import {tokens, useTheme} from '#/alf'
 
 export type Props = {
   fill?: PathProps['fill']
@@ -22,10 +22,11 @@ export const sizes = {
 }
 
 export function useCommonSVGProps(props: Props) {
+  const t = useTheme()
   const {fill, size, gradient, ...rest} = props
   const style = StyleSheet.flatten(rest.style)
   const _size = Number(size ? sizes[size] : rest.width || sizes.md)
-  let _fill = fill || style?.color || tokens.color.blue_500
+  let _fill = fill || style?.color || t.palette.primary_500
   let gradientDef = null
 
   if (gradient && tokens.gradients[gradient]) {

src/components/moderation/LabelsOnMeDialog.tsx

@@ -7,6 +7,7 @@ import {useMutation} from '@tanstack/react-query'
 
 import {useLabelInfo} from '#/lib/moderation/useLabelInfo'
 import {makeProfileLink} from '#/lib/routes/links'
+import {useGate} from '#/lib/statsig/statsig'
 import {sanitizeHandle} from '#/lib/strings/handles'
 import {logger} from '#/logger'
 import {useAgent, useSession} from '#/state/session'
@@ -201,22 +202,42 @@ function AppealForm({
   const [details, setDetails] = React.useState('')
   const isAccountReport = 'did' in subject
   const agent = useAgent()
+  const gate = useGate()
 
   const {mutate, isPending} = useMutation({
     mutationFn: async () => {
       const $type = !isAccountReport
         ? 'com.atproto.repo.strongRef'
         : 'com.atproto.admin.defs#repoRef'
-      await agent
+      if (gate('session_withproxy_fix')) {
-        .withProxy('atproto_labeler', label.src)
+        await agent.createModerationReport(
-        .createModerationReport({
+          {
-          reasonType: ComAtprotoModerationDefs.REASONAPPEAL,
+            reasonType: ComAtprotoModerationDefs.REASONAPPEAL,
-          subject: {
+            subject: {
-            $type,
+              $type,
-            ...subject,
+              ...subject,
+            },
+            reason: details,
           },
-          reason: details,
+          {
-        })
+            encoding: 'application/json',
+            headers: {
+              'atproto-proxy': `${label.src}#atproto_labeler`,
+            },
+          },
+        )
+      } else {
+        await agent
+          .withProxy('atproto_labeler', label.src)
+          .createModerationReport({
+            reasonType: ComAtprotoModerationDefs.REASONAPPEAL,
+            subject: {
+              $type,
+              ...subject,
+            },
+            reason: details,
+          })
+      }
     },
     onError: err => {
       logger.error('Failed to submit label appeal', {message: err})

src/lib/ThemeContext.tsx

@@ -1,7 +1,8 @@
-import React, {ReactNode, createContext, useContext} from 'react'
+import React, {createContext, ReactNode, useContext} from 'react'
 import {TextStyle, ViewStyle} from 'react-native'
+
+import {ThemeName} from '#/alf/types'
 import {darkTheme, defaultTheme, dimTheme} from './themes'
-import {ThemeName} from '#/alf/themes'
 
 export type ColorScheme = 'light' | 'dark'
 

src/lib/hooks/useIntentHandler.ts

@@ -1,9 +1,12 @@
 import React from 'react'
 import * as Linking from 'expo-linking'
+
+import {logEvent} from 'lib/statsig/statsig'
 import {isNative} from 'platform/detection'
-import {useComposerControls} from 'state/shell'
 import {useSession} from 'state/session'
+import {useComposerControls} from 'state/shell'
 import {useCloseAllActiveElements} from 'state/util'
+import {Referrer} from '../../../modules/expo-bluesky-swiss-army'
 
 type IntentType = 'compose'
 
@@ -15,6 +18,16 @@ export function useIntentHandler() {
 
   React.useEffect(() => {
     const handleIncomingURL = (url: string) => {
+      Referrer.getReferrerInfoAsync().then(info => {
+        if (info && info.hostname !== 'bsky.app') {
+          logEvent('deepLink:referrerReceived', {
+            to: url,
+            referrer: info?.referrer,
+            hostname: info?.hostname,
+          })
+        }
+      })
+
       // We want to be able to support bluesky:// deeplinks. It's unnatural for someone to use a deeplink with three
       // slashes, like bluesky:///intent/follow. However, supporting just two slashes causes us to have to take care
       // of two cases when parsing the url. If we ensure there is a third slash, we can always ensure the first

src/lib/routes/types.ts

@@ -25,6 +25,7 @@ export type CommonNavigatorParams = {
   ProfileLabelerLikedBy: {name: string}
   Debug: undefined
   DebugMod: undefined
+  SharedPreferencesTester: undefined
   Log: undefined
   Support: undefined
   PrivacyPolicy: undefined

src/lib/statsig/events.ts

@@ -25,6 +25,11 @@ export type LogEvents = {
   }
   'state:foreground:sampled': {}
   'router:navigate:sampled': {}
+  'deepLink:referrerReceived': {
+    to: string
+    referrer: string
+    hostname: string
+  }
 
   // Screen events
   'splash:signInPressed': {}

src/lib/statsig/gates.ts

@@ -1,11 +1,13 @@
 export type Gate =
   // Keep this alphabetic please.
   | 'debug_show_feedcontext'
+  | 'explore_page_profile_card_social_proof'
   | 'native_pwi_disabled'
   | 'new_user_guided_tour'
   | 'new_user_progress_guide'
   | 'onboarding_minimum_interests'
   | 'request_notifications_permission_after_onboarding_v2'
+  | 'session_withproxy_fix'
   | 'show_avi_follow_button'
   | 'show_follow_back_label_v2'
   | 'suggested_feeds_interstitial'

src/lib/statsig/statsig.tsx

@@ -28,8 +28,6 @@ type StatsigUser = {
     bundleDate: number
     refSrc: string
     refUrl: string
-    referrer: string
-    referrerHostname: string
     appLanguage: string
     contentLanguages: string[]
   }
@@ -37,29 +35,12 @@ type StatsigUser = {
 
 let refSrc = ''
 let refUrl = ''
-let referrer = ''
-let referrerHostname = ''
 if (isWeb && typeof window !== 'undefined') {
   const params = new URLSearchParams(window.location.search)
   refSrc = params.get('ref_src') ?? ''
   refUrl = decodeURIComponent(params.get('ref_url') ?? '')
 }
 
-if (
-  isWeb &&
-  typeof document !== 'undefined' &&
-  document != null &&
-  document.referrer
-) {
-  try {
-    const url = new URL(document.referrer)
-    if (url.hostname !== 'bsky.app') {
-      referrer = document.referrer
-      referrerHostname = url.hostname
-    }
-  } catch {}
-}
-
 export type {LogEvents}
 
 function createStatsigOptions(prefetchUsers: StatsigUser[]) {
@@ -222,8 +203,6 @@ function toStatsigUser(did: string | undefined): StatsigUser {
     custom: {
       refSrc,
       refUrl,
-      referrer,
-      referrerHostname,
       platform: Platform.OS as 'ios' | 'android' | 'web',
       bundleIdentifier: BUNDLE_IDENTIFIER,
       bundleDate: BUNDLE_DATE,

src/lib/strings/constants.ts

@@ -0,0 +1 @@
+export const NON_BREAKING_SPACE = '\u00A0'

src/lib/themes.ts

@@ -1,8 +1,8 @@
 import {Platform} from 'react-native'
-import type {Theme} from './ThemeContext'
-import {colors} from './styles'
 
-import {darkPalette, lightPalette, dimPalette} from '#/alf/themes'
+import {darkPalette, dimPalette, lightPalette} from '#/alf/themes'
+import {colors} from './styles'
+import type {Theme} from './ThemeContext'
 
 export const defaultTheme: Theme = {
   colorScheme: 'light',
@@ -308,8 +308,8 @@ export const darkTheme: Theme = {
       textVeryLight: darkPalette.contrast_400,
       replyLine: darkPalette.contrast_200,
       replyLineDot: darkPalette.contrast_200,
-      unreadNotifBg: darkPalette.primary_975,
+      unreadNotifBg: darkPalette.primary_25,
-      unreadNotifBorder: darkPalette.primary_900,
+      unreadNotifBorder: darkPalette.primary_100,
       postCtrl: darkPalette.contrast_500,
       brandText: darkPalette.primary_500,
       emptyStateIcon: darkPalette.contrast_300,
@@ -357,8 +357,8 @@ export const dimTheme: Theme = {
       textVeryLight: dimPalette.contrast_400,
       replyLine: dimPalette.contrast_200,
       replyLineDot: dimPalette.contrast_200,
-      unreadNotifBg: dimPalette.primary_975,
+      unreadNotifBg: dimPalette.primary_25,
-      unreadNotifBorder: dimPalette.primary_900,
+      unreadNotifBorder: dimPalette.primary_100,
       postCtrl: dimPalette.contrast_500,
       brandText: dimPalette.primary_500,
       emptyStateIcon: dimPalette.contrast_300,

src/screens/E2E/SharedPreferencesTesterScreen.tsx

@@ -0,0 +1,113 @@
+import React from 'react'
+import {View} from 'react-native'
+
+import {ScrollView} from 'view/com/util/Views'
+import {atoms as a} from '#/alf'
+import {Button, ButtonText} from '#/components/Button'
+import {Text} from '#/components/Typography'
+import {SharedPrefs} from '../../../modules/expo-bluesky-swiss-army'
+
+export function SharedPreferencesTesterScreen() {
+  const [currentTestOutput, setCurrentTestOutput] = React.useState<string>('')
+
+  return (
+    <ScrollView contentContainerStyle={{backgroundColor: 'red'}}>
+      <View style={[a.flex_1]}>
+        <View>
+          <Text testID="testOutput">{currentTestOutput}</Text>
+        </View>
+        <View style={[a.flex_wrap]}>
+          <Button
+            label="btn"
+            testID="setStringBtn"
+            style={[a.self_center]}
+            variant="solid"
+            color="primary"
+            size="xsmall"
+            onPress={async () => {
+              SharedPrefs.removeValue('testerString')
+              SharedPrefs.setValue('testerString', 'Hello')
+              const str = SharedPrefs.getString('testerString')
+              console.log(JSON.stringify(str))
+              setCurrentTestOutput(`${str}`)
+            }}>
+            <ButtonText>Set String</ButtonText>
+          </Button>
+          <Button
+            label="btn"
+            testID="removeStringBtn"
+            style={[a.self_center]}
+            variant="solid"
+            color="primary"
+            size="xsmall"
+            onPress={async () => {
+              SharedPrefs.removeValue('testerString')
+              const str = SharedPrefs.getString('testerString')
+              setCurrentTestOutput(`${str}`)
+            }}>
+            <ButtonText>Remove String</ButtonText>
+          </Button>
+          <Button
+            label="btn"
+            testID="setBoolBtn"
+            style={[a.self_center]}
+            variant="solid"
+            color="primary"
+            size="xsmall"
+            onPress={async () => {
+              SharedPrefs.removeValue('testerBool')
+              SharedPrefs.setValue('testerBool', true)
+              const bool = SharedPrefs.getBool('testerBool')
+              setCurrentTestOutput(`${bool}`)
+            }}>
+            <ButtonText>Set Bool</ButtonText>
+          </Button>
+          <Button
+            label="btn"
+            testID="setNumberBtn"
+            style={[a.self_center]}
+            variant="solid"
+            color="primary"
+            size="xsmall"
+            onPress={async () => {
+              SharedPrefs.removeValue('testerNumber')
+              SharedPrefs.setValue('testerNumber', 123)
+              const num = SharedPrefs.getNumber('testerNumber')
+              setCurrentTestOutput(`${num}`)
+            }}>
+            <ButtonText>Set Number</ButtonText>
+          </Button>
+          <Button
+            label="btn"
+            testID="addToSetBtn"
+            style={[a.self_center]}
+            variant="solid"
+            color="primary"
+            size="xsmall"
+            onPress={async () => {
+              SharedPrefs.removeFromSet('testerSet', 'Hello!')
+              SharedPrefs.addToSet('testerSet', 'Hello!')
+              const contains = SharedPrefs.setContains('testerSet', 'Hello!')
+              setCurrentTestOutput(`${contains}`)
+            }}>
+            <ButtonText>Add to Set</ButtonText>
+          </Button>
+          <Button
+            label="btn"
+            testID="removeFromSetBtn"
+            style={[a.self_center]}
+            variant="solid"
+            color="primary"
+            size="xsmall"
+            onPress={async () => {
+              SharedPrefs.removeFromSet('testerSet', 'Hello!')
+              const contains = SharedPrefs.setContains('testerSet', 'Hello!')
+              setCurrentTestOutput(`${contains}`)
+            }}>
+            <ButtonText>Remove from Set</ButtonText>
+          </Button>
+        </View>
+      </View>
+    </ScrollView>
+  )
+}

src/screens/Hashtag.tsx

@@ -169,7 +169,7 @@ function HashtagScreenTab({
 
   const queryParam = React.useMemo(() => {
     if (!author) return fullTag
-    return `${fullTag} from:${sanitizeHandle(author)}`
+    return `${fullTag} from:${author}`
   }, [fullTag, author])
 
   const {

src/screens/Messages/Conversation/MessagesList.tsx

@@ -386,10 +386,10 @@ export function MessagesList({
           data={convoState.items}
           renderItem={renderItem}
           keyExtractor={keyExtractor}
-          containWeb={true}
+          disableFullWindowScroll={true}
           // Prevents wrong position in Firefox when sending a message
           // as well as scroll getting stuck on Chome when scrolling upwards.
-          disableContentVisibility={true}
+          disableContainStyle={true}
           disableVirtualization={true}
           style={animatedListStyle}
           // The extra two items account for the header and the footer components

src/screens/Profile/Header/DisplayName.tsx

@@ -20,7 +20,7 @@ export function ProfileHeaderDisplayName({
     <View pointerEvents="none">
       <Text
         testID="profileHeaderDisplayName"
-        style={[t.atoms.text, a.text_4xl, {fontWeight: '500'}]}>
+        style={[t.atoms.text, a.text_4xl, a.self_start, {fontWeight: '500'}]}>
         {sanitizeDisplayName(
           profile.displayName || sanitizeHandle(profile.handle),
           moderation.ui('displayName'),

src/screens/StarterPack/Wizard/StepFeeds.tsx

@@ -101,7 +101,7 @@ export function StepFeeds({moderationOpts}: {moderationOpts: ModerationOpts}) {
         onEndReachedThreshold={2}
         renderScrollComponent={props => <KeyboardAwareScrollView {...props} />}
         keyboardShouldPersistTaps="handled"
-        containWeb={true}
+        disableFullWindowScroll={true}
         sideBorders={false}
         style={{flex: 1}}
         ListEmptyComponent={

src/screens/StarterPack/Wizard/StepProfiles.tsx

@@ -80,7 +80,7 @@ export function StepProfiles({
         keyExtractor={keyExtractor}
         renderScrollComponent={props => <KeyboardAwareScrollView {...props} />}
         keyboardShouldPersistTaps="handled"
-        containWeb={true}
+        disableFullWindowScroll={true}
         sideBorders={false}
         style={[a.flex_1]}
         onEndReached={

src/state/feed-feedback.tsx

@@ -5,6 +5,7 @@ import throttle from 'lodash.throttle'
 
 import {PROD_DEFAULT_FEED} from '#/lib/constants'
 import {logEvent} from '#/lib/statsig/statsig'
+import {useGate} from '#/lib/statsig/statsig'
 import {logger} from '#/logger'
 import {FeedDescriptor, FeedPostSliceItem} from '#/state/queries/post-feed'
 import {getFeedPostSlice} from '#/view/com/posts/Feed'
@@ -24,6 +25,7 @@ const stateContext = React.createContext<StateContext>({
 
 export function useFeedFeedback(feed: FeedDescriptor, hasSession: boolean) {
   const agent = useAgent()
+  const gate = useGate()
   const enabled = isDiscoverFeed(feed) && hasSession
   const queue = React.useRef<Set<string>>(new Set())
   const history = React.useRef<
@@ -43,22 +45,38 @@ export function useFeedFeedback(feed: FeedDescriptor, hasSession: boolean) {
   )
 
   const sendToFeedNoDelay = React.useCallback(() => {
-    const proxyAgent = agent.withProxy(
-      // @ts-ignore TODO need to update withProxy() to support this key -prf
-      'bsky_fg',
-      // TODO when we start sending to other feeds, we need to grab their DID -prf
-      'did:web:discover.bsky.app',
-    ) as BskyAgent
-
     const interactions = Array.from(queue.current).map(toInteraction)
     queue.current.clear()
 
     // Send to the feed
-    proxyAgent.app.bsky.feed
+    if (gate('session_withproxy_fix')) {
-      .sendInteractions({interactions})
+      agent.app.bsky.feed
-      .catch((e: any) => {
+        .sendInteractions(
-        logger.warn('Failed to send feed interactions', {error: e})
+          {interactions},
-      })
+          {
+            encoding: 'application/json',
+            headers: {
+              // TODO when we start sending to other feeds, we need to grab their DID -prf
+              'atproto-proxy': 'did:web:discover.bsky.app#bsky_fg',
+            },
+          },
+        )
+        .catch((e: any) => {
+          logger.warn('Failed to send feed interactions', {error: e})
+        })
+    } else {
+      const proxyAgent = agent.withProxy(
+        // @ts-ignore TODO need to update withProxy() to support this key -prf
+        'bsky_fg',
+        // TODO when we start sending to other feeds, we need to grab their DID -prf
+        'did:web:discover.bsky.app',
+      ) as BskyAgent
+      proxyAgent.app.bsky.feed
+        .sendInteractions({interactions})
+        .catch((e: any) => {
+          logger.warn('Failed to send feed interactions', {error: e})
+        })
+    }
 
     // Send to Statsig
     if (aggregatedStats.current === null) {
@@ -66,7 +84,7 @@ export function useFeedFeedback(feed: FeedDescriptor, hasSession: boolean) {
     }
     sendOrAggregateInteractionsForStats(aggregatedStats.current, interactions)
     throttledFlushAggregatedStats()
-  }, [agent, throttledFlushAggregatedStats])
+  }, [agent, gate, throttledFlushAggregatedStats])
 
   const sendToFeed = React.useMemo(
     () =>

src/state/session/agent.ts

@@ -12,6 +12,7 @@ import {tryFetchGates} from '#/lib/statsig/statsig'
 import {getAge} from '#/lib/strings/time'
 import {logger} from '#/logger'
 import {snoozeEmailConfirmationPrompt} from '#/state/shell/reminders'
+import {addSessionErrorLog} from './logging'
 import {
   configureModerationForAccount,
   configureModerationForGuest,
@@ -194,6 +195,9 @@ async function prepareAgent(
   const account = agentToSessionAccountOrThrow(agent)
   agent.setPersistSessionHandler(event => {
     onSessionChange(agent, account.did, event)
+    if (event !== 'create' && event !== 'update') {
+      addSessionErrorLog(account.did, event)
+    }
   })
   return {agent, account}
 }

src/state/session/logging.ts

@@ -1,4 +1,4 @@
-import {AtpSessionData} from '@atproto/api'
+import {AtpSessionData, AtpSessionEvent} from '@atproto/api'
 import {sha256} from 'js-sha256'
 import {Statsig} from 'statsig-react-native-expo'
 
@@ -70,6 +70,23 @@ export function wrapSessionReducerForLogging(reducer: Reducer): Reducer {
 let nextMessageIndex = 0
 const MAX_SLICE_LENGTH = 1000
 
+// Not gated.
+export function addSessionErrorLog(did: string, event: AtpSessionEvent) {
+  try {
+    if (!Statsig.initializeCalled() || !Statsig.getStableID()) {
+      return
+    }
+    const stack = (new Error().stack ?? '').slice(0, MAX_SLICE_LENGTH)
+    Statsig.logEvent('session:error', null, {
+      did,
+      event,
+      stack,
+    })
+  } catch (e) {
+    console.error(e)
+  }
+}
+
 export function addSessionDebugLog(log: Log) {
   try {
     if (!Statsig.initializeCalled() || !Statsig.getStableID()) {

src/view/com/composer/Composer.tsx

@@ -14,7 +14,6 @@ import {
   KeyboardAvoidingView,
   LayoutChangeEvent,
   StyleSheet,
-  TouchableOpacity,
   View,
 } from 'react-native'
 import Animated, {
@@ -24,7 +23,6 @@ import Animated, {
   withTiming,
 } from 'react-native-reanimated'
 import {useSafeAreaInsets} from 'react-native-safe-area-context'
-import {LinearGradient} from 'expo-linear-gradient'
 import {
   AppBskyFeedDefs,
   AppBskyFeedGetPostThread,
@@ -61,21 +59,21 @@ import {useAgent, useSession} from '#/state/session'
 import {useComposerControls} from '#/state/shell/composer'
 import {useAnalytics} from 'lib/analytics/analytics'
 import * as apilib from 'lib/api/index'
-import {HITSLOP_10, MAX_GRAPHEME_LENGTH} from 'lib/constants'
+import {MAX_GRAPHEME_LENGTH} from 'lib/constants'
 import {useIsKeyboardVisible} from 'lib/hooks/useIsKeyboardVisible'
 import {usePalette} from 'lib/hooks/usePalette'
 import {useWebMediaQueries} from 'lib/hooks/useWebMediaQueries'
 import {cleanError} from 'lib/strings/errors'
 import {insertMentionAt} from 'lib/strings/mention-manip'
 import {shortenLinks} from 'lib/strings/rich-text-manip'
-import {colors, gradients, s} from 'lib/styles'
+import {colors, s} from 'lib/styles'
 import {isAndroid, isIOS, isNative, isWeb} from 'platform/detection'
 import {useDialogStateControlContext} from 'state/dialogs'
 import {GalleryModel} from 'state/models/media/gallery'
 import {ComposerOpts} from 'state/shell/composer'
 import {ComposerReplyTo} from 'view/com/composer/ComposerReplyTo'
 import {atoms as a, useTheme} from '#/alf'
-import {Button} from '#/components/Button'
+import {Button, ButtonText} from '#/components/Button'
 import {EmojiArc_Stroke2_Corner0_Rounded as EmojiSmile} from '#/components/icons/Emoji'
 import * as Prompt from '#/components/Prompt'
 import {QuoteEmbed, QuoteX} from '../util/post-embeds/QuoteEmbed'
@@ -458,20 +456,25 @@ export const ComposePost = observer(function ComposePost({
       <View style={[a.flex_1, viewStyles]} aria-modal accessibilityViewIsModal>
         <Animated.View style={topBarAnimatedStyle}>
           <View style={styles.topbarInner}>
-            <TouchableOpacity
+            <Button
-              testID="composerDiscardButton"
+              label={_(msg`Cancel`)}
+              variant="ghost"
+              color="primary"
+              shape="default"
+              size="small"
+              style={[
+                a.rounded_full,
+                a.py_sm,
+                {paddingLeft: 7, paddingRight: 7},
+              ]}
               onPress={onPressCancel}
-              onAccessibilityEscape={onPressCancel}
-              accessibilityRole="button"
-              accessibilityLabel={_(msg`Cancel`)}
               accessibilityHint={_(
                 msg`Closes post composer and discards post draft`,
-              )}
+              )}>
-              hitSlop={HITSLOP_10}>
+              <ButtonText style={[a.text_md]}>
-              <Text style={[pal.link, s.f18]}>
                 <Trans>Cancel</Trans>
-              </Text>
+              </ButtonText>
-            </TouchableOpacity>
+            </Button>
             <View style={a.flex_1} />
             {isProcessing ? (
               <>
@@ -488,31 +491,25 @@ export const ComposePost = observer(function ComposePost({
                   hasMedia={hasMedia}
                 />
                 {canPost ? (
-                  <TouchableOpacity
+                  <Button
                     testID="composerPublishBtn"
-                    onPress={onPressPublish}
+                    label={
-                    accessibilityRole="button"
-                    accessibilityLabel={
                       replyTo ? _(msg`Publish reply`) : _(msg`Publish post`)
                     }
-                    accessibilityHint="">
+                    variant="solid"
-                    <LinearGradient
+                    color="primary"
-                      colors={[
+                    shape="default"
-                        gradients.blueLight.start,
+                    size="small"
-                        gradients.blueLight.end,
+                    style={[a.rounded_full, a.py_sm]}
-                      ]}
+                    onPress={onPressPublish}>
-                      start={{x: 0, y: 0}}
+                    <ButtonText style={[a.text_md]}>
-                      end={{x: 1, y: 1}}
+                      {replyTo ? (
-                      style={styles.postBtn}>
+                        <Trans context="action">Reply</Trans>
-                      <Text style={[s.white, s.f16, s.bold]}>
+                      ) : (
-                        {replyTo ? (
+                        <Trans context="action">Post</Trans>
-                          <Trans context="action">Reply</Trans>
+                      )}
-                        ) : (
+                    </ButtonText>
-                          <Trans context="action">Post</Trans>
+                  </Button>
-                        )}
-                      </Text>
-                    </LinearGradient>
-                  </TouchableOpacity>
                 ) : (
                   <View style={[styles.postBtn, pal.btn]}>
                     <Text style={[pal.textLight, s.f16, s.bold]}>
@@ -828,7 +825,7 @@ const styles = StyleSheet.create({
   topbarInner: {
     flexDirection: 'row',
     alignItems: 'center',
-    paddingHorizontal: 16,
+    paddingHorizontal: 8,
     height: 54,
     gap: 4,
   },

src/view/com/composer/GifAltText.tsx

@@ -174,8 +174,13 @@ function AltTextInner({
           <Text style={[a.text_2xl, a.font_bold, a.leading_tight, a.pb_sm]}>
             <Trans>Add alt text</Trans>
           </Text>
-          <View style={[a.w_full, a.align_center, native({maxHeight: 200})]}>
+          <View style={[a.align_center]}>
-            <GifEmbed link={link} params={params} hideAlt />
+            <GifEmbed
+              link={link}
+              params={params}
+              hideAlt
+              style={[native({maxHeight: 225})]}
+            />
           </View>
         </View>
       </View>

src/view/com/composer/text-input/web/EmojiPicker.web.tsx

@@ -1,11 +1,13 @@
 import React from 'react'
-import Picker from '@emoji-mart/react'
 import {
-  StyleSheet,
+  GestureResponderEvent,
   TouchableWithoutFeedback,
   useWindowDimensions,
   View,
 } from 'react-native'
+import Picker from '@emoji-mart/react'
+
+import {atoms as a} from '#/alf'
 import {textInputWebEmitter} from '../TextInput.web'
 
 const HEIGHT_OFFSET = 40
@@ -96,12 +98,29 @@ export function EmojiPicker({state, close}: IProps) {
 
   if (!state.isOpen) return null
 
+  const onPressBackdrop = (e: GestureResponderEvent) => {
+    // @ts-ignore web only
+    if (e.nativeEvent?.pointerId === -1) return
+    close()
+  }
+
   return (
     <TouchableWithoutFeedback
       accessibilityRole="button"
-      onPress={close}
+      onPress={onPressBackdrop}
       accessibilityViewIsModal>
-      <View style={styles.mask}>
+      <View
+        style={[
+          a.fixed,
+          a.w_full,
+          a.h_full,
+          a.align_center,
+          {
+            top: 0,
+            left: 0,
+            right: 0,
+          },
+        ]}>
         {/* eslint-disable-next-line react-native-a11y/has-valid-accessibility-descriptors */}
         <TouchableWithoutFeedback onPress={e => e.stopPropagation()}>
           <View style={[{position: 'absolute'}, position]}>
@@ -118,20 +137,3 @@ export function EmojiPicker({state, close}: IProps) {
     </TouchableWithoutFeedback>
   )
 }
-
-const styles = StyleSheet.create({
-  mask: {
-    // @ts-ignore web ony
-    position: 'fixed',
-    top: 0,
-    left: 0,
-    right: 0,
-    width: '100%',
-    height: '100%',
-    alignItems: 'center',
-  },
-  picker: {
-    marginHorizontal: 'auto',
-    paddingRight: 50,
-  },
-})

src/view/com/notifications/FeedItem.tsx

@@ -58,6 +58,7 @@ import {useNavigation} from '@react-navigation/native'
 import {parseTenorGif} from '#/lib/strings/embed-player'
 import {logger} from '#/logger'
 import {NavigationProp} from 'lib/routes/types'
+import {forceLTR} from 'lib/strings/bidi'
 import {DM_SERVICE_HEADERS} from 'state/queries/messages/const'
 import {useAgent} from 'state/session'
 import {Button, ButtonText} from '#/components/Button'
@@ -178,8 +179,10 @@ let FeedItem = ({
       key={authors[0].href}
       style={[pal.text, s.bold]}
       href={authors[0].href}
-      text={sanitizeDisplayName(
+      text={forceLTR(
-        authors[0].profile.displayName || authors[0].profile.handle,
+        sanitizeDisplayName(
+          authors[0].profile.displayName || authors[0].profile.handle,
+        ),
       )}
       disableMismatchWarning
     />
@@ -378,7 +381,7 @@ let FeedItem = ({
             showDmButton={item.type === 'starterpack-joined' || isFollowBack}
           />
           <ExpandedAuthorsList visible={isAuthorsExpanded} authors={authors} />
-          <Text style={[styles.meta, pal.text]}>
+          <Text style={[styles.meta, a.self_start, pal.text]}>
             {action}
             <TimeElapsed timestamp={item.notification.indexedAt}>
               {({timeElapsed}) => (

src/view/com/post-thread/PostThreadItem.tsx

@@ -281,7 +281,7 @@ let PostThreadItemLoaded = ({
                 <Link style={s.flex1} href={authorHref} title={authorTitle}>
                   <Text
                     type="xl-bold"
-                    style={[pal.text]}
+                    style={[pal.text, a.self_start]}
                     numberOfLines={1}
                     lineHeight={1.2}>
                     {sanitizeDisplayName(

src/view/com/post/Post.tsx

@@ -15,6 +15,7 @@ import {useQueryClient} from '@tanstack/react-query'
 import {moderatePost_wrapped as moderatePost} from '#/lib/moderatePost_wrapped'
 import {POST_TOMBSTONE, Shadow, usePostShadow} from '#/state/cache/post-shadow'
 import {useModerationOpts} from '#/state/preferences/moderation-opts'
+import {useSession} from '#/state/session'
 import {useComposerControls} from '#/state/shell/composer'
 import {MAX_POST_LINES} from 'lib/constants'
 import {usePalette} from 'lib/hooks/usePalette'
@@ -145,6 +146,9 @@ function PostInner({
     precacheProfile(queryClient, post.author)
   }, [queryClient, post.author])
 
+  const {currentAccount} = useSession()
+  const isMe = replyAuthorDid === currentAccount?.did
+
   return (
     <Link
       href={itemHref}
@@ -187,17 +191,21 @@ function PostInner({
                 style={[pal.textLight, s.mr2]}
                 lineHeight={1.2}
                 numberOfLines={1}>
-                <Trans context="description">
+                {isMe ? (
-                  Reply to{' '}
+                  <Trans context="description">Reply to you</Trans>
-                  <ProfileHoverCard inline did={replyAuthorDid}>
+                ) : (
-                    <UserInfoText
+                  <Trans context="description">
-                      type="sm"
+                    Reply to{' '}
-                      did={replyAuthorDid}
+                    <ProfileHoverCard inline did={replyAuthorDid}>
-                      attr="displayName"
+                      <UserInfoText
-                      style={[pal.textLight]}
+                        type="sm"
-                    />
+                        did={replyAuthorDid}
-                  </ProfileHoverCard>
+                        attr="displayName"
-                </Trans>
+                        style={[pal.textLight]}
+                      />
+                    </ProfileHoverCard>
+                  </Trans>
+                )}
               </Text>
             </View>
           )}

src/view/com/posts/FeedItem.tsx

@@ -43,6 +43,7 @@ import {Text} from '../util/text/Text'
 import {PreviewableUserAvatar} from '../util/UserAvatar'
 import {AviFollowButton} from './AviFollowButton'
 import hairlineWidth = StyleSheet.hairlineWidth
+import {useSession} from '#/state/session'
 import {Repost_Stroke2_Corner2_Rounded as Repost} from '#/components/icons/Repost'
 
 interface FeedItemProps {
@@ -200,6 +201,11 @@ let FeedItemInner = ({
     },
   ]
 
+  const {currentAccount} = useSession()
+  const isOwner =
+    AppBskyFeedDefs.isReasonRepost(reason) &&
+    reason.by.did === currentAccount?.did
+
   return (
     <Link
       testID={`feedItem-by-${post.author.handle}`}
@@ -250,11 +256,15 @@ let FeedItemInner = ({
             <Link
               style={styles.includeReason}
               href={makeProfileLink(reason.by)}
-              title={_(
+              title={
-                msg`Reposted by ${sanitizeDisplayName(
+                isOwner
-                  reason.by.displayName || reason.by.handle,
+                  ? _(msg`Reposted by you`)
-                )}`,
+                  : _(
-              )}
+                      msg`Reposted by ${sanitizeDisplayName(
+                        reason.by.displayName || reason.by.handle,
+                      )}`,
+                    )
+              }
               onBeforePress={onOpenReposter}>
               <Repost
                 style={{color: pal.colors.textLight, marginRight: 3}}
@@ -266,24 +276,28 @@ let FeedItemInner = ({
                 style={pal.textLight}
                 lineHeight={1.2}
                 numberOfLines={1}>
-                <Trans>
+                {isOwner ? (
-                  Reposted by{' '}
+                  <Trans>Reposted by you</Trans>
-                  <ProfileHoverCard inline did={reason.by.did}>
+                ) : (
-                    <TextLinkOnWebOnly
+                  <Trans>
-                      type="sm-bold"
+                    Reposted by{' '}
-                      style={pal.textLight}
+                    <ProfileHoverCard inline did={reason.by.did}>
-                      lineHeight={1.2}
+                      <TextLinkOnWebOnly
-                      numberOfLines={1}
+                        type="sm-bold"
-                      text={sanitizeDisplayName(
+                        style={pal.textLight}
-                        reason.by.displayName ||
+                        lineHeight={1.2}
-                          sanitizeHandle(reason.by.handle),
+                        numberOfLines={1}
-                        moderation.ui('displayName'),
+                        text={sanitizeDisplayName(
-                      )}
+                          reason.by.displayName ||
-                      href={makeProfileLink(reason.by)}
+                            sanitizeHandle(reason.by.handle),
-                      onBeforePress={onOpenReposter}
+                          moderation.ui('displayName'),
-                    />
+                        )}
-                  </ProfileHoverCard>
+                        href={makeProfileLink(reason.by)}
-                </Trans>
+                        onBeforePress={onOpenReposter}
+                      />
+                    </ProfileHoverCard>
+                  </Trans>
+                )}
               </Text>
             </Link>
           ) : null}
@@ -421,6 +435,9 @@ function ReplyToLabel({
   blocked?: boolean
 }) {
   const pal = usePalette('default')
+  const {currentAccount} = useSession()
+  const isMe = profile.did === currentAccount?.did
+
   return (
     <View style={[s.flexRow, s.mb2, s.alignCenter]}>
       <FontAwesomeIcon
@@ -433,7 +450,9 @@ function ReplyToLabel({
         style={[pal.textLight, s.mr2]}
         lineHeight={1.2}
         numberOfLines={1}>
-        {blocked ? (
+        {isMe ? (
+          <Trans context="description">Reply to you</Trans>
+        ) : blocked ? (
           <Trans context="description">Reply to a blocked post</Trans>
         ) : (
           <Trans context="description">

src/view/com/profile/ProfileCard.tsx

@@ -5,7 +5,6 @@ import {
   moderateProfile,
   ModerationDecision,
 } from '@atproto/api'
-import {Trans} from '@lingui/macro'
 import {useQueryClient} from '@tanstack/react-query'
 
 import {useProfileShadow} from '#/state/cache/profile-shadow'
@@ -19,12 +18,16 @@ import {sanitizeDisplayName} from 'lib/strings/display-names'
 import {sanitizeHandle} from 'lib/strings/handles'
 import {s} from 'lib/styles'
 import {precacheProfile} from 'state/queries/profile'
+import {atoms as a} from '#/alf'
+import {
+  KnownFollowers,
+  shouldShowKnownFollowers,
+} from '#/components/KnownFollowers'
 import {Link} from '../util/Link'
 import {Text} from '../util/text/Text'
 import {PreviewableUserAvatar} from '../util/UserAvatar'
 import {FollowButton} from './FollowButton'
 import hairlineWidth = StyleSheet.hairlineWidth
-import {atoms as a} from '#/alf'
 import * as Pills from '#/components/Pills'
 
 export function ProfileCard({
@@ -33,22 +36,22 @@ export function ProfileCard({
   noModFilter,
   noBg,
   noBorder,
-  followers,
   renderButton,
   onPress,
   style,
+  showKnownFollowers,
 }: {
   testID?: string
   profile: AppBskyActorDefs.ProfileViewBasic
   noModFilter?: boolean
   noBg?: boolean
   noBorder?: boolean
-  followers?: AppBskyActorDefs.ProfileView[] | undefined
   renderButton?: (
     profile: Shadow<AppBskyActorDefs.ProfileViewBasic>,
   ) => React.ReactNode
   onPress?: () => void
   style?: StyleProp<ViewStyle>
+  showKnownFollowers?: boolean
 }) {
   const queryClient = useQueryClient()
   const pal = usePalette('default')
@@ -70,6 +73,11 @@ export function ProfileCard({
     return null
   }
 
+  const knownFollowersVisible =
+    showKnownFollowers &&
+    shouldShowKnownFollowers(profile.viewer?.knownFollowers) &&
+    moderationOpts
+
   return (
     <Link
       testID={testID}
@@ -97,7 +105,7 @@ export function ProfileCard({
         <View style={styles.layoutContent}>
           <Text
             type="lg"
-            style={[s.bold, pal.text]}
+            style={[s.bold, pal.text, a.self_start]}
             numberOfLines={1}
             lineHeight={1.2}>
             {sanitizeDisplayName(
@@ -118,14 +126,30 @@ export function ProfileCard({
           <View style={styles.layoutButton}>{renderButton(profile)}</View>
         ) : undefined}
       </View>
-      {profile.description ? (
+      {profile.description || knownFollowersVisible ? (
         <View style={styles.details}>
-          <Text style={pal.text} numberOfLines={4}>
+          {profile.description ? (
-            {profile.description as string}
+            <Text style={pal.text} numberOfLines={4}>
-          </Text>
+              {profile.description as string}
+            </Text>
+          ) : null}
+          {knownFollowersVisible ? (
+            <View
+              style={[
+                a.flex_row,
+                a.align_center,
+                a.gap_sm,
+                !!profile.description && a.mt_md,
+              ]}>
+              <KnownFollowers
+                minimal
+                profile={profile}
+                moderationOpts={moderationOpts}
+              />
+            </View>
+          ) : null}
         </View>
       ) : null}
-      <FollowersList followers={followers} />
     </Link>
   )
 }
@@ -155,73 +179,20 @@ export function ProfileCardPills({
   )
 }
 
-function FollowersList({
-  followers,
-}: {
-  followers?: AppBskyActorDefs.ProfileView[] | undefined
-}) {
-  const pal = usePalette('default')
-  const moderationOpts = useModerationOpts()
-
-  const followersWithMods = React.useMemo(() => {
-    if (!followers || !moderationOpts) {
-      return []
-    }
-
-    return followers
-      .map(f => ({
-        f,
-        mod: moderateProfile(f, moderationOpts),
-      }))
-      .filter(({mod}) => !mod.ui('profileList').filter)
-  }, [followers, moderationOpts])
-
-  if (!followersWithMods?.length) {
-    return null
-  }
-
-  return (
-    <View style={styles.followedBy}>
-      <Text
-        type="sm"
-        style={[styles.followsByDesc, pal.textLight]}
-        numberOfLines={2}
-        lineHeight={1.2}>
-        <Trans>
-          Followed by{' '}
-          {followersWithMods.map(({f}) => f.displayName || f.handle).join(', ')}
-        </Trans>
-      </Text>
-      {followersWithMods.slice(0, 3).map(({f, mod}) => (
-        <View key={f.did} style={styles.followedByAviContainer}>
-          <View style={[styles.followedByAvi, pal.view]}>
-            <PreviewableUserAvatar
-              size={32}
-              profile={f}
-              moderation={mod.ui('avatar')}
-              type={f.associated?.labeler ? 'labeler' : 'user'}
-            />
-          </View>
-        </View>
-      ))}
-    </View>
-  )
-}
-
 export function ProfileCardWithFollowBtn({
   profile,
   noBg,
   noBorder,
-  followers,
   onPress,
   logContext = 'ProfileCard',
+  showKnownFollowers,
 }: {
-  profile: AppBskyActorDefs.ProfileViewBasic
+  profile: AppBskyActorDefs.ProfileView
   noBg?: boolean
   noBorder?: boolean
-  followers?: AppBskyActorDefs.ProfileView[] | undefined
   onPress?: () => void
   logContext?: 'ProfileCard' | 'StarterPackProfilesList'
+  showKnownFollowers?: boolean
 }) {
   const {currentAccount} = useSession()
   const isMe = profile.did === currentAccount?.did
@@ -231,7 +202,6 @@ export function ProfileCardWithFollowBtn({
       profile={profile}
       noBg={noBg}
       noBorder={noBorder}
-      followers={followers}
       renderButton={
         isMe
           ? undefined
@@ -240,6 +210,7 @@ export function ProfileCardWithFollowBtn({
             )
       }
       onPress={onPress}
+      showKnownFollowers={!isMe && showKnownFollowers}
     />
   )
 }

src/view/com/util/List.tsx

@@ -24,11 +24,12 @@ export type ListProps<ItemT> = Omit<
   refreshing?: boolean
   onRefresh?: () => void
   onItemSeen?: (item: ItemT) => void
-  containWeb?: boolean
   desktopFixedHeight?: number | boolean
+  // Web only prop to contain the scroll to the container rather than the window
+  disableFullWindowScroll?: boolean
   sideBorders?: boolean
   // Web only prop to disable a perf optimization (which would otherwise be on).
-  disableContentVisibility?: boolean
+  disableContainStyle?: boolean
 }
 export type ListRef = React.MutableRefObject<FlatList_INTERNAL | null>
 

src/view/com/util/List.web.tsx

@@ -23,9 +23,11 @@ export type ListProps<ItemT> = Omit<
   onRefresh?: () => void
   onItemSeen?: (item: ItemT) => void
   desktopFixedHeight?: number | boolean
-  containWeb?: boolean
+  // Web only prop to contain the scroll to the container rather than the window
+  disableFullWindowScroll?: boolean
   sideBorders?: boolean
-  disableContentVisibility?: boolean
+  // Web only prop to disable a perf optimization (which would otherwise be on).
+  disableContainStyle?: boolean
 }
 export type ListRef = React.MutableRefObject<any | null> // TODO: Better types.
 
@@ -39,7 +41,7 @@ function ListImpl<ItemT>(
     ListHeaderComponent,
     ListFooterComponent,
     ListEmptyComponent,
-    containWeb,
+    disableFullWindowScroll,
     contentContainerStyle,
     data,
     desktopFixedHeight,
@@ -58,7 +60,7 @@ function ListImpl<ItemT>(
     extraData,
     style,
     sideBorders = true,
-    disableContentVisibility,
+    disableContainStyle,
     ...props
   }: ListProps<ItemT>,
   ref: React.Ref<ListMethods>,
@@ -112,7 +114,7 @@ function ListImpl<ItemT>(
   }
 
   const getScrollableNode = React.useCallback(() => {
-    if (containWeb) {
+    if (disableFullWindowScroll) {
       const element = nativeRef.current as HTMLDivElement | null
       if (!element) return
 
@@ -182,7 +184,7 @@ function ListImpl<ItemT>(
         },
       }
     }
-  }, [containWeb])
+  }, [disableFullWindowScroll])
 
   const nativeRef = React.useRef<HTMLDivElement>(null)
   React.useImperativeHandle(
@@ -267,7 +269,12 @@ function ListImpl<ItemT>(
     return () => {
       element?.removeEventListener('scroll', handleScroll)
     }
-  }, [isInsideVisibleTree, handleScroll, containWeb, getScrollableNode])
+  }, [
+    isInsideVisibleTree,
+    handleScroll,
+    disableFullWindowScroll,
+    getScrollableNode,
+  ])
 
   // --- onScrolledDownChange ---
   const isScrolledDown = useRef(false)
@@ -308,7 +315,7 @@ function ListImpl<ItemT>(
       {...props}
       style={[
         style,
-        containWeb && {
+        disableFullWindowScroll && {
           flex: 1,
           // @ts-expect-error web only
           'overflow-y': 'scroll',
@@ -332,13 +339,13 @@ function ListImpl<ItemT>(
           pal.border,
         ]}>
         <Visibility
-          root={containWeb ? nativeRef : null}
+          root={disableFullWindowScroll ? nativeRef : null}
           onVisibleChange={handleAboveTheFoldVisibleChange}
           style={[styles.aboveTheFoldDetector, {height: headerOffset}]}
         />
         {onStartReached && !isEmpty && (
           <Visibility
-            root={containWeb ? nativeRef : null}
+            root={disableFullWindowScroll ? nativeRef : null}
             onVisibleChange={onHeadVisibilityChange}
             topMargin={(onStartReachedThreshold ?? 0) * 100 + '%'}
           />
@@ -356,13 +363,13 @@ function ListImpl<ItemT>(
                   renderItem={renderItem}
                   extraData={extraData}
                   onItemSeen={onItemSeen}
-                  disableContentVisibility={disableContentVisibility}
+                  disableContainStyle={disableContainStyle}
                 />
               )
             })}
         {onEndReached && !isEmpty && (
           <Visibility
-            root={containWeb ? nativeRef : null}
+            root={disableFullWindowScroll ? nativeRef : null}
             onVisibleChange={onTailVisibilityChange}
             bottomMargin={(onEndReachedThreshold ?? 0) * 100 + '%'}
             key={data?.length}
@@ -406,7 +413,7 @@ let Row = function RowImpl<ItemT>({
   renderItem,
   extraData: _unused,
   onItemSeen,
-  disableContentVisibility,
+  disableContainStyle,
 }: {
   item: ItemT
   index: number
@@ -416,7 +423,7 @@ let Row = function RowImpl<ItemT>({
     | ((data: {index: number; item: any; separators: any}) => React.ReactNode)
   extraData: any
   onItemSeen: ((item: any) => void) | undefined
-  disableContentVisibility?: boolean
+  disableContainStyle?: boolean
 }): React.ReactNode {
   const rowRef = React.useRef(null)
   const intersectionTimeout = React.useRef<NodeJS.Timer | undefined>(undefined)
@@ -465,14 +472,10 @@ let Row = function RowImpl<ItemT>({
     return null
   }
 
-  const shouldDisableContentVisibility = disableContentVisibility || isSafari
+  const shouldDisableContainStyle = disableContainStyle || isSafari
   return (
     <View
-      style={
+      style={shouldDisableContainStyle ? undefined : styles.contain}
-        shouldDisableContentVisibility
-          ? undefined
-          : styles.contentVisibilityAuto
-      }
       ref={rowRef}>
       {renderItem({item, index, separators: null as any})}
     </View>
@@ -544,9 +547,9 @@ const styles = StyleSheet.create({
     marginLeft: 'auto',
     marginRight: 'auto',
   },
-  contentVisibilityAuto: {
+  contain: {
     // @ts-ignore web only
-    contentVisibility: 'auto',
+    contain: 'layout paint',
   },
   minHeightViewport: {
     // @ts-ignore web only

src/view/com/util/PostMeta.tsx

@@ -6,6 +6,8 @@ import {useQueryClient} from '@tanstack/react-query'
 import {precacheProfile} from '#/state/queries/profile'
 import {usePalette} from 'lib/hooks/usePalette'
 import {makeProfileLink} from 'lib/routes/links'
+import {forceLTR} from 'lib/strings/bidi'
+import {NON_BREAKING_SPACE} from 'lib/strings/constants'
 import {sanitizeDisplayName} from 'lib/strings/display-names'
 import {sanitizeHandle} from 'lib/strings/handles'
 import {niceDate} from 'lib/strings/time'
@@ -32,8 +34,6 @@ interface PostMetaOpts {
   style?: StyleProp<ViewStyle>
 }
 
-const NON_BREAKING_SPACE = '\u00A0'
-
 let PostMeta = (opts: PostMetaOpts): React.ReactNode => {
   const pal = usePalette('default')
   const displayName = opts.author.displayName || opts.author.handle
@@ -70,14 +70,12 @@ let PostMeta = (opts: PostMetaOpts): React.ReactNode => {
             style={[pal.text]}
             lineHeight={1.2}
             disableMismatchWarning
-            text={
+            text={forceLTR(
-              <>
+              sanitizeDisplayName(
-                {sanitizeDisplayName(
+                displayName,
-                  displayName,
+                opts.moderation?.ui('displayName'),
-                  opts.moderation?.ui('displayName'),
+              ),
-                )}
+            )}
-              </>
-            }
             href={profileLink}
             onBeforePress={onBeforePressAuthor}
           />

src/view/com/util/post-embeds/GifEmbed.tsx

@@ -1,5 +1,12 @@
 import React from 'react'
-import {Pressable, StyleSheet, TouchableOpacity, View} from 'react-native'
+import {
+  Pressable,
+  StyleProp,
+  StyleSheet,
+  TouchableOpacity,
+  View,
+  ViewStyle,
+} from 'react-native'
 import {AppBskyEmbedExternal} from '@atproto/api'
 import {FontAwesomeIcon} from '@fortawesome/react-native-fontawesome'
 import {msg, Trans} from '@lingui/macro'
@@ -89,10 +96,12 @@ export function GifEmbed({
   params,
   link,
   hideAlt,
+  style = {width: '100%'},
 }: {
   params: EmbedPlayerParams
   link: AppBskyEmbedExternal.ViewExternal
   hideAlt?: boolean
+  style?: StyleProp<ViewStyle>
 }) {
   const {_} = useLingui()
   const autoplayDisabled = useAutoplayDisabled()
@@ -124,7 +133,7 @@ export function GifEmbed({
   )
 
   return (
-    <View style={[a.rounded_sm, a.overflow_hidden, a.mt_sm, {width: '100%'}]}>
+    <View style={[a.rounded_sm, a.overflow_hidden, a.mt_sm, style]}>
       <View
         style={[
           a.rounded_sm,

src/view/com/util/post-embeds/index.tsx

@@ -131,7 +131,7 @@ export function PostEmbeds({
         const {alt, thumb, aspectRatio} = images[0]
         return (
           <ContentHider modui={moderation?.ui('contentMedia')}>
-            <View style={[styles.imagesContainer, style]}>
+            <View style={[styles.container, style]}>
               <AutoSizedImage
                 alt={alt}
                 uri={thumb}
@@ -156,7 +156,7 @@ export function PostEmbeds({
 
       return (
         <ContentHider modui={moderation?.ui('contentMedia')}>
-          <View style={[styles.imagesContainer, style]}>
+          <View style={[styles.container, style]}>
             <ImageLayoutGrid
               images={embed.images}
               onPress={_openLightbox}
@@ -174,7 +174,11 @@ export function PostEmbeds({
     const link = embed.external
     return (
       <ContentHider modui={moderation?.ui('contentMedia')}>
-        <ExternalLinkEmbed link={link} onOpen={onOpen} style={style} />
+        <ExternalLinkEmbed
+          link={link}
+          onOpen={onOpen}
+          style={[styles.container, style]}
+        />
       </ContentHider>
     )
   }
@@ -183,7 +187,7 @@ export function PostEmbeds({
 }
 
 const styles = StyleSheet.create({
-  imagesContainer: {
+  container: {
     marginTop: 8,
   },
   altContainer: {

src/view/screens/Search/Explore.tsx

@@ -10,6 +10,7 @@ import {
 import {msg, Trans} from '@lingui/macro'
 import {useLingui} from '@lingui/react'
 
+import {useGate} from '#/lib/statsig/statsig'
 import {logger} from '#/logger'
 import {isWeb} from '#/platform/detection'
 import {useModerationOpts} from '#/state/preferences/moderation-opts'
@@ -241,7 +242,7 @@ type ExploreScreenItems =
   | {
       type: 'profile'
       key: string
-      profile: AppBskyActorDefs.ProfileViewBasic
+      profile: AppBskyActorDefs.ProfileView
     }
   | {
       type: 'feed'
@@ -291,6 +292,7 @@ export function Explore() {
     error: feedsError,
     fetchNextPage: fetchNextFeedsPage,
   } = useGetPopularFeedsQuery({limit: 10})
+  const gate = useGate()
 
   const isLoadingMoreProfiles = isFetchingNextProfilesPage && !isLoadingProfiles
   const onLoadMoreProfiles = React.useCallback(async () => {
@@ -492,7 +494,14 @@ export function Explore() {
         case 'profile': {
           return (
             <View style={[a.border_b, t.atoms.border_contrast_low]}>
-              <ProfileCardWithFollowBtn profile={item.profile} noBg noBorder />
+              <ProfileCardWithFollowBtn
+                profile={item.profile}
+                noBg
+                noBorder
+                showKnownFollowers={gate(
+                  'explore_page_profile_card_social_proof',
+                )}
+              />
             </View>
           )
         }
@@ -555,7 +564,7 @@ export function Explore() {
         }
       }
     },
-    [t, moderationOpts],
+    [t, moderationOpts, gate],
   )
 
   return (

src/view/screens/Settings/index.tsx

@@ -68,6 +68,7 @@ import {navigate, resetToTab} from '#/Navigation'
 import {Email2FAToggle} from './Email2FAToggle'
 import {ExportCarDialog} from './ExportCarDialog'
 import hairlineWidth = StyleSheet.hairlineWidth
+import {atoms as a} from '#/alf'
 
 function SettingsAccountCard({
   account,
@@ -104,7 +105,7 @@ function SettingsAccountCard({
         />
       </View>
       <View style={[s.flex1]}>
-        <Text type="md-bold" style={pal.text} numberOfLines={1}>
+        <Text type="md-bold" style={[pal.text, a.self_start]} numberOfLines={1}>
           {profile?.displayName || account.handle}
         </Text>
         <Text type="sm" style={pal.textLight} numberOfLines={1}>

src/view/screens/Storybook/Buttons.tsx

@@ -20,29 +20,31 @@ export function Buttons() {
       <H1>Buttons</H1>
 
       <View style={[a.flex_row, a.flex_wrap, a.gap_md, a.align_start]}>
-        {['primary', 'secondary', 'secondary_inverted'].map(color => (
+        {['primary', 'secondary', 'secondary_inverted', 'negative'].map(
-          <View key={color} style={[a.gap_md, a.align_start]}>
+          color => (
-            {['solid', 'outline', 'ghost'].map(variant => (
+            <View key={color} style={[a.gap_md, a.align_start]}>
-              <React.Fragment key={variant}>
+              {['solid', 'outline', 'ghost'].map(variant => (
-                <Button
+                <React.Fragment key={variant}>
-                  variant={variant as ButtonVariant}
+                  <Button
-                  color={color as ButtonColor}
+                    variant={variant as ButtonVariant}
-                  size="large"
+                    color={color as ButtonColor}
-                  label="Click here">
+                    size="large"
-                  <ButtonText>Button</ButtonText>
+                    label="Click here">
-                </Button>
+                    <ButtonText>Button</ButtonText>
-                <Button
+                  </Button>
-                  disabled
+                  <Button
-                  variant={variant as ButtonVariant}
+                    disabled
-                  color={color as ButtonColor}
+                    variant={variant as ButtonVariant}
-                  size="large"
+                    color={color as ButtonColor}
-                  label="Click here">
+                    size="large"
-                  <ButtonText>Button</ButtonText>
+                    label="Click here">
-                </Button>
+                    <ButtonText>Button</ButtonText>
-              </React.Fragment>
+                  </Button>
-            ))}
+                </React.Fragment>
-          </View>
+              ))}
-        ))}
+            </View>
+          ),
+        )}
 
         <View style={[a.flex_row, a.gap_md, a.align_start]}>
           <View style={[a.gap_md, a.align_start]}>
@@ -68,6 +70,7 @@ export function Buttons() {
               ),
             )}
           </View>
+          {/*
           <View style={[a.gap_md, a.align_start]}>
             {['gradient_sunset', 'gradient_nordic', 'gradient_bonfire'].map(
               name => (
@@ -91,6 +94,7 @@ export function Buttons() {
               ),
             )}
           </View>
+            */}
         </View>
       </View>
 

src/view/screens/Storybook/Dialogs.tsx

@@ -1,7 +1,9 @@
 import React from 'react'
 import {View} from 'react-native'
+import {useNavigation} from '@react-navigation/native'
 
 import {useDialogStateControlContext} from '#/state/dialogs'
+import {NavigationProp} from 'lib/routes/types'
 import {atoms as a} from '#/alf'
 import {Button, ButtonText} from '#/components/Button'
 import * as Dialog from '#/components/Dialog'
@@ -18,6 +20,7 @@ export function Dialogs() {
   const [shouldRenderUnmountTest, setShouldRenderUnmountTest] =
     React.useState(false)
   const unmountTestInterval = React.useRef<number>()
+  const navigation = useNavigation<NavigationProp>()
 
   const onUnmountTestStartPressWithClose = () => {
     setShouldRenderUnmountTest(true)
@@ -134,6 +137,16 @@ export function Dialogs() {
         <ButtonText>End Unmount Test</ButtonText>
       </Button>
 
+      <Button
+        variant="solid"
+        color="primary"
+        size="small"
+        onPress={() => navigation.navigate('SharedPreferencesTester')}
+        label="two"
+        testID="sharedPrefsTestOpenBtn">
+        <ButtonText>Open Shared Prefs Tester</ButtonText>
+      </Button>
+
       <Prompt.Outer control={prompt}>
         <Prompt.TitleText>This is a prompt</Prompt.TitleText>
         <Prompt.DescriptionText>

src/view/screens/Storybook/Forms.tsx

@@ -41,6 +41,16 @@ export function Forms() {
           />
         </TextField.Root>
 
+        <TextField.Root>
+          <TextField.Icon icon={Globe} />
+          <TextField.Input
+            value={value}
+            onChangeText={setValue}
+            label="Text field"
+            isInvalid
+          />
+        </TextField.Root>
+
         <View style={[a.w_full]}>
           <TextField.LabelText>Text field</TextField.LabelText>
           <TextField.Root>