chore: sync with upstream (#58)

* Send inferrable interactions to third-party feeds (#9094)

* Fix link crash (#9102)

* fix link crash

* fix link crash

* Log OTA errors properly (#9101)

* Log OTA errors properly

* filter out network errors

* don't send some "activity no longer available" errors (#9100)

* remove root sibling library (#9097)

* Catch errors on geolocation request, reduce Sentry logs (#9098)

* Nightly source-language update

* fix gap on profile (#9081)

* Update admonition component (#9068)

* update admonition component

* fix linting, adominition alighment

* design tweak

* edge cases for admonition, update storybook

* Update src/components/Admonition.tsx

Co-authored-by: Samuel Newman <[e-mail]>

* fix mobile version

* change button style

---------

Co-authored-by: Samuel Newman <[e-mail]>

* Button tweaks (#9106)

* Tweak button colors

* Semi bold only for tiny buttons

* [Web] Fix thread jumps (#9111)

* [Web] Fix thread jumps

* Comment formatting

---------

Co-authored-by: Eric Bailey <[e-mail]>

* Add StackedButton component (#9086)

* Nightly source-language update

* Fix feedfeedback metrics not distinguishing which feed it's from (#9099)

* fix feedfeedback metrics being sent for all feeds

* remove `discover:` metrics

* add patent pledge link to readme (#9118)

* Language selection and suggestion UX improvements (#9067)

* feat: don't retain accepted language suggestion after finishing or exiting post (#8886)

* feat: don't retain accepted language suggestion after finishing or exiting post

* fix: rebase fixes

* fix: rebase fixes

* chore: lint

* Rename onChange for clarity

* Improve logic in composer

* Handle user override more explicitly

* Drill in onSelectLanguage callback into dialog too

* Fix typo

Co-authored-by: surfdude29 <[e-mail]>

* Make text crystal clear

* Handle multiple languages

---------

Co-authored-by: Elijah Seed-Arita <[e-mail]>
Co-authored-by: surfdude29 <[e-mail]>

* Tighten up eslint rule to catch unused `const {_} = useLingui()` (#9122)

* tighten eslint config to catch unused `useLingui`s

* fix now-invalid uses of _

* remove unused function that produces a ton of eslint warnings

* upgrade react compiler plugin

* [Fix Logouts] Remove buggy hackfix (#9108)

* Rip out the network hack in favor of bluesky-social/atproto#4238

* Bump api pkg

* Debug code

* Revert "Debug code"

This reverts commit 38445f31f4d7bc6c360a18080a059040bd6b07d1.

---------

Co-authored-by: Eric Bailey <[e-mail]>

* Nightly source-language update

* fix: missed alf reversion

---------

Co-authored-by: dan <[e-mail]>
Co-authored-by: Samuel Newman <[e-mail]>
Co-authored-by: pfrazee <[e-mail]>
Co-authored-by: Chenyu <[e-mail]>
Co-authored-by: Eric Bailey <[e-mail]>
Co-authored-by: Daniel Holmgren <[e-mail]>
Co-authored-by: Elijah Seed-Arita <[e-mail]>
Co-authored-by: surfdude29 <[e-mail]>

.eslintrc.js

···
     'no-unused-vars': 'off',
     '@typescript-eslint/no-unused-vars': [
       'error',
-      {argsIgnorePattern: '^_', varsIgnorePattern: '^_'},
+      {argsIgnorePattern: '^_', varsIgnorePattern: '^_.+'},
     ],
     '@typescript-eslint/consistent-type-imports': [
       'warn',

README.md

···
 
 See [./LICENSE](./LICENSE) for the full license.
 
+Bluesky Social PBC has committed to a software patent non-aggression pledge. For details see [the original announcement](https://bsky.social/about/blog/10-01-2025-patent-pledge).
+
 ## P.S.
 
 We ❤️ you and all of the ways you support us. Thank you for making Bluesky a great place!

package.json

···
     "icons:optimize": "svgo -f ./assets/icons"
   },
   "dependencies": {
-    "@atproto/api": "^0.16.7",
+    "@atproto/api": "^0.17.0",
     "@bitdrift/react-native": "^0.6.8",
     "@braintree/sanitize-url": "^6.0.2",
     "@discord/bottom-sheet": "bluesky-social/react-native-bottom-sheet",
···
     "babel-jest": "^29.7.0",
     "babel-plugin-macros": "^3.1.0",
     "babel-plugin-module-resolver": "^5.0.2",
-    "babel-plugin-react-compiler": "^19.1.0-rc.1",
+    "babel-plugin-react-compiler": "^19.1.0-rc.3",
     "babel-preset-expo": "~54.0.0",
     "eslint": "^8.19.0",
     "eslint-plugin-bsky-internal": "link:./eslint",
···
     "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-lingui": "^0.2.0",
     "eslint-plugin-react": "^7.33.2",
-    "eslint-plugin-react-compiler": "^19.1.0-rc.1",
+    "eslint-plugin-react-compiler": "^19.1.0-rc.2",
     "eslint-plugin-react-native-a11y": "^3.3.0",
     "eslint-plugin-simple-import-sort": "^12.0.0",
     "file-loader": "6.2.0",

src/components/Button.tsx

···
     } else if (size === 'small') {
       baseStyles.push(a.text_sm, a.leading_snug, a.font_medium)
     } else if (size === 'tiny') {
-      baseStyles.push(a.text_xs, a.leading_snug, a.font_semi_bold)
+      baseStyles.push(a.text_xs, a.leading_snug, a.font_bold)
     }
 
     return StyleSheet.flatten(baseStyles)

src/components/PostControls/ShareMenu/RecentChats.tsx

···
 
 export function RecentChats({postUri}: {postUri: string}) {
   const control = useDialogContext()
-  const {_} = useLingui()
   const {currentAccount} = useSession()
   const {data} = useListConvosQuery({status: 'accepted'})
   const convos = data?.pages[0]?.convos?.slice(0, 10)

src/components/dialogs/StarterPackDialog.tsx

···
   targetDid,
   enabled,
 }: StarterPackDialogProps) {
-  const {_} = useLingui()
   const navigation = useNavigation<NavigationProp>()
   const requireEmailVerification = useRequireEmailVerification()
 

src/lib/hooks/useIntentHandler.ts

···
       }
 
       const urlp = new URL(url)
-      const [_, intent, intentType] = urlp.pathname.split('/')
+      const [__, intent, intentType] = urlp.pathname.split('/')
 
       // On native, our links look like bluesky://intent/SomeIntent, so we have to check the hostname for the
       // intent check. On web, we have to check the first part of the path since we have an actual hostname

src/lib/strings/embed-player.ts

···
     urlp.hostname === 'm.youtube.com' ||
     urlp.hostname === 'music.youtube.com'
   ) {
-    const [_, page, shortOrLiveVideoId] = urlp.pathname.split('/')
+    const [__, page, shortOrLiveVideoId] = urlp.pathname.split('/')
 
     const isShorts = page === 'shorts'
     const isLive = page === 'live'
···
         window.location.hostname
       : 'localhost'
 
-    const [_, channelOrVideo, clipOrId, id] = urlp.pathname.split('/')
+    const [__, channelOrVideo, clipOrId, id] = urlp.pathname.split('/')
 
     if (channelOrVideo === 'videos') {
       return {
···
 
   // spotify
   if (urlp.hostname === 'open.spotify.com') {
-    const [_, typeOrLocale, idOrType, id] = urlp.pathname.split('/')
+    const [__, typeOrLocale, idOrType, id] = urlp.pathname.split('/')
 
     if (idOrType) {
       if (typeOrLocale === 'playlist' || idOrType === 'playlist') {
···
     urlp.hostname === 'soundcloud.com' ||
     urlp.hostname === 'www.soundcloud.com'
   ) {
-    const [_, user, trackOrSets, set] = urlp.pathname.split('/')
+    const [__, user, trackOrSets, set] = urlp.pathname.split('/')
 
     if (user && trackOrSets) {
       if (trackOrSets === 'sets' && set) {
···
   }
 
   if (urlp.hostname === 'vimeo.com' || urlp.hostname === 'www.vimeo.com') {
-    const [_, videoId] = urlp.pathname.split('/')
+    const [__, videoId] = urlp.pathname.split('/')
     if (videoId) {
       return {
         type: 'vimeo_video',
···
   }
 
   if (urlp.hostname === 'giphy.com' || urlp.hostname === 'www.giphy.com') {
-    const [_, gifs, nameAndId] = urlp.pathname.split('/')
+    const [__, gifs, nameAndId] = urlp.pathname.split('/')
 
     /*
      * nameAndId is a string that consists of the name (dash separated) and the id of the gif (the last part of the name)
···
   // These can include (presumably) a tracking id in the path name, so we have to check for that as well
   if (giphyRegex.test(urlp.hostname)) {
     // We can link directly to the gif, if its a proper link
-    const [_, media, trackingOrId, idOrFilename, filename] =
+    const [__, media, trackingOrId, idOrFilename, filename] =
       urlp.pathname.split('/')
 
     if (media === 'media') {
···
   // Finally, we should see if it is a link to i.giphy.com. These links don't necessarily end in .gif but can also
   // be .webp
   if (urlp.hostname === 'i.giphy.com' || urlp.hostname === 'www.i.giphy.com') {
-    const [_, mediaOrFilename, filename] = urlp.pathname.split('/')
+    const [__, mediaOrFilename, filename] = urlp.pathname.split('/')
 
     if (mediaOrFilename === 'media' && filename) {
       const gifId = filename.split('.')[0]
···
     const path_components = urlp.pathname.slice(1, i + 1).split('/')
     if (path_components.length === 4) {
       // discard username - it's not relevant
-      const [photos, _, albums, id] = path_components
+      const [photos, __, albums, id] = path_components
       if (photos === 'photos' && albums === 'albums') {
         // this at least has the shape of a valid photo-album URL!
         return {
···
   // link shortened flickr path
   if (urlp.hostname === 'flic.kr') {
     const b58alph = '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
-    let [_, type, idBase58Enc] = urlp.pathname.split('/')
+    let [__, type, idBase58Enc] = urlp.pathname.split('/')
     let id = 0n
     for (const char of idBase58Enc) {
       const nextIdx = b58alph.indexOf(char)
···
     return {success: false}
   }
 
-  let [_, id, filename] = urlp.pathname.split('/')
+  let [__, id, filename] = urlp.pathname.split('/')
 
   if (!id || !filename) {
     return {success: false}

src/lib/strings/helpers.ts

···
   }, [splitter, maxCount, text])
 }
 
-// https://stackoverflow.com/a/52171480
-export function toHashCode(str: string, seed = 0): number {
-  let h1 = 0xdeadbeef ^ seed,
-    h2 = 0x41c6ce57 ^ seed
-  for (let i = 0, ch; i < str.length; i++) {
-    ch = str.charCodeAt(i)
-    h1 = Math.imul(h1 ^ ch, 2654435761)
-    h2 = Math.imul(h2 ^ ch, 1597334677)
-  }
-  h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507)
-  h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909)
-  h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507)
-  h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909)
-
-  return 4294967296 * (2097151 & h2) + (h1 >>> 0)
-}
-
 export function countLines(str: string | undefined): number {
   if (!str) return 0
   return str.match(/\n/g)?.length ?? 0

src/lib/strings/starter-pack.ts

···
     } else {
       const url = new URL(uri)
       const parts = url.pathname.split('/')
-      const [_, path, name, rkey] = parts
+      const [__, path, name, rkey] = parts
 
       if (parts.length !== 4) return null
       if (path !== 'starter-pack' && path !== 'start') return null

src/logger/metrics.ts

···
   'feed:suggestion:press': {
     feedUrl: string
   }
-  'discover:showMore': {
+  'feed:showMore': {
+    feed: string
     feedContext: string
   }
-  'discover:showLess': {
+  'feed:showLess': {
+    feed: string
     feedContext: string
   }
-  'discover:clickthrough': {
+  'feed:clickthrough': {
+    feed: string
     count: number
   }
-  'discover:engaged': {
+  'feed:engaged': {
+    feed: string
     count: number
   }
-  'discover:seen': {
+  'feed:seen': {
+    feed: string
     count: number
   }
 

src/screens/Onboarding/StepFinished.tsx

···
 import * as bsky from '#/types/bsky'
 
 export function StepFinished() {
-  const {_} = useLingui()
   const {state, dispatch} = useContext(Context)
   const onboardDispatch = useOnboardingDispatch()
   const [saving, setSaving] = useState(false)
···
 
 function Dot({active}: {active: boolean}) {
   const t = useTheme()
-  const {_} = useLingui()
 
   return (
     <View

src/screens/Search/Shell.tsx

···
   const {hasSession} = useSession()
   const {gtTablet} = useBreakpoints()
   const [activeTab, setActiveTab] = useState(0)
-  const {_} = useLingui()
 
   const onPageSelected = useCallback(
     (index: number) => {

src/screens/Search/modules/ExploreTrendingVideos.tsx

···
 }
 
 export function ExploreTrendingVideos() {
-  const {_} = useLingui()
   const gutters = useGutters([0, 'base'])
   const {data, isLoading, error} = usePostFeedQuery(FEED_DESC, FEED_PARAMS)
 

src/state/feed-feedback.tsx

···
 
 import {PROD_FEEDS, STAGING_FEEDS} from '#/lib/constants'
 import {isNetworkError} from '#/lib/hooks/useCleanError'
-import {logEvent} from '#/lib/statsig/statsig'
 import {Logger} from '#/logger'
 import {
   type FeedSourceFeedInfo,
···
   const aggregatedStats = useRef<AggregatedStats | null>(null)
   const throttledFlushAggregatedStats = useMemo(
     () =>
-      throttle(() => flushToStatsig(aggregatedStats.current), 45e3, {
-        leading: true, // The outer call is already throttled somewhat.
-        trailing: true,
-      }),
-    [],
+      throttle(
+        () =>
+          flushToStatsig(
+            aggregatedStats.current,
+            feed?.feedDescriptor ?? 'unknown',
+          ),
+        45e3,
+        {
+          leading: true, // The outer call is already throttled somewhat.
+          trailing: true,
+        },
+      ),
+    [feed?.feedDescriptor],
   )
 
   const sendToFeedNoDelay = useCallback(() => {
···
     sendOrAggregateInteractionsForStats(
       aggregatedStats.current,
       interactionsToSend,
+      feed?.feedDescriptor ?? 'unknown',
     )
     throttledFlushAggregatedStats()
     logger.debug('flushed')
···
 function sendOrAggregateInteractionsForStats(
   stats: AggregatedStats,
   interactions: AppBskyFeedDefs.Interaction[],
+  feed: string,
 ) {
   for (let interaction of interactions) {
     switch (interaction.event) {
       // Pressing "Show more" / "Show less" is relatively uncommon so we won't aggregate them.
       // This lets us send the feed context together with them.
       case 'app.bsky.feed.defs#requestLess': {
-        logEvent('discover:showLess', {
+        logger.metric('feed:showLess', {
+          feed,
           feedContext: interaction.feedContext ?? '',
         })
         break
       }
       case 'app.bsky.feed.defs#requestMore': {
-        logEvent('discover:showMore', {
+        logger.metric('feed:showMore', {
+          feed,
           feedContext: interaction.feedContext ?? '',
         })
         break
···
   }
 }
 
-function flushToStatsig(stats: AggregatedStats | null) {
+function flushToStatsig(stats: AggregatedStats | null, feedDescriptor: string) {
   if (stats === null) {
     return
   }
 
   if (stats.clickthroughCount > 0) {
-    logEvent('discover:clickthrough', {
+    logger.metric('feed:clickthrough', {
       count: stats.clickthroughCount,
+      feed: feedDescriptor,
     })
     stats.clickthroughCount = 0
   }
 
   if (stats.engagedCount > 0) {
-    logEvent('discover:engaged', {
+    logger.metric('feed:engaged', {
       count: stats.engagedCount,
+      feed: feedDescriptor,
     })
     stats.engagedCount = 0
   }
 
   if (stats.seenCount > 0) {
-    logEvent('discover:seen', {
+    logger.metric('feed:seen', {
       count: stats.seenCount,
+      feed: feedDescriptor,
     })
     stats.seenCount = 0
   }

src/state/persisted/schema.ts

···
     contentLanguages: z.array(z.string()),
     /**
      * The language(s) the user is currently posting in, configured within the
-     * composer. Multiple languages are psearate by commas.
+     * composer. Multiple languages are separated by commas.
      *
      * BCP-47 2-letter language code without region.
      */

src/state/preferences/languages.tsx

···
   return postLanguage.split(',').filter(Boolean)
 }
 
+export function fromPostLanguages(languages: string[]): string {
+  return languages.filter(Boolean).join(',')
+}
+
 export function hasPostLanguage(postLanguage: string, code2: string): boolean {
   return toPostLanguages(postLanguage).includes(code2)
 }

src/state/queries/post-feed.ts

···
       }
     }
   } else if (feedDesc.startsWith('author')) {
-    const [_, actor, filter] = feedDesc.split('|')
+    const [__, actor, filter] = feedDesc.split('|')
     return new AuthorFeedAPI({agent, feedParams: {actor, filter}})
   } else if (feedDesc.startsWith('likes')) {
-    const [_, actor] = feedDesc.split('|')
+    const [__, actor] = feedDesc.split('|')
     return new LikesFeedAPI({agent, feedParams: {actor}})
   } else if (feedDesc.startsWith('feedgen')) {
-    const [_, feed] = feedDesc.split('|')
+    const [__, feed] = feedDesc.split('|')
     return new CustomFeedAPI({
       agent,
       feedParams: {feed},
       userInterests,
     })
   } else if (feedDesc.startsWith('list')) {
-    const [_, list] = feedDesc.split('|')
+    const [__, list] = feedDesc.split('|')
     return new ListFeedAPI({agent, feedParams: {list}})
   } else if (feedDesc.startsWith('posts')) {
-    const [_, uriList] = feedDesc.split('|')
+    const [__, uriList] = feedDesc.split('|')
     return new PostListFeedAPI({agent, feedParams: {uris: uriList.split(',')}})
   } else if (feedDesc === 'demo') {
     return new DemoFeedAPI({agent})

src/state/queries/trending/useGetSuggestedUsersQuery.ts

···
     queryClient.getQueriesData<AppBskyUnspeccedGetSuggestedUsers.OutputSchema>({
       queryKey: [getSuggestedUsersQueryKeyRoot],
     })
-  for (const [_, response] of responses) {
+  for (const [_key, response] of responses) {
     if (!response) {
       continue
     }

src/state/session/agent.ts

···
 
     // Now the agent is ready.
     const account = agentToSessionAccountOrThrow(this)
-    let lastSession = this.sessionManager.session
     this.persistSessionHandler = event => {
-      if (this.sessionManager.session) {
-        lastSession = this.sessionManager.session
-      } else if (event === 'network-error') {
-        // Put it back, we'll try again later.
-        this.sessionManager.session = lastSession
-      }
-
       onSessionChange(this, account.did, event)
       if (event !== 'create' && event !== 'update') {
         addSessionErrorLog(account.did, event)

src/view/com/composer/Composer.tsx

···
 import {useModalControls} from '#/state/modals'
 import {useRequireAltTextEnabled} from '#/state/preferences'
 import {
+  fromPostLanguages,
   toPostLanguages,
   useLanguagePrefs,
   useLanguagePrefsApi,
···
   const [publishingStage, setPublishingStage] = useState('')
   const [error, setError] = useState('')
 
+  /**
+   * A temporary local reference to a language suggestion that the user has
+   * accepted. This overrides the global post language preference, but is not
+   * stored permanently.
+   */
+  const [acceptedLanguageSuggestion, setAcceptedLanguageSuggestion] = useState<
+    string | null
+  >(null)
+
+  /**
+   * The language(s) of the post being replied to.
+   */
+  const [replyToLanguages, setReplyToLanguages] = useState<string[]>(
+    replyTo?.langs || [],
+  )
+
+  /**
+   * The currently selected languages of the post. Prefer local temporary
+   * language suggestion over global lang prefs, if available.
+   */
+  const currentLanguages = useMemo(
+    () =>
+      acceptedLanguageSuggestion
+        ? [acceptedLanguageSuggestion]
+        : toPostLanguages(langPrefs.postLanguage),
+    [acceptedLanguageSuggestion, langPrefs.postLanguage],
+  )
+
+  /**
+   * When the user selects a language from the composer language selector,
+   * clear any temporary language suggestions they may have selected
+   * previously, and any we might try to suggest to them.
+   */
+  const onSelectLanguage = () => {
+    setAcceptedLanguageSuggestion(null)
+    setReplyToLanguages([])
+  }
+
   const [composerState, composerDispatch] = useReducer(
     composerReducer,
     {
···
           thread,
           replyTo: replyTo?.uri,
           onStateChange: setPublishingStage,
-          langs: toPostLanguages(langPrefs.postLanguage),
+          langs: currentLanguages,
         })
       ).uris[0]
 
···
             isPartOfThread: thread.posts.length > 1,
             hasLink: !!post.embed.link,
             hasQuote: !!post.embed.quote,
-            langs: langPrefs.postLanguage,
+            langs: fromPostLanguages(currentLanguages),
             logContext: 'Composer',
           })
           index++
···
     thread,
     canPost,
     isPublishing,
-    langPrefs.postLanguage,
+    currentLanguages,
     onClose,
     onPost,
     onPostSuccess,
···
     <>
       <SuggestedLanguage
         text={activePost.richtext.text}
-        // NOTE(@elijaharita): currently just choosing the first language if any exists
-        replyToLanguage={replyTo?.langs?.[0]}
+        replyToLanguages={replyToLanguages}
+        currentLanguages={currentLanguages}
+        onAcceptSuggestedLanguage={setAcceptedLanguageSuggestion}
       />
       <ComposerPills
         isReply={!!replyTo}
···
             type: 'add_post',
           })
         }}
+        currentLanguages={currentLanguages}
+        onSelectLanguage={onSelectLanguage}
       />
     </>
   )
···
   onEmojiButtonPress,
   onSelectVideo,
   onAddPost,
+  currentLanguages,
+  onSelectLanguage,
 }: {
   post: PostDraft
   dispatch: (action: PostAction) => void
···
   onError: (error: string) => void
   onSelectVideo: (postId: string, asset: ImagePickerAsset) => void
   onAddPost: () => void
+  currentLanguages: string[]
+  onSelectLanguage?: (language: string) => void
 }) {
   const t = useTheme()
   const {_} = useLingui()
···
             <PlusIcon size="lg" />
           </Button>
         )}
-        <PostLanguageSelect />
+        <PostLanguageSelect
+          currentLanguages={currentLanguages}
+          onSelectLanguage={onSelectLanguage}
+        />
         <CharProgress
           count={post.shortenedGraphemeLength}
           style={{width: 65}}

src/view/com/composer/photos/EditImageDialog.web.tsx

···
   }) {
   const t = useTheme()
   const [isDragging, setIsDragging] = useState(false)
-  const {_} = useLingui()
   const control = Dialog.useDialogContext()
 
   const source = image.source

src/view/com/composer/select-language/PostLanguageSelect.tsx

···
 import {Text} from '#/components/Typography'
 import {PostLanguageSelectDialog} from './PostLanguageSelectDialog'
 
-export function PostLanguageSelect() {
+export function PostLanguageSelect({
+  currentLanguages: currentLanguagesProp,
+  onSelectLanguage,
+}: {
+  currentLanguages?: string[]
+  onSelectLanguage?: (language: string) => void
+}) {
   const {_} = useLingui()
   const langPrefs = useLanguagePrefs()
   const setLangPrefs = useLanguagePrefsApi()
···
   const dedupedHistory = Array.from(
     new Set([...langPrefs.postLanguageHistory, langPrefs.postLanguage]),
   )
+
+  const currentLanguages =
+    currentLanguagesProp ?? toPostLanguages(langPrefs.postLanguage)
 
   if (
     dedupedHistory.length === 1 &&
···
     return (
       <>
         <LanguageBtn onPress={languageDialogControl.open} />
-        <PostLanguageSelectDialog control={languageDialogControl} />
+        <PostLanguageSelectDialog
+          control={languageDialogControl}
+          currentLanguages={currentLanguages}
+        />
       </>
     )
   }
···
     <>
       <Menu.Root>
         <Menu.Trigger label={_(msg`Select post language`)}>
-          {({props}) => <LanguageBtn {...props} />}
+          {({props}) => (
+            <LanguageBtn currentLanguages={currentLanguages} {...props} />
+          )}
         </Menu.Trigger>
         <Menu.Outer>
           <Menu.Group>
···
                 <Menu.Item
                   key={historyItem}
                   label={_(msg`Select ${langName}`)}
-                  onPress={() => setLangPrefs.setPostLanguage(historyItem)}>
+                  onPress={() => {
+                    setLangPrefs.setPostLanguage(historyItem)
+                    onSelectLanguage?.(historyItem)
+                  }}>
                   <Menu.ItemText>{langName}</Menu.ItemText>
                   <Menu.ItemRadio
-                    selected={historyItem === langPrefs.postLanguage}
+                    selected={currentLanguages.includes(historyItem)}
                   />
                 </Menu.Item>
               )
···
         </Menu.Outer>
       </Menu.Root>
 
-      <PostLanguageSelectDialog control={languageDialogControl} />
+      <PostLanguageSelectDialog
+        control={languageDialogControl}
+        currentLanguages={currentLanguages}
+        onSelectLanguage={onSelectLanguage}
+      />
     </>
   )
 }
 
-function LanguageBtn(props: Omit<ButtonProps, 'label' | 'children'>) {
+function LanguageBtn(
+  props: Omit<ButtonProps, 'label' | 'children'> & {
+    currentLanguages?: string[]
+  },
+) {
   const {_} = useLingui()
   const langPrefs = useLanguagePrefs()
   const t = useTheme()
 
   const postLanguagesPref = toPostLanguages(langPrefs.postLanguage)
+  const currentLanguages = props.currentLanguages ?? postLanguagesPref
 
   return (
     <Button
···
       {({pressed, hovered}) => {
         const color =
           pressed || hovered ? t.palette.primary_300 : t.palette.primary_500
-        if (postLanguagesPref.length > 0) {
+        if (currentLanguages.length > 0) {
           return (
             <Text
               style={[
···
                 {maxWidth: 100},
               ]}
               numberOfLines={1}>
-              {postLanguagesPref
+              {currentLanguages
                 .map(lang => codeToLanguageName(lang, langPrefs.appLanguage))
                 .join(', ')}
             </Text>

src/view/com/composer/select-language/PostLanguageSelectDialog.tsx

···
 import {type Language, LANGUAGES, LANGUAGES_MAP_CODE2} from '#/locale/languages'
 import {isNative, isWeb} from '#/platform/detection'
 import {
+  toPostLanguages,
   useLanguagePrefs,
   useLanguagePrefsApi,
 } from '#/state/preferences/languages'
···
 
 export function PostLanguageSelectDialog({
   control,
+  /**
+   * Optionally can be passed to show different values than what is saved in
+   * langPrefs.
+   */
+  currentLanguages,
+  onSelectLanguage,
 }: {
   control: Dialog.DialogControlProps
+  currentLanguages?: string[]
+  onSelectLanguage?: (language: string) => void
 }) {
   const {height} = useWindowDimensions()
   const insets = useSafeAreaInsets()
···
       nativeOptions={{minHeight: height - insets.top}}>
       <Dialog.Handle />
       <ErrorBoundary renderError={renderErrorBoundary}>
-        <DialogInner />
+        <DialogInner
+          currentLanguages={currentLanguages}
+          onSelectLanguage={onSelectLanguage}
+        />
       </ErrorBoundary>
     </Dialog.Outer>
   )
 }
 
-export function DialogInner() {
+export function DialogInner({
+  currentLanguages,
+  onSelectLanguage,
+}: {
+  currentLanguages?: string[]
+  onSelectLanguage?: (language: string) => void
+}) {
   const control = Dialog.useDialogContext()
   const [headerHeight, setHeaderHeight] = useState(0)
 
···
   }, [])
 
   const langPrefs = useLanguagePrefs()
+  const postLanguagesPref =
+    currentLanguages ?? toPostLanguages(langPrefs.postLanguage)
+
   const [checkedLanguagesCode2, setCheckedLanguagesCode2] = useState<string[]>(
-    langPrefs.postLanguage.split(',') || [langPrefs.primaryLanguage],
+    postLanguagesPref || [langPrefs.primaryLanguage],
   )
   const [search, setSearch] = useState('')
 
···
         langsString = langPrefs.primaryLanguage
       }
       setLangPrefs.setPostLanguage(langsString)
+      onSelectLanguage?.(langsString)
     })
   }
 

src/view/com/composer/select-language/SuggestedLanguage.tsx

···
 import {useEffect, useState} from 'react'
-import {View} from 'react-native'
+import {Text as RNText, View} from 'react-native'
 import {parseLanguage} from '@atproto/api'
 import {msg, Trans} from '@lingui/macro'
 import {useLingui} from '@lingui/react'
 import lande from 'lande'
 
 import {code3ToCode2Strict, codeToLanguageName} from '#/locale/helpers'
-import {
-  toPostLanguages,
-  useLanguagePrefs,
-  useLanguagePrefsApi,
-} from '#/state/preferences/languages'
+import {useLanguagePrefs} from '#/state/preferences/languages'
 import {atoms as a, useTheme} from '#/alf'
 import {Button, ButtonText} from '#/components/Button'
 import {Earth_Stroke2_Corner2_Rounded as EarthIcon} from '#/components/icons/Globe'
···
 
 export function SuggestedLanguage({
   text,
-  replyToLanguage: replyToLanguageProp,
+  replyToLanguages: replyToLanguagesProp,
+  currentLanguages,
+  onAcceptSuggestedLanguage,
 }: {
   text: string
-  replyToLanguage?: string
+  /**
+   * All languages associated with the post being replied to.
+   */
+  replyToLanguages: string[]
+  /**
+   * All languages currently selected for the post being composed.
+   */
+  currentLanguages: string[]
+  /**
+   * Called when the user accepts a suggested language. We only pass a single
+   * language here. If the post being replied to has multiple languages, we
+   * only suggest the first one.
+   */
+  onAcceptSuggestedLanguage: (language: string | null) => void
 }) {
-  const replyToLanguage = cleanUpLanguage(replyToLanguageProp)
+  const langPrefs = useLanguagePrefs()
+  const replyToLanguages = replyToLanguagesProp
+    .map(lang => cleanUpLanguage(lang))
+    .filter(Boolean) as string[]
+  const [hasInteracted, setHasInteracted] = useState(false)
   const [suggestedLanguage, setSuggestedLanguage] = useState<
     string | undefined
-  >(text.length === 0 ? replyToLanguage : undefined)
-  const langPrefs = useLanguagePrefs()
-  const setLangPrefs = useLanguagePrefsApi()
-  const t = useTheme()
-  const {_} = useLingui()
+  >(undefined)
 
   useEffect(() => {
-    // For replies, suggest the language of the post being replied to if no text
-    // has been typed yet
-    if (replyToLanguage && text.length === 0) {
-      setSuggestedLanguage(replyToLanguage)
-      return
+    if (text.length > 0 && !hasInteracted) {
+      setHasInteracted(true)
     }
+  }, [text, hasInteracted])
 
+  useEffect(() => {
     const textTrimmed = text.trim()
 
     // Don't run the language model on small posts, the results are likely
···
     })
 
     return () => cancelIdle(idle)
-  }, [text, replyToLanguage])
+  }, [text])
+
+  /*
+   * We've detected a language, and the user hasn't already selected it.
+   */
+  const hasLanguageSuggestion =
+    suggestedLanguage && !currentLanguages.includes(suggestedLanguage)
+  /*
+   * We have not detected a different language, and the user is not already
+   * using or has not already selected one of the languages of the post they
+   * are replying to.
+   */
+  const hasSuggestedReplyLanguage =
+    !hasInteracted &&
+    !suggestedLanguage &&
+    replyToLanguages.length &&
+    !replyToLanguages.some(l => currentLanguages.includes(l))
 
-  if (
-    suggestedLanguage &&
-    !toPostLanguages(langPrefs.postLanguage).includes(suggestedLanguage)
-  ) {
+  if (hasLanguageSuggestion) {
     const suggestedLanguageName = codeToLanguageName(
       suggestedLanguage,
       langPrefs.appLanguage,
     )
 
     return (
+      <LanguageSuggestionButton
+        label={
+          <RNText>
+            <Trans>
+              Are you writing in{' '}
+              <Text style={[a.font_bold]}>{suggestedLanguageName}</Text>?
+            </Trans>
+          </RNText>
+        }
+        value={suggestedLanguage}
+        onAccept={onAcceptSuggestedLanguage}
+      />
+    )
+  } else if (hasSuggestedReplyLanguage) {
+    const suggestedLanguageName = codeToLanguageName(
+      replyToLanguages[0],
+      langPrefs.appLanguage,
+    )
+
+    return (
+      <LanguageSuggestionButton
+        label={
+          <RNText>
+            <Trans>
+              The post you're replying to was marked as being written in{' '}
+              {suggestedLanguageName} by its author. Would you like to reply in{' '}
+              <Text style={[a.font_bold]}>{suggestedLanguageName}</Text>?
+            </Trans>
+          </RNText>
+        }
+        value={replyToLanguages[0]}
+        onAccept={onAcceptSuggestedLanguage}
+      />
+    )
+  } else {
+    return null
+  }
+}
+
+function LanguageSuggestionButton({
+  label,
+  value,
+  onAccept,
+}: {
+  label: React.ReactNode
+  value: string
+  onAccept: (language: string | null) => void
+}) {
+  const t = useTheme()
+  const {_} = useLingui()
+
+  return (
+    <View style={[a.px_lg, a.py_sm]}>
       <View
         style={[
-          t.atoms.border_contrast_low,
-          a.gap_sm,
+          a.gap_md,
           a.border,
           a.flex_row,
           a.align_center,
           a.rounded_sm,
-          a.px_lg,
-          a.py_md,
-          a.mx_md,
-          a.my_sm,
+          a.p_md,
+          a.pl_lg,
           t.atoms.bg,
+          t.atoms.border_contrast_low,
         ]}>
         <EarthIcon />
-        <Text style={[a.flex_1]}>
-          <Trans>
-            Are you writing in{' '}
-            <Text style={[a.font_bold]}>{suggestedLanguageName}</Text>?
-          </Trans>
-        </Text>
+        <View style={[a.flex_1]}>
+          <Text
+            style={[
+              a.flex_1,
+              a.leading_snug,
+              {
+                maxWidth: 400,
+              },
+            ]}>
+            {label}
+          </Text>
+        </View>
 
         <Button
-          color="secondary"
           size="small"
-          variant="solid"
-          onPress={() => setLangPrefs.setPostLanguage(suggestedLanguage)}
-          label={_(msg`Change post language to ${suggestedLanguageName}`)}>
+          color="secondary"
+          onPress={() => onAccept(value)}
+          label={_(msg`Accept this language suggestion`)}>
           <ButtonText>
             <Trans>Yes</Trans>
           </ButtonText>
         </Button>
       </View>
-    )
-  } else {
-    return null
-  }
+    </View>
+  )
 }
 
 /**

src/view/com/composer/text-input/web/TagDecorator.ts

···
 
       let match
       while ((match = regex.exec(textContent))) {
-        const [matchedString, _, tag] = match
+        const [matchedString, __, tag] = match
 
         if (!tag || tag.replace(TRAILING_PUNCTUATION_REGEX, '').length > 64)
           continue

src/view/com/posts/PostFeedErrorMessage.tsx

···
       })[knownError],
     [_l, knownError],
   )
-  const [_, uri] = feedDesc.split('|')
+  const [__, uri] = feedDesc.split('|')
   const [ownerDid] = safeParseFeedgenUri(uri)
   const removePromptControl = Prompt.usePromptControl()
   const {mutateAsync: removeFeed} = useRemoveFeedMutation()

src/view/screens/ModerationMutedAccounts.tsx

···
 import {type StyleProp, View, type ViewStyle} from 'react-native'
 import {type AppBskyActorDefs as ActorDefs} from '@atproto/api'
 import {Trans} from '@lingui/macro'
-import {useLingui} from '@lingui/react'
 import {useFocusEffect} from '@react-navigation/native'
 import {type NativeStackScreenProps} from '@react-navigation/native-stack'
 
···
 export function ModerationMutedAccounts({}: Props) {
   const t = useTheme()
   const moderationOpts = useModerationOpts()
-  const {_} = useLingui()
   const setMinimalShellMode = useSetMinimalShellMode()
 
   const [isPTRing, setIsPTRing] = useState(false)

src/view/screens/ProfileFeedLikedBy.tsx

···
 import {useCallback} from 'react'
 import {Trans} from '@lingui/macro'
-import {useLingui} from '@lingui/react'
 import {useFocusEffect} from '@react-navigation/native'
 
 import {
···
   const setMinimalShellMode = useSetMinimalShellMode()
   const {name, rkey} = route.params
   const uri = makeRecordUri(name, 'app.bsky.feed.generator', rkey)
-  const {_} = useLingui()
 
   useFocusEffect(
     useCallback(() => {

src/view/screens/Storybook/Buttons.tsx

···
         </StackedButton>
       </View>
 
+      <View style={[a.flex_row, a.gap_md, a.align_start, {maxWidth: 350}]}>
+        <StackedButton
+          label="stacked"
+          icon={Globe}
+          color="secondary"
+          style={[a.flex_1]}>
+          Bop it
+        </StackedButton>
+        <StackedButton
+          label="stacked"
+          icon={Globe}
+          color="negative_subtle"
+          style={[a.flex_1]}>
+          Twist it
+        </StackedButton>
+        <StackedButton
+          label="stacked"
+          icon={Globe}
+          color="primary"
+          style={[a.flex_1]}>
+          Pull it
+        </StackedButton>
+      </View>
+
       {[
         'primary',
         'secondary',

yarn.lock

···
     tlds "^1.234.0"
     zod "^3.23.8"
 
+"@atproto/api@^0.17.0":
+  version "0.17.0"
+  resolved "https://registry.yarnpkg.com/@atproto/api/-/api-0.17.0.tgz#1fe87ef703f8020dbe00bb5e5cc18622b8b91f4a"
+  integrity sha512-FNS9SW7/3kslAnJH7F4fO9/jPjXzC0NMD6u9NjJ/h4EnaIEpWHZQPkmD9Q2hvAwD6+Uo2boYZEPKkOa55Lr5Dg==
+  dependencies:
+    "@atproto/common-web" "^0.4.3"
+    "@atproto/lexicon" "^0.5.1"
+    "@atproto/syntax" "^0.4.1"
+    "@atproto/xrpc" "^0.7.5"
+    await-lock "^2.2.2"
+    multiformats "^9.9.0"
+    tlds "^1.234.0"
+    zod "^3.23.8"
+
 "@atproto/aws@^0.2.28":
   version "0.2.28"
   resolved "https://registry.yarnpkg.com/@atproto/aws/-/aws-0.2.28.tgz#17bd88a6276e323ebb094a3f01bd94b1173a29a4"
···
     uint8arrays "3.0.0"
     zod "^3.23.8"
 
+"@atproto/common-web@^0.4.3":
+  version "0.4.3"
+  resolved "https://registry.yarnpkg.com/@atproto/common-web/-/common-web-0.4.3.tgz#b4480220b5682db09da45f4ef906eb7619c838b5"
+  integrity sha512-nRDINmSe4VycJzPo6fP/hEltBcULFxt9Kw7fQk6405FyAWZiTluYHlXOnU7GkQfeUK44OENG1qFTBcmCJ7e8pg==
+  dependencies:
+    graphemer "^1.4.0"
+    multiformats "^9.9.0"
+    uint8arrays "3.0.0"
+    zod "^3.23.8"
+
 "@atproto/common@0.1.0":
   version "0.1.0"
   resolved "https://registry.yarnpkg.com/@atproto/common/-/common-0.1.0.tgz#4216a8fef5b985ab62ac21252a0f8ca0f4a0f210"
···
   integrity sha512-3aAzEAy9EAPs3CxznzMhEcqDd7m3vz1eze/ya9/ThbB7yleqJIhz5GY2q76tCCwHPhn5qDDMhlA9kKV6fG23gA==
   dependencies:
     "@atproto/common-web" "^0.4.2"
+    "@atproto/syntax" "^0.4.1"
+    iso-datestring-validator "^2.2.2"
+    multiformats "^9.9.0"
+    zod "^3.23.8"
+
+"@atproto/lexicon@^0.5.1":
+  version "0.5.1"
+  resolved "https://registry.yarnpkg.com/@atproto/lexicon/-/lexicon-0.5.1.tgz#e9b7d5c70dc5a38518a8069cd80fea77ab526947"
+  integrity sha512-y8AEtYmfgVl4fqFxqXAeGvhesiGkxiy3CWoJIfsFDDdTlZUC8DFnZrYhcqkIop3OlCkkljvpSJi1hbeC1tbi8A==
+  dependencies:
+    "@atproto/common-web" "^0.4.3"
     "@atproto/syntax" "^0.4.1"
     iso-datestring-validator "^2.2.2"
     multiformats "^9.9.0"
···
   integrity sha512-sDi68+QE1XHegTaNAndlX41Gp827pouSzSs8CyAwhrqZdsJUxE3P7TMtrA0z+zAjvxVyvzscRc0TsN/fGUGrhw==
   dependencies:
     "@atproto/lexicon" "^0.5.0"
+    zod "^3.23.8"
+
+"@atproto/xrpc@^0.7.5":
+  version "0.7.5"
+  resolved "https://registry.yarnpkg.com/@atproto/xrpc/-/xrpc-0.7.5.tgz#40cef1a657b5f28af8ebec9e3dac5872e58e88ea"
+  integrity sha512-MUYNn5d2hv8yVegRL0ccHvTHAVj5JSnW07bkbiaz96UH45lvYNRVwt44z+yYVnb0/mvBzyD3/ZQ55TRGt7fHkA==
+  dependencies:
+    "@atproto/lexicon" "^0.5.1"
     zod "^3.23.8"
 
 "@aws-crypto/crc32@3.0.0":
···
   dependencies:
     "@babel/helper-define-polyfill-provider" "^0.6.3"
 
-babel-plugin-react-compiler@^19.1.0-rc.1:
-  version "19.1.0-rc.1"
-  resolved "https://registry.yarnpkg.com/babel-plugin-react-compiler/-/babel-plugin-react-compiler-19.1.0-rc.1.tgz#99d131be61017e40abbaedd98321069bf8b7e54a"
-  integrity sha512-M4fpG+Hfq5gWzsJeeMErdRokzg0fdJ8IAk+JDhfB/WLT+U3WwJWR8edphypJrk447/JEvYu6DBFwsTn10bMW4Q==
-  dependencies:
-    "@babel/types" "^7.26.0"
-
-babel-plugin-react-compiler@^19.1.0-rc.2:
+babel-plugin-react-compiler@^19.1.0-rc.2, babel-plugin-react-compiler@^19.1.0-rc.3:
   version "19.1.0-rc.3"
   resolved "https://registry.yarnpkg.com/babel-plugin-react-compiler/-/babel-plugin-react-compiler-19.1.0-rc.3.tgz#45e5a282a2460b3701971e5eb8310a90a7919022"
   integrity sha512-mjRn69WuTz4adL0bXGx8Rsyk1086zFJeKmes6aK0xPuK3aaXmDJdLHqwKKMrpm6KAI1MCoUK72d2VeqQbu8YIA==
···
   dependencies:
     "@typescript-eslint/utils" "^5.61.0"
 
-eslint-plugin-react-compiler@^19.1.0-rc.1:
-  version "19.1.0-rc.1"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-react-compiler/-/eslint-plugin-react-compiler-19.1.0-rc.1.tgz#e974ba9541c9a4464d77723e0505b5742bc22e56"
-  integrity sha512-3umw5eqZXapBl7aQGmvcjheKhUbsElb9jTETxRZg371e1LG4EPs/zCHt2JzP+wNcdaZWzjU/R730zPUJblY2zw==
+eslint-plugin-react-compiler@^19.1.0-rc.2:
+  version "19.1.0-rc.2"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-react-compiler/-/eslint-plugin-react-compiler-19.1.0-rc.2.tgz#83343e7422e00fa61e729af8e8468f0ddec37925"
+  integrity sha512-oKalwDGcD+RX9mf3NEO4zOoUMeLvjSvcbbEOpquzmzqEEM2MQdp7/FY/Hx9NzmUwFzH1W9SKTz5fihfMldpEYw==
   dependencies:
     "@babel/core" "^7.24.4"
     "@babel/parser" "^7.24.4"