Age Assurance V2 (#9479)

* Age Assurance V2

* Tighten up test

* Add todos for sdk migration

* Align RQ versions

* Use useEffect for side effect

* Improve effects, memoize

* Standarize on birthdate

* Copy feedback

* Copilot

* Add support link

* Reove double ..

* Cleanup

* Remove redirect dialog

* Cleanup todos, add comments

* Update splash in main template too

* Mock some stuff

* Exhaustive checks

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

* Exhaustive checks

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

* Small fix to bday handling

* Add comment

* onboarding style tweak

sneaking this in sorry!

* rm unreachable breaks

* Put useIntentHandler back on web

* Remove misleading success set

* Align on birthdate

---------

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

.env.example

···
 
 # bapp-config web worker URL
 BAPP_CONFIG_DEV_URL=
-
-# Dev-only passthrough value for bapp-config web worker
-BAPP_CONFIG_DEV_BYPASS_SECRET=

__tests__/lib/string.test.ts

···
   })
 
   it('returns the at uri when the input is a valid starterpack at uri', () => {
-    const validAtUri = 'at://did:123/app.bsky.graph.starterpack/rkey'
+    const validAtUri = 'at://did:plc:123/app.bsky.graph.starterpack/rkey'
     expect(parseStarterPackUri(validAtUri)).toEqual({
-      name: 'did:123',
+      name: 'did:plc:123',
       rkey: 'rkey',
     })
   })
 
   it('returns null when the at uri has no rkey', () => {
-    const validAtUri = 'at://did:123/app.bsky.graph.starterpack'
+    const validAtUri = 'at://did:plc:123/app.bsky.graph.starterpack'
     expect(parseStarterPackUri(validAtUri)).toEqual(null)
   })
 
   it('returns null when the collection is not app.bsky.graph.starterpack', () => {
-    const validAtUri = 'at://did:123/app.bsky.graph.list/rkey'
+    const validAtUri = 'at://did:plc:123/app.bsky.graph.list/rkey'
     expect(parseStarterPackUri(validAtUri)).toEqual(null)
   })
 

bskyweb/templates/base.html

···
       width: 100%;
     }
     #splash {
+      display: flex;
       position: fixed;
+      top: 0;
+      bottom: 0;
+      left: 0;
+      right: 0;
+      align-items: center;
+      justify-content: center;
+    }
+    #splash svg {
+      position: relative;
+      top: -50px;
       width: 100px;
-      left: 50%;
-      top: 50%;
-      transform: translateX(-50%) translateY(-50%) translateY(-50px);
     }
     /**
      * We need these styles to prevent shifting due to scrollbar show/hide on
···
   <div id="root">
     <div id="splash">
       <!-- Bluesky SVG -->
-      <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 360 320"><path fill="#0085ff" d="M180 142c-16.3-31.7-60.7-90.8-102-120C38.5-5.9 23.4-1 13.5 3.4 2.1 8.6 0 26.2 0 36.5c0 10.4 5.7 84.8 9.4 97.2 12.2 41 55.7 55 95.7 50.5-58.7 8.6-110.8 30-42.4 106.1 75.1 77.9 103-16.7 117.3-64.6 14.3 48 30.8 139 116 64.6 64-64.6 17.6-97.5-41.1-106.1 40 4.4 83.5-9.5 95.7-50.5 3.7-12.4 9.4-86.8 9.4-97.2 0-10.3-2-27.9-13.5-33C336.5-1 321.5-6 282 22c-41.3 29.2-85.7 88.3-102 120Z"/></svg>
+      <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 57"><path fill="#006AFF" d="M13.873 3.805C21.21 9.332 29.103 20.537 32 26.55v15.882c0-.338-.13.044-.41.867-1.512 4.456-7.418 21.847-20.923 7.944-7.111-7.32-3.819-14.64 9.125-16.85-7.405 1.264-15.73-.825-18.014-9.015C1.12 23.022 0 8.51 0 6.55 0-3.268 8.579-.182 13.873 3.805ZM50.127 3.805C42.79 9.332 34.897 20.537 32 26.55v15.882c0-.338.13.044.41.867 1.512 4.456 7.418 21.847 20.923 7.944 7.111-7.32 3.819-14.64-9.125-16.85 7.405 1.264 15.73-.825 18.014-9.015C62.88 23.022 64 8.51 64 6.55c0-9.818-8.578-6.732-13.873-2.745Z"/></svg>
     </div>
   </div>
 

package.json

···
     "icons:optimize": "svgo -f ./assets/icons"
   },
   "dependencies": {
-    "@atproto/api": "^0.18.0",
+    "@atproto/api": "^0.18.4",
     "@bitdrift/react-native": "^0.6.8",
     "@braintree/sanitize-url": "^6.0.2",
     "@bsky.app/alf": "^0.1.5",
···
     "@react-navigation/native-stack": "^7.3.13",
     "@sentry/react-native": "~6.20.0",
     "@tanstack/query-async-storage-persister": "^5.25.0",
-    "@tanstack/react-query": "^5.8.1",
+    "@tanstack/react-query": "5.25.0",
     "@tanstack/react-query-persist-client": "^5.25.0",
     "@tiptap/core": "^2.9.1",
     "@tiptap/extension-document": "^2.9.1",

src/App.native.tsx

···
 import {logger} from '#/logger'
 import {isAndroid, isIOS} from '#/platform/detection'
 import {Provider as A11yProvider} from '#/state/a11y'
-import {Provider as AgeAssuranceProvider} from '#/state/ageAssurance'
 import {Provider as MutedThreadsProvider} from '#/state/cache/thread-mutes'
 import {Provider as DialogStateProvider} from '#/state/dialogs'
 import {Provider as EmailVerificationProvider} from '#/state/email-verification'
 import {listenSessionDropped} from '#/state/events'
-import {
-  beginResolveGeolocationConfig,
-  ensureGeolocationConfigIsResolved,
-  Provider as GeolocationProvider,
-} from '#/state/geolocation'
 import {GlobalGestureEventsProvider} from '#/state/global-gesture-events'
 import {Provider as HomeBadgeProvider} from '#/state/home-badge'
 import {Provider as LightboxStateProvider} from '#/state/lightbox'
···
 import {Provider as ShellStateProvider} from '#/state/shell'
 import {Provider as ComposerProvider} from '#/state/shell/composer'
 import {Provider as LoggedOutViewProvider} from '#/state/shell/logged-out'
+import {Provider as OnboardingProvider} from '#/state/shell/onboarding'
 import {Provider as ProgressGuideProvider} from '#/state/shell/progress-guide'
 import {Provider as SelectedFeedProvider} from '#/state/shell/selected-feed'
 import {Provider as StarterPackProvider} from '#/state/shell/starter-pack'
···
 import {Provider as PortalProvider} from '#/components/Portal'
 import {Provider as VideoVolumeProvider} from '#/components/Post/Embed/VideoEmbed/VideoVolumeContext'
 import {ToastOutlet} from '#/components/Toast'
+import {Provider as AgeAssuranceV2Provider} from '#/ageAssurance'
+import {prefetchAgeAssuranceConfig} from '#/ageAssurance'
+import * as Geo from '#/geolocation'
 import {Splash} from '#/Splash'
 import {BottomSheetProvider} from '../modules/bottom-sheet'
 import {BackgroundNotificationPreferencesProvider} from '../modules/expo-background-notification-handler/src/BackgroundNotificationHandlerProvider'
···
 /**
  * Begin geolocation ASAP
  */
-beginResolveGeolocationConfig()
+Geo.resolve()
+prefetchAgeAssuranceConfig()
 
 function InnerApp() {
   const [isReady, setIsReady] = React.useState(false)
···
                 <QueryProvider currentDid={currentAccount?.did}>
                   <PolicyUpdateOverlayProvider>
                     <StatsigProvider>
-                      <AgeAssuranceProvider>
+                      <AgeAssuranceV2Provider>
                         <ComposerProvider>
                           <MessagesProvider>
                             {/* LabelDefsProvider MUST come before ModerationOptsProvider */}
···
                             </LabelDefsProvider>
                           </MessagesProvider>
                         </ComposerProvider>
-                      </AgeAssuranceProvider>
+                      </AgeAssuranceV2Provider>
                     </StatsigProvider>
                   </PolicyUpdateOverlayProvider>
                 </QueryProvider>
···
   const [isReady, setReady] = useState(false)
 
   React.useEffect(() => {
-    Promise.all([
-      initPersistedState(),
-      ensureGeolocationConfigIsResolved(),
-    ]).then(() => setReady(true))
+    Promise.all([initPersistedState(), Geo.resolve()]).then(() =>
+      setReady(true),
+    )
   }, [])
 
   if (!isReady) {
···
    * that is set up in the InnerApp component above.
    */
   return (
-    <GeolocationProvider>
+    <Geo.Provider>
       <A11yProvider>
         <KeyboardControllerProvider>
-          <SessionProvider>
-            <PrefsStateProvider>
-              <I18nProvider>
-                <ShellStateProvider>
-                  <ModalStateProvider>
-                    <DialogStateProvider>
-                      <LightboxStateProvider>
-                        <PortalProvider>
-                          <BottomSheetProvider>
-                            <StarterPackProvider>
-                              <SafeAreaProvider
-                                initialMetrics={initialWindowMetrics}>
-                                <InnerApp />
-                              </SafeAreaProvider>
-                            </StarterPackProvider>
-                          </BottomSheetProvider>
-                        </PortalProvider>
-                      </LightboxStateProvider>
-                    </DialogStateProvider>
-                  </ModalStateProvider>
-                </ShellStateProvider>
-              </I18nProvider>
-            </PrefsStateProvider>
-          </SessionProvider>
+          <OnboardingProvider>
+            <SessionProvider>
+              <PrefsStateProvider>
+                <I18nProvider>
+                  <ShellStateProvider>
+                    <ModalStateProvider>
+                      <DialogStateProvider>
+                        <LightboxStateProvider>
+                          <PortalProvider>
+                            <BottomSheetProvider>
+                              <StarterPackProvider>
+                                <SafeAreaProvider
+                                  initialMetrics={initialWindowMetrics}>
+                                  <InnerApp />
+                                </SafeAreaProvider>
+                              </StarterPackProvider>
+                            </BottomSheetProvider>
+                          </PortalProvider>
+                        </LightboxStateProvider>
+                      </DialogStateProvider>
+                    </ModalStateProvider>
+                  </ShellStateProvider>
+                </I18nProvider>
+              </PrefsStateProvider>
+            </SessionProvider>
+          </OnboardingProvider>
         </KeyboardControllerProvider>
       </A11yProvider>
-    </GeolocationProvider>
+    </Geo.Provider>
   )
 }
 

src/App.web.tsx

···
 import I18nProvider from '#/locale/i18nProvider'
 import {logger} from '#/logger'
 import {Provider as A11yProvider} from '#/state/a11y'
-import {Provider as AgeAssuranceProvider} from '#/state/ageAssurance'
 import {Provider as MutedThreadsProvider} from '#/state/cache/thread-mutes'
 import {Provider as DialogStateProvider} from '#/state/dialogs'
 import {Provider as EmailVerificationProvider} from '#/state/email-verification'
 import {listenSessionDropped} from '#/state/events'
-import {
-  beginResolveGeolocationConfig,
-  ensureGeolocationConfigIsResolved,
-  Provider as GeolocationProvider,
-} from '#/state/geolocation'
 import {Provider as HomeBadgeProvider} from '#/state/home-badge'
 import {Provider as LightboxStateProvider} from '#/state/lightbox'
 import {MessagesProvider} from '#/state/messages'
···
 import {Provider as ShellStateProvider} from '#/state/shell'
 import {Provider as ComposerProvider} from '#/state/shell/composer'
 import {Provider as LoggedOutViewProvider} from '#/state/shell/logged-out'
+import {Provider as OnboardingProvider} from '#/state/shell/onboarding'
 import {Provider as ProgressGuideProvider} from '#/state/shell/progress-guide'
 import {Provider as SelectedFeedProvider} from '#/state/shell/selected-feed'
 import {Provider as StarterPackProvider} from '#/state/shell/starter-pack'
···
 import {Provider as ActiveVideoProvider} from '#/components/Post/Embed/VideoEmbed/ActiveVideoWebContext'
 import {Provider as VideoVolumeProvider} from '#/components/Post/Embed/VideoEmbed/VideoVolumeContext'
 import {ToastOutlet} from '#/components/Toast'
+import {Provider as AgeAssuranceV2Provider} from '#/ageAssurance'
+import {prefetchAgeAssuranceConfig} from '#/ageAssurance'
+import * as Geo from '#/geolocation'
+import {Splash} from '#/Splash'
 import {BackgroundNotificationPreferencesProvider} from '../modules/expo-background-notification-handler/src/BackgroundNotificationHandlerProvider'
 import {Provider as HideBottomBarBorderProvider} from './lib/hooks/useHideBottomBarBorder'
 
 /**
  * Begin geolocation ASAP
  */
-beginResolveGeolocationConfig()
+Geo.resolve()
+prefetchAgeAssuranceConfig()
 
 function InnerApp() {
   const [isReady, setIsReady] = React.useState(false)
···
   }, [_])
 
   // wait for session to resume
-  if (!isReady || !hasCheckedReferrer) return null
+  if (!isReady || !hasCheckedReferrer) return <Splash isReady />
 
   return (
     <Alf theme={theme}>
···
                 <QueryProvider currentDid={currentAccount?.did}>
                   <PolicyUpdateOverlayProvider>
                     <StatsigProvider>
-                      <AgeAssuranceProvider>
+                      <AgeAssuranceV2Provider>
                         <ComposerProvider>
                           <MessagesProvider>
                             {/* LabelDefsProvider MUST come before ModerationOptsProvider */}
···
                             </LabelDefsProvider>
                           </MessagesProvider>
                         </ComposerProvider>
-                      </AgeAssuranceProvider>
+                      </AgeAssuranceV2Provider>
                     </StatsigProvider>
                   </PolicyUpdateOverlayProvider>
                 </QueryProvider>
···
   const [isReady, setReady] = useState(false)
 
   React.useEffect(() => {
-    Promise.all([
-      initPersistedState(),
-      ensureGeolocationConfigIsResolved(),
-    ]).then(() => setReady(true))
+    Promise.all([initPersistedState(), Geo.resolve()]).then(() =>
+      setReady(true),
+    )
   }, [])
 
   if (!isReady) {
-    return null
+    return <Splash isReady />
   }
 
   /*
···
    * that is set up in the InnerApp component above.
    */
   return (
-    <GeolocationProvider>
+    <Geo.Provider>
       <A11yProvider>
-        <SessionProvider>
-          <PrefsStateProvider>
-            <I18nProvider>
-              <ShellStateProvider>
-                <ModalStateProvider>
-                  <DialogStateProvider>
-                    <LightboxStateProvider>
-                      <PortalProvider>
-                        <StarterPackProvider>
-                          <InnerApp />
-                        </StarterPackProvider>
-                      </PortalProvider>
-                    </LightboxStateProvider>
-                  </DialogStateProvider>
-                </ModalStateProvider>
-              </ShellStateProvider>
-            </I18nProvider>
-          </PrefsStateProvider>
-        </SessionProvider>
+        <OnboardingProvider>
+          <SessionProvider>
+            <PrefsStateProvider>
+              <I18nProvider>
+                <ShellStateProvider>
+                  <ModalStateProvider>
+                    <DialogStateProvider>
+                      <LightboxStateProvider>
+                        <PortalProvider>
+                          <StarterPackProvider>
+                            <InnerApp />
+                          </StarterPackProvider>
+                        </PortalProvider>
+                      </LightboxStateProvider>
+                    </DialogStateProvider>
+                  </ModalStateProvider>
+                </ShellStateProvider>
+              </I18nProvider>
+            </PrefsStateProvider>
+          </SessionProvider>
+        </OnboardingProvider>
       </A11yProvider>
-    </GeolocationProvider>
+    </Geo.Provider>
   )
 }
 

src/Splash.web.tsx

···
+/*
+ * This is a reimplementation of what exists in our HTML template files
+ * already. Once the React tree mounts, this is what gets rendered first, until
+ * the app is ready to go.
+ */
+
+import {View} from 'react-native'
+import Svg, {Path} from 'react-native-svg'
+
+import {atoms as a} from '#/alf'
+
+const size = 100
+const ratio = 57 / 64
+
+export function Splash() {
+  return (
+    <View style={[a.fixed, a.inset_0, a.align_center, a.justify_center]}>
+      <Svg
+        fill="none"
+        viewBox="0 0 64 57"
+        style={[a.relative, {width: size, height: size * ratio, top: -50}]}>
+        <Path
+          fill="#006AFF"
+          d="M13.873 3.805C21.21 9.332 29.103 20.537 32 26.55v15.882c0-.338-.13.044-.41.867-1.512 4.456-7.418 21.847-20.923 7.944-7.111-7.32-3.819-14.64 9.125-16.85-7.405 1.264-15.73-.825-18.014-9.015C1.12 23.022 0 8.51 0 6.55 0-3.268 8.579-.182 13.873 3.805ZM50.127 3.805C42.79 9.332 34.897 20.537 32 26.55v15.882c0-.338.13.044.41.867 1.512 4.456 7.418 21.847 20.923 7.944 7.111-7.32 3.819-14.64-9.125-16.85 7.405 1.264 15.73-.825 18.014-9.015C62.88 23.022 64 8.51 64 6.55c0-9.818-8.578-6.732-13.873-2.745Z"
+        />
+      </Svg>
+    </View>
+  )
+}

src/ageAssurance/__mocks__/data.tsx

···
+export const prefetchAgeAssuranceData = () => {}
+export const setBirthdateForDid = () => {}
+export const setCreatedAtForDid = () => {}

src/ageAssurance/components/NoAccessScreen.tsx

···
+import {useCallback, useEffect} from 'react'
+import {ScrollView, View} from 'react-native'
+import {useSafeAreaInsets} from 'react-native-safe-area-context'
+import {msg, Trans} from '@lingui/macro'
+import {useLingui} from '@lingui/react'
+
+import {
+  SupportCode,
+  useCreateSupportLink,
+} from '#/lib/hooks/useCreateSupportLink'
+import {dateDiff, useGetTimeAgo} from '#/lib/hooks/useTimeAgo'
+import {logger} from '#/logger'
+import {isWeb} from '#/platform/detection'
+import {isNative} from '#/platform/detection'
+import {useIsBirthdateUpdateAllowed} from '#/state/birthdate'
+import {useSessionApi} from '#/state/session'
+import {atoms as a, useBreakpoints, useTheme, web} from '#/alf'
+import {Admonition} from '#/components/Admonition'
+import {AgeAssuranceAppealDialog} from '#/components/ageAssurance/AgeAssuranceAppealDialog'
+import {AgeAssuranceBadge} from '#/components/ageAssurance/AgeAssuranceBadge'
+import {AgeAssuranceInitDialog} from '#/components/ageAssurance/AgeAssuranceInitDialog'
+import {Button, ButtonIcon, ButtonText} from '#/components/Button'
+import {useDialogControl} from '#/components/Dialog'
+import * as Dialog from '#/components/Dialog'
+import {BirthDateSettingsDialog} from '#/components/dialogs/BirthDateSettings'
+import {DeviceLocationRequestDialog} from '#/components/dialogs/DeviceLocationRequestDialog'
+import {Full as Logo} from '#/components/icons/Logo'
+import {ShieldCheck_Stroke2_Corner0_Rounded as ShieldIcon} from '#/components/icons/Shield'
+import {createStaticClick, SimpleInlineLinkText} from '#/components/Link'
+import {Outlet as PortalOutlet} from '#/components/Portal'
+import * as Toast from '#/components/Toast'
+import {Text} from '#/components/Typography'
+import {BottomSheetOutlet} from '#/../modules/bottom-sheet'
+import {useAgeAssurance} from '#/ageAssurance'
+import {useAgeAssuranceDataContext} from '#/ageAssurance/data'
+import {useComputeAgeAssuranceRegionAccess} from '#/ageAssurance/useComputeAgeAssuranceRegionAccess'
+import {
+  isLegacyBirthdateBug,
+  useAgeAssuranceRegionConfig,
+} from '#/ageAssurance/util'
+import {useDeviceGeolocationApi} from '#/geolocation'
+
+const textStyles = [a.text_md, a.leading_snug]
+
+export function NoAccessScreen() {
+  const t = useTheme()
+  const {_} = useLingui()
+  const {gtPhone} = useBreakpoints()
+  const insets = useSafeAreaInsets()
+  const birthdateControl = useDialogControl()
+  const {data} = useAgeAssuranceDataContext()
+  const region = useAgeAssuranceRegionConfig()
+  const isBirthdateUpdateAllowed = useIsBirthdateUpdateAllowed()
+  const {logoutCurrentAccount} = useSessionApi()
+  const createSupportLink = useCreateSupportLink()
+
+  const aa = useAgeAssurance()
+  const isBlocked = aa.state.status === aa.Status.Blocked
+  const isAARegion = !!region
+  const hasDeclaredAge = data?.declaredAge !== undefined
+  const canUpdateBirthday =
+    isBirthdateUpdateAllowed || isLegacyBirthdateBug(data?.birthdate || '')
+
+  useEffect(() => {
+    // just counting overall hits here
+    logger.metric(`blockedGeoOverlay:shown`, {})
+  }, [])
+
+  const onPressLogout = useCallback(() => {
+    if (isWeb) {
+      // We're switching accounts, which remounts the entire app.
+      // On mobile, this gets us Home, but on the web we also need reset the URL.
+      // We can't change the URL via a navigate() call because the navigator
+      // itself is about to unmount, and it calls pushState() too late.
+      // So we change the URL ourselves. The navigator will pick it up on remount.
+      history.pushState(null, '', '/')
+    }
+    logoutCurrentAccount('AgeAssuranceNoAccessScreen')
+  }, [logoutCurrentAccount])
+
+  const birthdateUpdateText = canUpdateBirthday ? (
+    <Text style={[textStyles]}>
+      <Trans>
+        If you believe your birthdate is incorrect, you can update it by{' '}
+        <SimpleInlineLinkText
+          label={_(msg`Click here to update your birthdate`)}
+          style={[textStyles]}
+          {...createStaticClick(() => {
+            birthdateControl.open()
+          })}>
+          clicking here
+        </SimpleInlineLinkText>
+        .
+      </Trans>
+    </Text>
+  ) : (
+    <Text style={[textStyles]}>
+      <Trans>
+        If you believe your birthdate is incorrect, please{' '}
+        <SimpleInlineLinkText
+          to={createSupportLink({code: SupportCode.AA_BIRTHDATE})}
+          label={_(msg`Click here to contact our support team`)}
+          style={[textStyles]}>
+          contact our support team
+        </SimpleInlineLinkText>
+        .
+      </Trans>
+    </Text>
+  )
+
+  return (
+    <>
+      <ScrollView
+        contentContainerStyle={[
+          a.px_2xl,
+          {
+            paddingTop: isWeb ? a.p_5xl.padding : insets.top + a.p_2xl.padding,
+            paddingBottom: 100,
+          },
+        ]}>
+        <View
+          style={[
+            a.mx_auto,
+            a.w_full,
+            web({
+              maxWidth: 380,
+              paddingTop: gtPhone ? '8vh' : undefined,
+            }),
+            {
+              gap: 32,
+            },
+          ]}>
+          <View style={[a.align_start]}>
+            <AgeAssuranceBadge />
+          </View>
+
+          {hasDeclaredAge ? (
+            <>
+              {isAARegion ? (
+                <>
+                  <View style={[a.gap_lg]}>
+                    <Text style={[textStyles]}>
+                      <Trans>
+                        You are accessing Bluesky from a region that legally
+                        requires us to verify your age before allowing you to
+                        access the app.
+                      </Trans>
+                    </Text>
+
+                    {!isBlocked && birthdateUpdateText}
+                  </View>
+
+                  <AccessSection />
+                </>
+              ) : (
+                <View style={[a.gap_lg]}>
+                  <Text style={[textStyles]}>
+                    <Trans>
+                      Unfortunately, the birthdate you have saved to your
+                      profile makes you too young to access Bluesky.
+                    </Trans>
+                  </Text>
+
+                  {birthdateUpdateText}
+                </View>
+              )}
+            </>
+          ) : (
+            <View style={[a.gap_lg]}>
+              <Text style={[textStyles]}>
+                <Trans>
+                  It looks like you haven't added your birthdate. You must
+                  provide an accurate date of birth to use Bluesky.
+                </Trans>
+              </Text>
+              <Button
+                color="primary"
+                size="large"
+                label={_(msg`Click here to update your birthdate`)}
+                onPress={() => birthdateControl.open()}>
+                <ButtonText>
+                  <Trans>Add your birthdate</Trans>
+                </ButtonText>
+              </Button>
+            </View>
+          )}
+
+          <View style={[a.pt_lg, a.gap_xl]}>
+            <Logo width={120} textFill={t.atoms.text.color} />
+            <Text style={[a.text_sm, a.italic, t.atoms.text_contrast_medium]}>
+              <Trans>
+                To log out,{' '}
+                <SimpleInlineLinkText
+                  label={_(msg`Click here to log out`)}
+                  {...createStaticClick(() => {
+                    onPressLogout()
+                  })}>
+                  click here
+                </SimpleInlineLinkText>
+                .
+              </Trans>
+            </Text>
+          </View>
+        </View>
+      </ScrollView>
+
+      <BirthDateSettingsDialog control={birthdateControl} />
+
+      {/*
+       * While this blocking overlay is up, other dialogs in the shell
+       * are not mounted, so it _should_ be safe to use these here
+       * without fear of other modals showing up.
+       */}
+      <BottomSheetOutlet />
+      <PortalOutlet />
+    </>
+  )
+}
+
+function AccessSection() {
+  const t = useTheme()
+  const {_, i18n} = useLingui()
+  const control = useDialogControl()
+  const appealControl = Dialog.useDialogControl()
+  const locationControl = Dialog.useDialogControl()
+  const getTimeAgo = useGetTimeAgo()
+  const {setDeviceGeolocation} = useDeviceGeolocationApi()
+  const computeAgeAssuranceRegionAccess = useComputeAgeAssuranceRegionAccess()
+
+  const aa = useAgeAssurance()
+  const {status, lastInitiatedAt} = aa.state
+  const isBlocked = status === aa.Status.Blocked
+  const hasInitiated = !!lastInitiatedAt
+  const timeAgo = lastInitiatedAt
+    ? getTimeAgo(lastInitiatedAt, new Date())
+    : null
+  const diff = lastInitiatedAt
+    ? dateDiff(lastInitiatedAt, new Date(), 'down')
+    : null
+
+  return (
+    <>
+      <AgeAssuranceInitDialog control={control} />
+      <AgeAssuranceAppealDialog control={appealControl} />
+
+      <View style={[a.gap_xl]}>
+        {isBlocked ? (
+          <Admonition type="warning">
+            <Trans>
+              You are currently unable to access Bluesky's Age Assurance flow.
+              Please{' '}
+              <SimpleInlineLinkText
+                label={_(msg`Contact our moderation team`)}
+                {...createStaticClick(() => {
+                  appealControl.open()
+                  logger.metric('ageAssurance:appealDialogOpen', {})
+                })}>
+                contact our moderation team
+              </SimpleInlineLinkText>{' '}
+              if you believe this is an error.
+            </Trans>
+          </Admonition>
+        ) : (
+          <>
+            <View style={[a.gap_md]}>
+              <Button
+                label={_(msg`Verify now`)}
+                size="large"
+                color={hasInitiated ? 'secondary' : 'primary'}
+                onPress={() => {
+                  control.open()
+                  logger.metric('ageAssurance:initDialogOpen', {
+                    hasInitiatedPreviously: hasInitiated,
+                  })
+                }}>
+                <ButtonIcon icon={ShieldIcon} />
+                <ButtonText>
+                  {hasInitiated ? (
+                    <Trans>Verify again</Trans>
+                  ) : (
+                    <Trans>Verify now</Trans>
+                  )}
+                </ButtonText>
+              </Button>
+
+              {lastInitiatedAt && timeAgo && diff ? (
+                <Text
+                  style={[a.text_sm, a.italic, t.atoms.text_contrast_medium]}
+                  title={i18n.date(lastInitiatedAt, {
+                    dateStyle: 'medium',
+                    timeStyle: 'medium',
+                  })}>
+                  {diff.value === 0 ? (
+                    <Trans>Last initiated just now</Trans>
+                  ) : (
+                    <Trans>Last initiated {timeAgo} ago</Trans>
+                  )}
+                </Text>
+              ) : (
+                <Text
+                  style={[a.text_sm, a.italic, t.atoms.text_contrast_medium]}>
+                  <Trans>Age assurance only takes a few minutes</Trans>
+                </Text>
+              )}
+            </View>
+          </>
+        )}
+
+        <View style={[a.gap_xs]}>
+          {isNative && (
+            <>
+              <Admonition>
+                <Trans>
+                  Is your location not accurate?{' '}
+                  <SimpleInlineLinkText
+                    label={_(msg`Confirm your location`)}
+                    {...createStaticClick(() => {
+                      locationControl.open()
+                    })}>
+                    Tap here to confirm your location.
+                  </SimpleInlineLinkText>{' '}
+                </Trans>
+              </Admonition>
+
+              <DeviceLocationRequestDialog
+                control={locationControl}
+                onLocationAcquired={props => {
+                  const access = computeAgeAssuranceRegionAccess(
+                    props.geolocation,
+                  )
+                  if (access !== aa.Access.Full) {
+                    props.disableDialogAction()
+                    props.setDialogError(
+                      _(
+                        msg`We're sorry, but based on your device's location, you are currently located in a region that requires age assurance.`,
+                      ),
+                    )
+                  } else {
+                    props.closeDialog(() => {
+                      // set this after close!
+                      setDeviceGeolocation(props.geolocation)
+                      Toast.show(_(msg`Thanks! You're all set.`), {
+                        type: 'success',
+                      })
+                    })
+                  }
+                }}
+              />
+            </>
+          )}
+        </View>
+      </View>
+    </>
+  )
+}

src/ageAssurance/components/RedirectOverlay.tsx

···
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react'
+import {Dimensions, View} from 'react-native'
+import * as Linking from 'expo-linking'
+import {msg, Trans} from '@lingui/macro'
+import {useLingui} from '@lingui/react'
+
+import {retry} from '#/lib/async/retry'
+import {wait} from '#/lib/async/wait'
+import {parseLinkingUrl} from '#/lib/parseLinkingUrl'
+import {isWeb} from '#/platform/detection'
+import {isIOS} from '#/platform/detection'
+import {useAgent, useSession} from '#/state/session'
+import {atoms as a, platform, useBreakpoints, useTheme} from '#/alf'
+import {AgeAssuranceBadge} from '#/components/ageAssurance/AgeAssuranceBadge'
+import {Button, ButtonText} from '#/components/Button'
+import {FullWindowOverlay} from '#/components/FullWindowOverlay'
+import {CheckThick_Stroke2_Corner0_Rounded as SuccessIcon} from '#/components/icons/Check'
+import {CircleInfo_Stroke2_Corner0_Rounded as ErrorIcon} from '#/components/icons/CircleInfo'
+import {Loader} from '#/components/Loader'
+import {Text} from '#/components/Typography'
+import {refetchAgeAssuranceServerState} from '#/ageAssurance'
+import {logger} from '#/ageAssurance'
+
+export type RedirectOverlayState = {
+  result: 'success' | 'unknown'
+  actorDid: string
+}
+
+/**
+ * Validate and parse the query parameters returned from the age assurance
+ * redirect. If not valid, returns `undefined` and the dialog will not open.
+ */
+export function parseRedirectOverlayState(
+  state: {
+    result?: string
+    actorDid?: string
+  } = {},
+): RedirectOverlayState | undefined {
+  let result: RedirectOverlayState['result'] = 'unknown'
+  const actorDid = state.actorDid
+
+  switch (state.result) {
+    case 'success':
+      result = 'success'
+      break
+    case 'unknown':
+    default:
+      result = 'unknown'
+      break
+  }
+
+  if (actorDid) {
+    return {
+      result,
+      actorDid,
+    }
+  }
+}
+
+const Context = createContext<{
+  isOpen: boolean
+  open: (state: RedirectOverlayState) => void
+  close: () => void
+}>({
+  isOpen: false,
+  open: () => {},
+  close: () => {},
+})
+
+export function useRedirectOverlayContext() {
+  return useContext(Context)
+}
+
+export function Provider({children}: {children?: React.ReactNode}) {
+  const {currentAccount} = useSession()
+  const incomingUrl = Linking.useLinkingURL()
+  const [state, setState] = useState<RedirectOverlayState | null>(() => {
+    if (!incomingUrl) return null
+    const url = parseLinkingUrl(incomingUrl)
+    if (url.pathname !== '/intent/age-assurance') return null
+    const params = url.searchParams
+    const state = parseRedirectOverlayState({
+      result: params.get('result') ?? undefined,
+      actorDid: params.get('actorDid') ?? undefined,
+    })
+
+    if (isWeb) {
+      // Clear the URL parameters so they don't re-trigger
+      history.pushState(null, '', '/')
+    }
+
+    /*
+     * If we don't have an account or the account doesn't match, do
+     * nothing. By the time the user switches to their other account, AA
+     * state should be ready for them.
+     */
+    if (state && currentAccount && state.actorDid === currentAccount.did) {
+      return state
+    }
+
+    return null
+  })
+  const open = useCallback((state: RedirectOverlayState) => {
+    setState(state)
+  }, [])
+  const close = useCallback(() => {
+    setState(null)
+  }, [])
+
+  return (
+    <Context.Provider
+      value={useMemo(
+        () => ({
+          isOpen: state !== null,
+          open,
+          close,
+        }),
+        [state, open, close],
+      )}>
+      {children}
+    </Context.Provider>
+  )
+}
+
+export function RedirectOverlay() {
+  const t = useTheme()
+  const {_} = useLingui()
+  const {isOpen} = useRedirectOverlayContext()
+  const {gtMobile} = useBreakpoints()
+
+  return isOpen ? (
+    <FullWindowOverlay>
+      <View
+        style={[
+          a.fixed,
+          a.inset_0,
+          // setting a zIndex when using FullWindowOverlay on iOS
+          // means the taps pass straight through to the underlying content (???)
+          // so don't set it on iOS. FullWindowOverlay already does the job.
+          !isIOS && {zIndex: 9999},
+          t.atoms.bg,
+          gtMobile ? a.p_2xl : a.p_xl,
+          a.align_center,
+          // @ts-ignore
+          platform({
+            web: {
+              paddingTop: '35vh',
+            },
+            default: {
+              paddingTop: Dimensions.get('window').height * 0.35,
+            },
+          }),
+        ]}>
+        <View
+          role="dialog"
+          aria-role="dialog"
+          aria-label={_(msg`Verifying your age assurance status`)}>
+          <View style={[a.pb_3xl, {width: 300}]}>
+            <Inner />
+          </View>
+        </View>
+      </View>
+    </FullWindowOverlay>
+  ) : null
+}
+
+function Inner() {
+  const t = useTheme()
+  const {_} = useLingui()
+  const agent = useAgent()
+  const polling = useRef(false)
+  const unmounted = useRef(false)
+  const [error, setError] = useState(false)
+  const [success, setSuccess] = useState(false)
+  const {close} = useRedirectOverlayContext()
+
+  useEffect(() => {
+    if (polling.current) return
+
+    polling.current = true
+
+    logger.metric('ageAssurance:redirectDialogOpen', {})
+
+    wait(
+      3e3,
+      retry(
+        5,
+        () => true,
+        async () => {
+          if (!agent.session) return
+          if (unmounted.current) return
+
+          const data = await refetchAgeAssuranceServerState({agent})
+
+          if (data?.state.status !== 'assured') {
+            throw new Error(
+              `Polling for age assurance state did not receive assured status`,
+            )
+          }
+
+          return data
+        },
+        1e3,
+      ),
+    )
+      .then(async data => {
+        if (!data) return
+        if (!agent.session) return
+        if (unmounted.current) return
+
+        setSuccess(true)
+
+        logger.metric('ageAssurance:redirectDialogSuccess', {})
+      })
+      .catch(() => {
+        if (unmounted.current) return
+        setError(true)
+        logger.metric('ageAssurance:redirectDialogFail', {})
+      })
+
+    return () => {
+      unmounted.current = true
+    }
+  }, [agent])
+
+  if (success) {
+    return (
+      <>
+        <View style={[a.align_start, a.w_full]}>
+          <AgeAssuranceBadge />
+
+          <View
+            style={[
+              a.flex_row,
+              a.justify_between,
+              a.align_center,
+              a.gap_sm,
+              a.pt_lg,
+              a.pb_md,
+            ]}>
+            <SuccessIcon size="sm" fill={t.palette.positive_500} />
+            <Text style={[a.text_3xl, a.font_bold]}>
+              <Trans>Success</Trans>
+            </Text>
+          </View>
+
+          <Text style={[a.text_md, a.leading_snug]}>
+            <Trans>
+              We've confirmed your age assurance status. You can now close this
+              dialog.
+            </Trans>
+          </Text>
+
+          <View style={[a.w_full, a.pt_lg]}>
+            <Button
+              label={_(msg`Close`)}
+              size="large"
+              variant="solid"
+              color="secondary"
+              onPress={() => close()}>
+              <ButtonText>
+                <Trans>Close</Trans>
+              </ButtonText>
+            </Button>
+          </View>
+        </View>
+      </>
+    )
+  }
+
+  return (
+    <>
+      <View style={[a.align_start, a.w_full]}>
+        <AgeAssuranceBadge />
+
+        <View
+          style={[
+            a.flex_row,
+            a.justify_between,
+            a.align_center,
+            a.gap_sm,
+            a.pt_lg,
+            a.pb_md,
+          ]}>
+          {error && <ErrorIcon size="lg" fill={t.palette.negative_500} />}
+
+          <Text style={[a.text_3xl, a.font_bold]}>
+            {error ? <Trans>Connection issue</Trans> : <Trans>Verifying</Trans>}
+          </Text>
+
+          {!error && <Loader size="lg" />}
+        </View>
+
+        <Text style={[a.text_md, t.atoms.text_contrast_medium, a.leading_snug]}>
+          {error ? (
+            <Trans>
+              We were unable to receive the verification due to a connection
+              issue. It may arrive later. If it does, your account will update
+              automatically.
+            </Trans>
+          ) : (
+            <Trans>
+              We're confirming your age assurance status with our servers. This
+              should only take a few seconds.
+            </Trans>
+          )}
+        </Text>
+
+        {error && (
+          <View style={[a.w_full, a.pt_lg]}>
+            <Button
+              label={_(msg`Close`)}
+              size="large"
+              variant="solid"
+              color="secondary"
+              onPress={() => close()}>
+              <ButtonText>
+                <Trans>Close</Trans>
+              </ButtonText>
+            </Button>
+          </View>
+        )}
+      </View>
+    </>
+  )
+}

src/ageAssurance/data.tsx

···
+import {createContext, useCallback, useContext, useEffect, useMemo} from 'react'
+import {
+  type AppBskyAgeassuranceDefs,
+  type AppBskyAgeassuranceGetConfig,
+  type AppBskyAgeassuranceGetState,
+  AtpAgent,
+  getAgeAssuranceRegionConfig,
+} from '@atproto/api'
+import AsyncStorage from '@react-native-async-storage/async-storage'
+import {createAsyncStoragePersister} from '@tanstack/query-async-storage-persister'
+import {focusManager, QueryClient, useQuery} from '@tanstack/react-query'
+import {persistQueryClient} from '@tanstack/react-query-persist-client'
+import debounce from 'lodash.debounce'
+
+import {networkRetry} from '#/lib/async/retry'
+import {PUBLIC_BSKY_SERVICE} from '#/lib/constants'
+import {getAge} from '#/lib/strings/time'
+import {snoozeBirthdateUpdateAllowedForDid} from '#/state/birthdate'
+import {useAgent, useSession} from '#/state/session'
+import * as debug from '#/ageAssurance/debug'
+import {logger} from '#/ageAssurance/logger'
+import {isLegacyBirthdateBug} from '#/ageAssurance/util'
+import {IS_DEV} from '#/env'
+import {device} from '#/storage'
+
+/**
+ * Special query client for age assurance data so we can prefetch on app
+ * load without interfering with other queries.
+ */
+const qc = new QueryClient({
+  defaultOptions: {
+    queries: {
+      /**
+       * We clear this manually, so disable automatic garbage collection.
+       * @see https://tanstack.com/query/latest/docs/framework/react/plugins/persistQueryClient#how-it-works
+       */
+      gcTime: Infinity,
+    },
+  },
+})
+const persister = createAsyncStoragePersister({
+  storage: AsyncStorage,
+  key: 'age-assurance-query-client',
+})
+const [, cacheHydrationPromise] = persistQueryClient({
+  queryClient: qc,
+  persister,
+})
+
+function getDidFromAgentSession(agent: AtpAgent) {
+  const sessionManager = agent.sessionManager
+  if (!sessionManager || !sessionManager.did) return
+  return sessionManager.did
+}
+
+/*
+ * Optimistic data
+ */
+
+const createdAtCache = new Map<string, string>()
+export function setCreatedAtForDid({
+  did,
+  createdAt,
+}: {
+  did: string
+  createdAt: string
+}) {
+  createdAtCache.set(did, createdAt)
+}
+const birthdateCache = new Map<string, string>()
+export function setBirthdateForDid({
+  did,
+  birthdate,
+}: {
+  did: string
+  birthdate: string
+}) {
+  birthdateCache.set(did, birthdate)
+}
+
+/*
+ * Config
+ */
+
+export const configQueryKey = ['config']
+export async function getConfig() {
+  if (debug.enabled) return debug.resolve(debug.config)
+  const agent = new AtpAgent({
+    service: PUBLIC_BSKY_SERVICE,
+  })
+  const res = await agent.app.bsky.ageassurance.getConfig()
+  return res.data
+}
+export function getConfigFromCache():
+  | AppBskyAgeassuranceGetConfig.OutputSchema
+  | undefined {
+  return qc.getQueryData<AppBskyAgeassuranceGetConfig.OutputSchema>(
+    configQueryKey,
+  )
+}
+let configPrefetchPromise: Promise<void> | undefined
+export async function prefetchConfig() {
+  if (configPrefetchPromise) {
+    logger.debug(`prefetchAgeAssuranceConfig: already in progress`)
+    return
+  }
+
+  configPrefetchPromise = new Promise(async resolve => {
+    await cacheHydrationPromise
+    const cached = getConfigFromCache()
+
+    if (cached) {
+      logger.debug(`prefetchAgeAssuranceConfig: using cache`)
+      resolve()
+    } else {
+      try {
+        logger.debug(`prefetchAgeAssuranceConfig: resolving...`)
+        const res = await networkRetry(3, () => getConfig())
+        qc.setQueryData<AppBskyAgeassuranceGetConfig.OutputSchema>(
+          configQueryKey,
+          res,
+        )
+      } catch (e: any) {
+        logger.warn(`prefetchAgeAssuranceConfig: failed`, {
+          safeMessage: e.message,
+        })
+      } finally {
+        resolve()
+      }
+    }
+  })
+}
+export function useConfigQuery() {
+  return useQuery(
+    {
+      /**
+       * Will re-fetch when stale, at most every hour (or 5s in dev for easier
+       * testing).
+       *
+       * @see https://tanstack.com/query/latest/docs/framework/react/guides/initial-query-data#initial-data-from-the-cache-with-initialdataupdatedat
+       */
+      staleTime: IS_DEV ? 5e3 : 1000 * 60 * 60,
+      initialData: getConfigFromCache(),
+      initialDataUpdatedAt: () =>
+        qc.getQueryState(configQueryKey)?.dataUpdatedAt,
+      queryKey: configQueryKey,
+      async queryFn() {
+        logger.debug(`useConfigQuery: fetching config`)
+        return getConfig()
+      },
+    },
+    qc,
+  )
+}
+
+/*
+ * Server state
+ */
+
+export function createServerStateQueryKey({did}: {did: string}) {
+  return ['serverState', did]
+}
+export async function getServerState({agent}: {agent: AtpAgent}) {
+  if (debug.enabled && debug.serverState)
+    return debug.resolve(debug.serverState)
+  const geolocation = device.get(['mergedGeolocation'])
+  if (!geolocation || !geolocation.countryCode) {
+    logger.error(`getServerState: missing geolocation countryCode`)
+    return
+  }
+  const {data} = await agent.app.bsky.ageassurance.getState({
+    countryCode: geolocation.countryCode,
+    regionCode: geolocation.regionCode,
+  })
+  const did = getDidFromAgentSession(agent)
+  if (data && did && createdAtCache.has(did)) {
+    /*
+     * If account was just created, just use the local cache if available. On
+     * subsequent reloads, the server should have the correct value.
+     */
+    data.metadata.accountCreatedAt = createdAtCache.get(did)
+  }
+  return data ?? null
+}
+export function getServerStateFromCache({
+  did,
+}: {
+  did: string
+}): AppBskyAgeassuranceGetState.OutputSchema | undefined {
+  return qc.getQueryData<AppBskyAgeassuranceGetState.OutputSchema>(
+    createServerStateQueryKey({did}),
+  )
+}
+export async function prefetchServerState({agent}: {agent: AtpAgent}) {
+  const did = getDidFromAgentSession(agent)
+
+  if (!did) return
+
+  await cacheHydrationPromise
+  const qk = createServerStateQueryKey({did})
+  const cached = getServerStateFromCache({did})
+
+  if (cached) {
+    logger.debug(`prefetchServerState: using cache`)
+    return
+  }
+
+  try {
+    logger.debug(`prefetchServerState: resolving...`)
+    const res = await networkRetry(3, () => getServerState({agent}))
+    qc.setQueryData<AppBskyAgeassuranceGetState.OutputSchema>(qk, res)
+  } catch (e: any) {
+    logger.warn(`prefetchServerState: failed`, {
+      safeMessage: e.message,
+    })
+  }
+}
+export async function refetchServerState({agent}: {agent: AtpAgent}) {
+  const did = getDidFromAgentSession(agent)
+  if (!did) return
+  logger.debug(`refetchServerState: fetching...`)
+  const res = await networkRetry(3, () => getServerState({agent}))
+  qc.setQueryData<AppBskyAgeassuranceGetState.OutputSchema>(
+    createServerStateQueryKey({did}),
+    res,
+  )
+  return res
+}
+export function usePatchServerState() {
+  const {currentAccount} = useSession()
+  return useCallback(
+    async (next: AppBskyAgeassuranceDefs.State) => {
+      if (!currentAccount) return
+      const did = currentAccount.did
+      const prev = getServerStateFromCache({did})
+      const merged: AppBskyAgeassuranceGetState.OutputSchema = {
+        metadata: {},
+        ...(prev || {}),
+        state: next,
+      }
+      qc.setQueryData<AppBskyAgeassuranceGetState.OutputSchema>(
+        createServerStateQueryKey({did}),
+        merged,
+      )
+    },
+    [currentAccount],
+  )
+}
+export function useServerStateQuery() {
+  const agent = useAgent()
+  const did = getDidFromAgentSession(agent)
+  const query = useQuery(
+    {
+      enabled: !!did,
+      initialData: () => {
+        if (!did) return
+        return getServerStateFromCache({did})
+      },
+      queryKey: createServerStateQueryKey({did: did!}),
+      async queryFn() {
+        return getServerState({agent})
+      },
+    },
+    qc,
+  )
+  const refetch = useMemo(() => debounce(query.refetch, 100), [query.refetch])
+
+  const isAssured = query.data?.state?.status === 'assured'
+
+  /**
+   * `refetchOnWindowFocus` doesn't seem to want to work for this custom query
+   * client, so we manually subscribe to focus changes.
+   */
+  useEffect(() => {
+    return focusManager.subscribe(() => {
+      // logged out
+      if (!did) return
+
+      const isFocused = focusManager.isFocused()
+
+      if (!isFocused) return
+
+      const config = getConfigFromCache()
+      const geolocation = device.get(['mergedGeolocation'])
+      const isAArequired = Boolean(
+        config &&
+          geolocation &&
+          !!getAgeAssuranceRegionConfig(config, {
+            countryCode: geolocation?.countryCode ?? '',
+            regionCode: geolocation?.regionCode,
+          }),
+      )
+
+      // only refetch when needed
+      if (isAssured || !isAArequired) return
+
+      refetch()
+    })
+  }, [did, refetch, isAssured])
+
+  return query
+}
+
+/*
+ * Other required data
+ */
+
+export type OtherRequiredData = {
+  birthdate: string | undefined
+}
+export function createOtherRequiredDataQueryKey({did}: {did: string}) {
+  return ['otherRequiredData', did]
+}
+export async function getOtherRequiredData({
+  agent,
+}: {
+  agent: AtpAgent
+}): Promise<OtherRequiredData> {
+  if (debug.enabled) return debug.resolve(debug.otherRequiredData)
+  const [prefs] = await Promise.all([agent.getPreferences()])
+  const data: OtherRequiredData = {
+    birthdate: prefs.birthDate ? prefs.birthDate.toISOString() : undefined,
+  }
+  const did = getDidFromAgentSession(agent)
+  if (data && did && birthdateCache.has(did)) {
+    /*
+     * If birthdate was just set, use the local cache value. On subsequent
+     * reloads, the server should have the correct value.
+     */
+    data.birthdate = birthdateCache.get(did)
+  }
+
+  /**
+   * If the user is under the minimum age, and the birthdate is not due to
+   * the legacy bug, snooze further birthdate updates for this user.
+   */
+  if (data.birthdate && !isLegacyBirthdateBug(data.birthdate)) {
+    snoozeBirthdateUpdateAllowedForDid(did!)
+  }
+
+  return data
+}
+export function getOtherRequiredDataFromCache({
+  did,
+}: {
+  did: string
+}): OtherRequiredData | undefined {
+  return qc.getQueryData<OtherRequiredData>(
+    createOtherRequiredDataQueryKey({did}),
+  )
+}
+export async function prefetchOtherRequiredData({agent}: {agent: AtpAgent}) {
+  const did = getDidFromAgentSession(agent)
+
+  if (!did) return
+
+  await cacheHydrationPromise
+  const qk = createOtherRequiredDataQueryKey({did})
+  const cached = getOtherRequiredDataFromCache({did})
+
+  if (cached) {
+    logger.debug(`prefetchOtherRequiredData: using cache`)
+    return
+  }
+
+  try {
+    logger.debug(`prefetchOtherRequiredData: resolving...`)
+    const res = await networkRetry(3, () => getOtherRequiredData({agent}))
+    qc.setQueryData<OtherRequiredData>(qk, res)
+  } catch (e: any) {
+    logger.warn(`prefetchOtherRequiredData: failed`, {
+      safeMessage: e.message,
+    })
+  }
+}
+export function usePatchOtherRequiredData() {
+  const {currentAccount} = useSession()
+  return useCallback(
+    async (next: OtherRequiredData) => {
+      if (!currentAccount) return
+      const did = currentAccount.did
+      const prev = getOtherRequiredDataFromCache({did})
+      const merged: OtherRequiredData = {
+        ...(prev || {}),
+        ...next,
+      }
+      qc.setQueryData<OtherRequiredData>(
+        createOtherRequiredDataQueryKey({did}),
+        merged,
+      )
+    },
+    [currentAccount],
+  )
+}
+export function useOtherRequiredDataQuery() {
+  const agent = useAgent()
+  const did = getDidFromAgentSession(agent)
+  return useQuery(
+    {
+      enabled: !!did,
+      initialData: () => {
+        if (!did) return
+        return getOtherRequiredDataFromCache({did})
+      },
+      queryKey: createOtherRequiredDataQueryKey({did: did!}),
+      async queryFn() {
+        return getOtherRequiredData({agent})
+      },
+    },
+    qc,
+  )
+}
+
+/**
+ * Helper to prefetch all age assurance data.
+ */
+export function prefetchAgeAssuranceData({agent}: {agent: AtpAgent}) {
+  return Promise.allSettled([
+    // config fetch initiated at the top of the App.platform.tsx files, awaited here
+    configPrefetchPromise,
+    prefetchServerState({agent}),
+    prefetchOtherRequiredData({agent}),
+  ])
+}
+
+export function clearAgeAssuranceDataForDid({did}: {did: string}) {
+  logger.debug(`clearAgeAssuranceDataForDid: ${did}`)
+  qc.removeQueries({queryKey: createServerStateQueryKey({did}), exact: true})
+  qc.removeQueries({
+    queryKey: createOtherRequiredDataQueryKey({did}),
+    exact: true,
+  })
+}
+
+export function clearAgeAssuranceData() {
+  logger.debug(`clearAgeAssuranceData`)
+  qc.clear()
+}
+
+/*
+ * Context
+ */
+
+export type AgeAssuranceData = {
+  config: AppBskyAgeassuranceDefs.Config | undefined
+  state: AppBskyAgeassuranceDefs.State | undefined
+  data:
+    | {
+        accountCreatedAt: AppBskyAgeassuranceDefs.StateMetadata['accountCreatedAt']
+        declaredAge: number | undefined
+        birthdate: string | undefined
+      }
+    | undefined
+}
+export const AgeAssuranceDataContext = createContext<AgeAssuranceData>({
+  config: undefined,
+  state: undefined,
+  data: {
+    accountCreatedAt: undefined,
+    declaredAge: undefined,
+    birthdate: undefined,
+  },
+})
+export function useAgeAssuranceDataContext() {
+  return useContext(AgeAssuranceDataContext)
+}
+export function AgeAssuranceDataProvider({
+  children,
+}: {
+  children: React.ReactNode
+}) {
+  const {data: config} = useConfigQuery()
+  const serverState = useServerStateQuery()
+  const {state, metadata} = serverState.data || {}
+  const {data} = useOtherRequiredDataQuery()
+  const ctx = useMemo(
+    () => ({
+      config,
+      state,
+      data: {
+        accountCreatedAt: metadata?.accountCreatedAt,
+        declaredAge: data?.birthdate
+          ? getAge(new Date(data.birthdate))
+          : undefined,
+        birthdate: data?.birthdate,
+      },
+    }),
+    [config, state, data, metadata],
+  )
+  return (
+    <AgeAssuranceDataContext.Provider value={ctx}>
+      {children}
+    </AgeAssuranceDataContext.Provider>
+  )
+}

src/ageAssurance/debug.ts

···
+import {
+  ageAssuranceRuleIDs as ids,
+  type AppBskyAgeassuranceDefs,
+  type AppBskyAgeassuranceGetState,
+} from '@atproto/api'
+
+import {type OtherRequiredData} from '#/ageAssurance/data'
+import {IS_DEV} from '#/env'
+import {type Geolocation} from '#/geolocation'
+
+export const enabled = IS_DEV && false
+
+export const geolocation: Geolocation | undefined = enabled
+  ? {
+      countryCode: 'AA',
+      regionCode: undefined,
+    }
+  : undefined
+
+export const deviceGeolocation: Geolocation | undefined = enabled
+  ? {
+      countryCode: 'AA',
+      regionCode: undefined,
+    }
+  : undefined
+
+export const config: AppBskyAgeassuranceDefs.Config = {
+  regions: [
+    {
+      countryCode: 'AA',
+      regionCode: undefined,
+      rules: [
+        {
+          $type: ids.IfAccountNewerThan,
+          date: '2025-12-01T00:00:00Z',
+          access: 'none',
+        },
+        {
+          $type: ids.IfAssuredOverAge,
+          age: 18,
+          access: 'full',
+        },
+        {
+          $type: ids.IfAssuredOverAge,
+          age: 16,
+          access: 'safe',
+        },
+        {
+          $type: ids.IfDeclaredUnderAge,
+          age: 16,
+          access: 'none',
+        },
+        {
+          $type: ids.Default,
+          access: 'safe',
+        },
+      ],
+    },
+  ],
+}
+
+export const otherRequiredData: OtherRequiredData = {
+  birthdate: new Date(2000, 1, 1).toISOString(),
+}
+
+const serverStateEnabled = false
+export const serverState: AppBskyAgeassuranceGetState.OutputSchema | undefined =
+  serverStateEnabled
+    ? {
+        state: {
+          lastInitiatedAt: new Date(2023, 5, 1).toISOString(),
+          status: 'assured',
+          access: 'safe',
+        },
+        metadata: {
+          accountCreatedAt: new Date(2023, 11, 1).toISOString(),
+        },
+      }
+    : undefined
+
+export async function resolve<T>(data: T) {
+  await new Promise(y => setTimeout(y, 2000)) // simulate network
+  return data
+}

src/ageAssurance/index.tsx

···
+import {createContext, useCallback, useContext, useEffect, useMemo} from 'react'
+
+import {useGetAndRegisterPushToken} from '#/lib/notifications/notifications'
+import {Provider as RedirectOverlayProvider} from '#/ageAssurance/components/RedirectOverlay'
+import {AgeAssuranceDataProvider} from '#/ageAssurance/data'
+import {logger} from '#/ageAssurance/logger'
+import {
+  useAgeAssuranceState,
+  useOnAgeAssuranceAccessUpdate,
+} from '#/ageAssurance/state'
+import {
+  AgeAssuranceAccess,
+  type AgeAssuranceState,
+  AgeAssuranceStatus,
+} from '#/ageAssurance/types'
+
+export {
+  prefetchConfig as prefetchAgeAssuranceConfig,
+  prefetchAgeAssuranceData,
+  refetchServerState as refetchAgeAssuranceServerState,
+  usePatchOtherRequiredData as usePatchAgeAssuranceOtherRequiredData,
+  usePatchServerState as usePatchAgeAssuranceServerState,
+} from '#/ageAssurance/data'
+export {logger} from '#/ageAssurance/logger'
+
+const AgeAssuranceStateContext = createContext<{
+  Access: typeof AgeAssuranceAccess
+  Status: typeof AgeAssuranceStatus
+  state: AgeAssuranceState
+}>({
+  Access: AgeAssuranceAccess,
+  Status: AgeAssuranceStatus,
+  state: {
+    lastInitiatedAt: undefined,
+    status: AgeAssuranceStatus.Unknown,
+    access: AgeAssuranceAccess.Full,
+  },
+})
+
+/**
+ * THE MAIN AGE ASSURANCE CONTEXT HOOK
+ *
+ * Prefer this to using any of the lower-level data-provider hooks.
+ */
+export function useAgeAssurance() {
+  return useContext(AgeAssuranceStateContext)
+}
+
+export function Provider({children}: {children: React.ReactNode}) {
+  return (
+    <AgeAssuranceDataProvider>
+      <InnerProvider>
+        <RedirectOverlayProvider>{children}</RedirectOverlayProvider>
+      </InnerProvider>
+    </AgeAssuranceDataProvider>
+  )
+}
+
+function InnerProvider({children}: {children: React.ReactNode}) {
+  const state = useAgeAssuranceState()
+  const getAndRegisterPushToken = useGetAndRegisterPushToken()
+
+  const handleAccessUpdate = useCallback(
+    (s: AgeAssuranceState) => {
+      getAndRegisterPushToken({
+        isAgeRestricted: s.access !== AgeAssuranceAccess.Full,
+      })
+    },
+    [getAndRegisterPushToken],
+  )
+  useOnAgeAssuranceAccessUpdate(handleAccessUpdate)
+
+  useEffect(() => {
+    logger.debug(`useAgeAssuranceState`, {state})
+  }, [state])
+
+  return (
+    <AgeAssuranceStateContext.Provider
+      value={useMemo(
+        () => ({
+          Access: AgeAssuranceAccess,
+          Status: AgeAssuranceStatus,
+          state,
+        }),
+        [state],
+      )}>
+      {children}
+    </AgeAssuranceStateContext.Provider>
+  )
+}

src/ageAssurance/state.ts

···
+import {useEffect, useMemo, useState} from 'react'
+import {computeAgeAssuranceRegionAccess} from '@atproto/api'
+
+import {useSession} from '#/state/session'
+import {useAgeAssuranceDataContext} from '#/ageAssurance/data'
+import {logger} from '#/ageAssurance/logger'
+import {
+  AgeAssuranceAccess,
+  type AgeAssuranceState,
+  AgeAssuranceStatus,
+  parseAccessFromString,
+  parseStatusFromString,
+} from '#/ageAssurance/types'
+import {getAgeAssuranceRegionConfigWithFallback} from '#/ageAssurance/util'
+import {useGeolocation} from '#/geolocation'
+
+export function useAgeAssuranceState(): AgeAssuranceState {
+  const {hasSession} = useSession()
+  const geolocation = useGeolocation()
+  const {config, state, data} = useAgeAssuranceDataContext()
+
+  return useMemo(() => {
+    /**
+     * This is where we control logged-out moderation prefs. It's all
+     * downstream of AA now.
+     */
+    if (!hasSession)
+      return {
+        status: AgeAssuranceStatus.Unknown,
+        access: AgeAssuranceAccess.Safe,
+      }
+
+    // should never happen, but need to guard
+    if (!config) {
+      logger.warn('useAgeAssuranceState: missing config')
+      return {
+        status: AgeAssuranceStatus.Unknown,
+        access: AgeAssuranceAccess.Unknown,
+      }
+    }
+
+    const region = getAgeAssuranceRegionConfigWithFallback(config, geolocation)
+    const isAARequired = region.countryCode !== '*'
+    const isTerminalState =
+      state?.status === 'assured' || state?.status === 'blocked'
+
+    /*
+     * If we are in a terminal state and AA is required for this region,
+     * we can trust the server state completely and avoid recomputing.
+     */
+    if (isTerminalState && isAARequired) {
+      return {
+        lastInitiatedAt: state.lastInitiatedAt,
+        status: parseStatusFromString(state.status),
+        access: parseAccessFromString(state.access),
+      }
+    }
+
+    /*
+     * Otherwise, we need to compute the access based on the latest data. For
+     * accounts with an accurate birthdate, our default fallback rules should
+     * ensure correct access.
+     */
+    const result = computeAgeAssuranceRegionAccess(region, data)
+    const computed = {
+      lastInitiatedAt: state?.lastInitiatedAt,
+      // prefer server state
+      status: state?.status
+        ? parseStatusFromString(state?.status)
+        : AgeAssuranceStatus.Unknown,
+      // prefer server state
+      access: result
+        ? parseAccessFromString(result.access)
+        : AgeAssuranceAccess.Full,
+    }
+    logger.debug('debug useAgeAssuranceState', {
+      region,
+      state,
+      data,
+      computed,
+    })
+    return computed
+  }, [hasSession, geolocation, config, state, data])
+}
+
+export function useOnAgeAssuranceAccessUpdate(
+  cb: (state: AgeAssuranceState) => void,
+) {
+  const state = useAgeAssuranceState()
+  // start with null to ensure callback is called on first render
+  const [prevAccess, setPrevAccess] = useState<AgeAssuranceAccess | null>(null)
+
+  useEffect(() => {
+    if (prevAccess !== state.access) {
+      setPrevAccess(state.access)
+      cb(state)
+      logger.debug(`useOnAgeAssuranceAccessUpdate`, {state})
+    }
+  }, [cb, state, prevAccess])
+}

src/ageAssurance/types.ts

···
+import {logger} from '#/ageAssurance/logger'
+
+export enum AgeAssuranceAccess {
+  Unknown = 'unknown',
+  None = 'none',
+  Safe = 'safe',
+  Full = 'full',
+}
+
+export enum AgeAssuranceStatus {
+  Unknown = 'unknown',
+  Pending = 'pending',
+  Assured = 'assured',
+  Blocked = 'blocked',
+}
+
+export type AgeAssuranceState = {
+  lastInitiatedAt?: string
+  status: AgeAssuranceStatus
+  access: AgeAssuranceAccess
+}
+
+export function parseStatusFromString(raw: string) {
+  switch (raw) {
+    case 'unknown':
+      return AgeAssuranceStatus.Unknown
+    case 'pending':
+      return AgeAssuranceStatus.Pending
+    case 'assured':
+      return AgeAssuranceStatus.Assured
+    case 'blocked':
+      return AgeAssuranceStatus.Blocked
+    default:
+      logger.error(`parseStatusFromString: unknown status value: ${raw}`)
+      return AgeAssuranceStatus.Unknown
+  }
+}
+
+export function parseAccessFromString(raw: string) {
+  switch (raw) {
+    case 'unknown':
+      return AgeAssuranceAccess.Unknown
+    case 'none':
+      return AgeAssuranceAccess.None
+    case 'safe':
+      return AgeAssuranceAccess.Safe
+    case 'full':
+      return AgeAssuranceAccess.Full
+    default:
+      logger.error(`parseAccessFromString: unknown access value: ${raw}`)
+      return AgeAssuranceAccess.Full
+  }
+}

src/ageAssurance/useBeginAgeAssurance.ts

···
+import {type AppBskyAgeassuranceBegin, AtpAgent} from '@atproto/api'
+import {useMutation} from '@tanstack/react-query'
+
+import {wait} from '#/lib/async/wait'
+import {
+  DEV_ENV_APPVIEW,
+  PUBLIC_APPVIEW,
+  PUBLIC_APPVIEW_DID,
+} from '#/lib/constants'
+import {isNetworkError} from '#/lib/hooks/useCleanError'
+import {logger} from '#/logger'
+import {useAgent} from '#/state/session'
+import {usePatchAgeAssuranceServerState} from '#/ageAssurance'
+import {BLUESKY_PROXY_DID} from '#/env'
+import {useGeolocation} from '#/geolocation'
+
+const IS_DEV_ENV = BLUESKY_PROXY_DID !== PUBLIC_APPVIEW_DID
+const APPVIEW = IS_DEV_ENV ? DEV_ENV_APPVIEW : PUBLIC_APPVIEW
+
+export function useBeginAgeAssurance() {
+  const agent = useAgent()
+  const geolocation = useGeolocation()
+  const patchAgeAssuranceStateResponse = usePatchAgeAssuranceServerState()
+
+  return useMutation({
+    async mutationFn(
+      props: Omit<
+        AppBskyAgeassuranceBegin.InputSchema,
+        'countryCode' | 'regionCode'
+      >,
+    ) {
+      const countryCode = geolocation?.countryCode
+      const regionCode = geolocation?.regionCode
+      if (!countryCode) {
+        throw new Error(`Geolocation not available, cannot init age assurance.`)
+      }
+
+      const {
+        data: {token},
+      } = await agent.com.atproto.server.getServiceAuth({
+        aud: BLUESKY_PROXY_DID,
+        lxm: `app.bsky.ageassurance.begin`,
+      })
+
+      const appView = new AtpAgent({service: APPVIEW})
+      appView.sessionManager.session = {...agent.session!}
+      appView.sessionManager.session.accessJwt = token
+      appView.sessionManager.session.refreshJwt = ''
+
+      /*
+       * 2s wait is good actually. Email sending takes a hot sec and this helps
+       * ensure the email is ready for the user once they open their inbox.
+       */
+      const {data} = await wait(
+        2e3,
+        appView.app.bsky.ageassurance.begin({
+          ...props,
+          countryCode: countryCode.toUpperCase(),
+          regionCode: regionCode ? regionCode.toUpperCase() : undefined,
+        }),
+      )
+
+      // Just keeps this in sync, not necessarily used right now
+      patchAgeAssuranceStateResponse(data)
+    },
+    onError(e) {
+      if (!isNetworkError(e)) {
+        logger.error(`useBeginAgeAssurance failed`, {
+          safeMessage: e,
+        })
+      }
+    },
+  })
+}

src/ageAssurance/useComputeAgeAssuranceRegionAccess.ts

···
+import {useCallback} from 'react'
+import {computeAgeAssuranceRegionAccess} from '@atproto/api'
+
+import {useAgeAssuranceDataContext} from '#/ageAssurance/data'
+import {logger} from '#/ageAssurance/logger'
+import {AgeAssuranceAccess, parseAccessFromString} from '#/ageAssurance/types'
+import {getAgeAssuranceRegionConfigWithFallback} from '#/ageAssurance/util'
+import {type Geolocation} from '#/geolocation'
+
+export function useComputeAgeAssuranceRegionAccess() {
+  const {config, data} = useAgeAssuranceDataContext()
+  return useCallback(
+    (geolocation: Geolocation) => {
+      if (!config) {
+        logger.warn('useComputeAgeAssuranceRegionAccess: missing config')
+        return AgeAssuranceAccess.Unknown
+      }
+      const region = getAgeAssuranceRegionConfigWithFallback(
+        config,
+        geolocation,
+      )
+      const result = computeAgeAssuranceRegionAccess(region, data)
+      return result
+        ? parseAccessFromString(result.access)
+        : AgeAssuranceAccess.Full
+    },
+    [config, data],
+  )
+}

src/ageAssurance/util.ts

···
+import {useMemo} from 'react'
+import {
+  ageAssuranceRuleIDs as ids,
+  type AppBskyAgeassuranceDefs,
+  getAgeAssuranceRegionConfig,
+} from '@atproto/api'
+
+import {getAge} from '#/lib/strings/time'
+import {useAgeAssuranceDataContext} from '#/ageAssurance/data'
+import {AgeAssuranceAccess} from '#/ageAssurance/types'
+import {type Geolocation, useGeolocation} from '#/geolocation'
+
+const DEFAULT_MIN_AGE = 13
+
+/**
+ * Get age assurance region config based on geolocation, with fallback to
+ * app defaults if no region config is found.
+ *
+ * See {@link getAgeAssuranceRegionConfig} for the generic option, which can
+ * return undefined if the geolocation does not match any AA region.
+ */
+export function getAgeAssuranceRegionConfigWithFallback(
+  config: AppBskyAgeassuranceDefs.Config,
+  geolocation: Geolocation,
+): AppBskyAgeassuranceDefs.ConfigRegion {
+  const region = getAgeAssuranceRegionConfig(config, {
+    countryCode: geolocation.countryCode ?? '',
+    regionCode: geolocation.regionCode,
+  })
+
+  return (
+    region || {
+      countryCode: '*',
+      regionCode: undefined,
+      rules: [
+        {
+          $type: ids.IfDeclaredOverAge,
+          age: DEFAULT_MIN_AGE,
+          access: AgeAssuranceAccess.Full,
+        },
+        {
+          $type: ids.Default,
+          access: AgeAssuranceAccess.None,
+        },
+      ],
+    }
+  )
+}
+
+/**
+ * Hook to get the age assurance region config based on current geolocation.
+ * Does not fall-back to our app defaults. If no config is found, returns
+ * undefined, which indicates no regional age assurance rules apply.
+ */
+export function useAgeAssuranceRegionConfig() {
+  const geolocation = useGeolocation()
+  const {config} = useAgeAssuranceDataContext()
+  return useMemo(() => {
+    if (!config) return
+    // use generic helper, we want to potentially return undefined
+    return getAgeAssuranceRegionConfig(config, {
+      countryCode: geolocation.countryCode ?? '',
+      regionCode: geolocation.regionCode,
+    })
+  }, [config, geolocation])
+}
+
+/**
+ * Some users may have erroneously set their birth date to the current date
+ * if one wasn't set on their account. We previously didn't do validation on
+ * the bday dialog, and it defaulted to the current date. This bug _has_ been
+ * seen in production, so we need to check for it where possible.
+ */
+export function isLegacyBirthdateBug(birthDate: string) {
+  return ['2025', '2024', '2023'].includes((birthDate || '').slice(0, 4))
+}
+
+/**
+ * Returns whether the user is under the minimum age required to use the app.
+ * This applies to all regions.
+ */
+export function isUserUnderMinimumAge(birthDate: string) {
+  return getAge(new Date(birthDate)) < DEFAULT_MIN_AGE
+}

src/components/BlockedGeoOverlay.tsx

···
-import {useEffect} from 'react'
-import {ScrollView, View} from 'react-native'
-import {useSafeAreaInsets} from 'react-native-safe-area-context'
-import {msg, Trans} from '@lingui/macro'
-import {useLingui} from '@lingui/react'
-
-import {logger} from '#/logger'
-import {isWeb} from '#/platform/detection'
-import {useDeviceGeolocationApi} from '#/state/geolocation'
-import {atoms as a, useBreakpoints, useTheme, web} from '#/alf'
-import {Button, ButtonIcon, ButtonText} from '#/components/Button'
-import * as Dialog from '#/components/Dialog'
-import {DeviceLocationRequestDialog} from '#/components/dialogs/DeviceLocationRequestDialog'
-import {Divider} from '#/components/Divider'
-import {Full as Logo, Mark} from '#/components/icons/Logo'
-import {PinLocation_Stroke2_Corner0_Rounded as LocationIcon} from '#/components/icons/PinLocation'
-import {SimpleInlineLinkText as InlineLinkText} from '#/components/Link'
-import {Outlet as PortalOutlet} from '#/components/Portal'
-import * as Toast from '#/components/Toast'
-import {Text} from '#/components/Typography'
-import {BottomSheetOutlet} from '#/../modules/bottom-sheet'
-
-export function BlockedGeoOverlay() {
-  const t = useTheme()
-  const {_} = useLingui()
-  const {gtPhone} = useBreakpoints()
-  const insets = useSafeAreaInsets()
-  const geoDialog = Dialog.useDialogControl()
-  const {setDeviceGeolocation} = useDeviceGeolocationApi()
-
-  useEffect(() => {
-    // just counting overall hits here
-    logger.metric(`blockedGeoOverlay:shown`, {})
-  }, [])
-
-  const textStyles = [a.text_md, a.leading_normal]
-  const links = {
-    blog: {
-      to: `https://bsky.social/about/blog/08-22-2025-mississippi-hb1126`,
-      label: _(msg`Read our blog post`),
-      overridePresentation: false,
-      disableMismatchWarning: true,
-      style: textStyles,
-    },
-  }
-
-  const blocks = [
-    _(msg`Unfortunately, Bluesky is unavailable in Mississippi right now.`),
-    _(
-      msg`A new Mississippi law requires us to implement age verification for all users before they can access Bluesky. We think this law creates challenges that go beyond its child safety goals, and creates significant barriers that limit free speech and disproportionately harm smaller platforms and emerging technologies.`,
-    ),
-    _(
-      msg`As a small team, we cannot justify building the expensive infrastructure this requirement demands while legal challenges to this law are pending.`,
-    ),
-    _(
-      msg`For now, we have made the difficult decision to block access to Bluesky in the state of Mississippi.`,
-    ),
-    <>
-      To learn more, read our{' '}
-      <InlineLinkText {...links.blog}>blog post</InlineLinkText>.
-    </>,
-  ]
-
-  return (
-    <>
-      <ScrollView
-        contentContainerStyle={[
-          a.px_2xl,
-          {
-            paddingTop: isWeb ? a.p_5xl.padding : insets.top + a.p_2xl.padding,
-            paddingBottom: 100,
-          },
-        ]}>
-        <View
-          style={[
-            a.mx_auto,
-            web({
-              maxWidth: 380,
-              paddingTop: gtPhone ? '8vh' : undefined,
-            }),
-          ]}>
-          <View style={[a.align_start]}>
-            <View
-              style={[
-                a.pl_md,
-                a.pr_lg,
-                a.py_sm,
-                a.rounded_full,
-                a.flex_row,
-                a.align_center,
-                a.gap_xs,
-                {
-                  backgroundColor: t.palette.primary_25,
-                },
-              ]}>
-              <Mark fill={t.palette.primary_600} width={14} />
-              <Text
-                style={[
-                  a.font_semi_bold,
-                  {
-                    color: t.palette.primary_600,
-                  },
-                ]}>
-                <Trans>Announcement</Trans>
-              </Text>
-            </View>
-          </View>
-
-          <View style={[a.gap_lg, {paddingTop: 32}]}>
-            {blocks.map((block, index) => (
-              <Text key={index} style={[textStyles]}>
-                {block}
-              </Text>
-            ))}
-          </View>
-
-          {!isWeb && (
-            <>
-              <View style={[a.pt_2xl]}>
-                <Divider />
-              </View>
-
-              <View style={[a.mt_xl, a.align_start]}>
-                <Text style={[a.text_lg, a.font_bold, a.leading_snug, a.pb_xs]}>
-                  <Trans>Not in Mississippi?</Trans>
-                </Text>
-                <Text
-                  style={[
-                    a.text_sm,
-                    a.leading_snug,
-                    t.atoms.text_contrast_medium,
-                    a.pb_md,
-                  ]}>
-                  <Trans>
-                    Confirm your location with GPS. Your location data is not
-                    tracked and does not leave your device.
-                  </Trans>
-                </Text>
-                <Button
-                  label={_(msg`Confirm your location`)}
-                  onPress={() => geoDialog.open()}
-                  size="small"
-                  color="primary_subtle">
-                  <ButtonIcon icon={LocationIcon} />
-                  <ButtonText>
-                    <Trans>Confirm your location</Trans>
-                  </ButtonText>
-                </Button>
-              </View>
-
-              <DeviceLocationRequestDialog
-                control={geoDialog}
-                onLocationAcquired={props => {
-                  if (props.geolocationStatus.isAgeBlockedGeo) {
-                    props.disableDialogAction()
-                    props.setDialogError(
-                      _(
-                        msg`We're sorry, but based on your device's location, you are currently located in a region where we cannot provide access at this time.`,
-                      ),
-                    )
-                  } else {
-                    props.closeDialog(() => {
-                      // set this after close!
-                      setDeviceGeolocation({
-                        countryCode: props.geolocationStatus.countryCode,
-                        regionCode: props.geolocationStatus.regionCode,
-                      })
-                      Toast.show(_(msg`Thanks! You're all set.`), {
-                        type: 'success',
-                      })
-                    })
-                  }
-                }}
-              />
-            </>
-          )}
-
-          <View style={[{paddingTop: 48}]}>
-            <Logo width={120} textFill={t.atoms.text.color} />
-          </View>
-        </View>
-      </ScrollView>
-
-      {/*
-       * While this blocking overlay is up, other dialogs in the shell
-       * are not mounted, so it _should_ be safe to use these here
-       * without fear of other modals showing up.
-       */}
-      <BottomSheetOutlet />
-      <PortalOutlet />
-    </>
-  )
-}

src/components/Link.tsx

···
   label,
   disableUnderline,
   shouldProxy,
+  onPress: outerOnPress,
   ...rest
 }: Omit<
   InlineLinkProps,
···
   | 'action'
   | 'disableMismatchWarning'
   | 'overridePresentation'
-  | 'onPress'
   | 'onLongPress'
   | 'shareOnLongPress'
 > & {
···
     href = createProxiedUrl(href)
   }
 
-  const onPress = () => {
+  const onPress = (e: GestureResponderEvent) => {
+    const exitEarlyIfFalse = outerOnPress?.(e)
+    if (exitEarlyIfFalse === false) return
     Linking.openURL(href)
   }
 
···
 export function createStaticClick(
   onPressHandler: Exclude<BaseLinkProps['onPress'], undefined>,
 ): {
-  to: BaseLinkProps['to']
+  to: string
   onPress: Exclude<BaseLinkProps['onPress'], undefined>
 } {
   return {

src/components/PostControls/ShareMenu/ShareMenuItems.tsx

···
 import {toShareUrl} from '#/lib/strings/url-helpers'
 import {logger} from '#/logger'
 import {isIOS} from '#/platform/detection'
-import {useAgeAssurance} from '#/state/ageAssurance/useAgeAssurance'
 import {useProfileShadow} from '#/state/cache/profile-shadow'
 import {useSession} from '#/state/session'
 import * as Toast from '#/view/com/util/Toast'
···
 import {Clipboard_Stroke2_Corner2_Rounded as ClipboardIcon} from '#/components/icons/Clipboard'
 import {PaperPlane_Stroke2_Corner0_Rounded as PaperPlaneIcon} from '#/components/icons/PaperPlane'
 import * as Menu from '#/components/Menu'
+import {useAgeAssurance} from '#/ageAssurance'
 import {useDevMode} from '#/storage/hooks/dev-mode'
 import {RecentChats} from './RecentChats'
 import {type ShareMenuItemsProps} from './ShareMenuItems.types'
···
   const navigation = useNavigation<NavigationProp>()
   const sendViaChatControl = useDialogControl()
   const [devModeEnabled] = useDevMode()
-  const {isAgeRestricted} = useAgeAssurance()
+  const aa = useAgeAssurance()
 
   const postUri = post.uri
   const postAuthor = useProfileShadow(post.author)
···
   return (
     <>
       <Menu.Outer>
-        {hasSession && !isAgeRestricted && (
+        {hasSession && aa.state.access === aa.Access.Full && (
           <Menu.Group>
             <Menu.ContainerItem>
               <RecentChats postUri={postUri} />

src/components/PostControls/ShareMenu/ShareMenuItems.web.tsx

···
 import {toShareUrl} from '#/lib/strings/url-helpers'
 import {logger} from '#/logger'
 import {isWeb} from '#/platform/detection'
-import {useAgeAssurance} from '#/state/ageAssurance/useAgeAssurance'
 import {useProfileShadow} from '#/state/cache/profile-shadow'
 import {useSession} from '#/state/session'
 import {useBreakpoints} from '#/alf'
···
 import {CodeBrackets_Stroke2_Corner0_Rounded as CodeBracketsIcon} from '#/components/icons/CodeBrackets'
 import {PaperPlane_Stroke2_Corner0_Rounded as Send} from '#/components/icons/PaperPlane'
 import * as Menu from '#/components/Menu'
+import {useAgeAssurance} from '#/ageAssurance'
 import {useDevMode} from '#/storage/hooks/dev-mode'
 import {type ShareMenuItemsProps} from './ShareMenuItems.types'
 
···
   const embedPostControl = useDialogControl()
   const sendViaChatControl = useDialogControl()
   const [devModeEnabled] = useDevMode()
-  const {isAgeRestricted} = useAgeAssurance()
+  const aa = useAgeAssurance()
 
   const postUri = post.uri
   const postCid = post.cid
···
       <Menu.Outer>
         {!hideInPWI && copyLinkItem}
 
-        {hasSession && !isAgeRestricted && (
+        {hasSession && aa.state.access === aa.Access.Full && (
           <Menu.Item
             testID="postDropdownSendViaDMBtn"
             label={_(msg`Send via direct message`)}

src/components/ageAssurance/AgeAssuranceAccountCard.tsx

···
 
 import {dateDiff, useGetTimeAgo} from '#/lib/hooks/useTimeAgo'
 import {isNative} from '#/platform/detection'
-import {useAgeAssurance} from '#/state/ageAssurance/useAgeAssurance'
-import {logger} from '#/state/ageAssurance/util'
-import {useDeviceGeolocationApi} from '#/state/geolocation'
 import {atoms as a, useBreakpoints, useTheme, type ViewStyleProp} from '#/alf'
 import {Admonition} from '#/components/Admonition'
 import {AgeAssuranceAppealDialog} from '#/components/ageAssurance/AgeAssuranceAppealDialog'
···
 import {createStaticClick, InlineLinkText} from '#/components/Link'
 import * as Toast from '#/components/Toast'
 import {Text} from '#/components/Typography'
+import {logger, useAgeAssurance} from '#/ageAssurance'
+import {useComputeAgeAssuranceRegionAccess} from '#/ageAssurance/useComputeAgeAssuranceRegionAccess'
+import {useDeviceGeolocationApi} from '#/geolocation'
 
 export function AgeAssuranceAccountCard({style}: ViewStyleProp & {}) {
-  const {isReady, isAgeRestricted, isDeclaredUnderage} = useAgeAssurance()
-
-  if (!isReady) return null
-  if (isDeclaredUnderage) return null
-  if (!isAgeRestricted) return null
-
+  const aa = useAgeAssurance()
+  if (aa.state.access === aa.Access.Full) return null
   return <Inner style={style} />
 }
 
···
   const getTimeAgo = useGetTimeAgo()
   const {gtPhone} = useBreakpoints()
   const {setDeviceGeolocation} = useDeviceGeolocationApi()
+  const computeAgeAssuranceRegionAccess = useComputeAgeAssuranceRegionAccess()
 
   const copy = useAgeAssuranceCopy()
-  const {status, lastInitiatedAt} = useAgeAssurance()
-  const isBlocked = status === 'blocked'
+  const aa = useAgeAssurance()
+  const {status, lastInitiatedAt} = aa.state
+  const isBlocked = status === aa.Status.Blocked
   const hasInitiated = !!lastInitiatedAt
   const timeAgo = lastInitiatedAt
     ? getTimeAgo(lastInitiatedAt, new Date())
···
                 <DeviceLocationRequestDialog
                   control={locationControl}
                   onLocationAcquired={props => {
-                    if (props.geolocationStatus.isAgeRestrictedGeo) {
+                    const access = computeAgeAssuranceRegionAccess(
+                      props.geolocation,
+                    )
+                    if (access !== aa.Access.Full) {
                       props.disableDialogAction()
                       props.setDialogError(
                         _(
···
                     } else {
                       props.closeDialog(() => {
                         // set this after close!
-                        setDeviceGeolocation({
-                          countryCode: props.geolocationStatus.countryCode,
-                          regionCode: props.geolocationStatus.regionCode,
-                        })
+                        setDeviceGeolocation(props.geolocation)
                         Toast.show(_(msg`Thanks! You're all set.`), {
                           type: 'success',
                         })

src/components/ageAssurance/AgeAssuranceAdmonition.tsx

···
 import {msg, Trans} from '@lingui/macro'
 import {useLingui} from '@lingui/react'
 
-import {useAgeAssurance} from '#/state/ageAssurance/useAgeAssurance'
-import {logger} from '#/state/ageAssurance/util'
 import {atoms as a, select, useTheme, type ViewStyleProp} from '#/alf'
 import {useDialogControl} from '#/components/ageAssurance/AgeAssuranceInitDialog'
 import type * as Dialog from '#/components/Dialog'
 import {ShieldCheck_Stroke2_Corner0_Rounded as Shield} from '#/components/icons/Shield'
 import {InlineLinkText} from '#/components/Link'
 import {Text} from '#/components/Typography'
+import {useAgeAssurance} from '#/ageAssurance'
+import {logger} from '#/ageAssurance'
 
 export function AgeAssuranceAdmonition({
   children,
   style,
 }: ViewStyleProp & {children: React.ReactNode}) {
   const control = useDialogControl()
-  const {isReady, isDeclaredUnderage, isAgeRestricted} = useAgeAssurance()
+  const aa = useAgeAssurance()
 
-  if (!isReady) return null
-  if (isDeclaredUnderage) return null
-  if (!isAgeRestricted) return null
+  if (aa.state.access === aa.Access.Full) return null
 
   return (
     <Inner style={style} control={control}>

src/components/ageAssurance/AgeAssuranceAppealDialog.tsx

···
 import {useMutation} from '@tanstack/react-query'
 
 import {BLUESKY_MOD_SERVICE_HEADERS} from '#/lib/constants'
-import {logger} from '#/state/ageAssurance/util'
 import {useAgent, useSession} from '#/state/session'
 import * as Toast from '#/view/com/util/Toast'
 import {atoms as a, useBreakpoints, web} from '#/alf'
···
 import * as Dialog from '#/components/Dialog'
 import {Loader} from '#/components/Loader'
 import {Text} from '#/components/Typography'
+import {logger} from '#/ageAssurance'
 
 export function AgeAssuranceAppealDialog({
   control,

src/components/ageAssurance/AgeAssuranceDismissibleFeedBanner.tsx

···
 import {msg} from '@lingui/macro'
 import {useLingui} from '@lingui/react'
 
-import {useAgeAssurance} from '#/state/ageAssurance/useAgeAssurance'
-import {logger} from '#/state/ageAssurance/util'
 import {Nux, useNux, useSaveNux} from '#/state/queries/nuxs'
 import {atoms as a, select, useTheme} from '#/alf'
 import {useAgeAssuranceCopy} from '#/components/ageAssurance/useAgeAssuranceCopy'
···
 import {TimesLarge_Stroke2_Corner0_Rounded as X} from '#/components/icons/Times'
 import {Link} from '#/components/Link'
 import {Text} from '#/components/Typography'
+import {useAgeAssurance} from '#/ageAssurance'
+import {logger} from '#/ageAssurance'
 
 export function useInternalState() {
-  const {isReady, isDeclaredUnderage, isAgeRestricted, lastInitiatedAt} =
-    useAgeAssurance()
+  const aa = useAgeAssurance()
   const {nux} = useNux(Nux.AgeAssuranceDismissibleFeedBanner)
   const {mutate: save, variables} = useSaveNux()
   const hidden = !!variables
 
   const visible = useMemo(() => {
-    if (!isReady) return false
-    if (isDeclaredUnderage) return false
-    if (!isAgeRestricted) return false
-    if (lastInitiatedAt) return false
+    if (aa.state.access === aa.Access.Full) return false
+    if (aa.state.lastInitiatedAt) return false
     if (hidden) return false
     if (nux && nux.completed) return false
     return true
-  }, [
-    isReady,
-    isDeclaredUnderage,
-    isAgeRestricted,
-    lastInitiatedAt,
-    hidden,
-    nux,
-  ])
+  }, [aa, hidden, nux])
 
   const close = () => {
     save({

src/components/ageAssurance/AgeAssuranceDismissibleNotice.tsx

···
 import {msg} from '@lingui/macro'
 import {useLingui} from '@lingui/react'
 
-import {useAgeAssurance} from '#/state/ageAssurance/useAgeAssurance'
-import {logger} from '#/state/ageAssurance/util'
 import {Nux, useNux, useSaveNux} from '#/state/queries/nuxs'
 import {atoms as a, type ViewStyleProp} from '#/alf'
 import {AgeAssuranceAdmonition} from '#/components/ageAssurance/AgeAssuranceAdmonition'
 import {useAgeAssuranceCopy} from '#/components/ageAssurance/useAgeAssuranceCopy'
 import {Button, ButtonIcon} from '#/components/Button'
 import {TimesLarge_Stroke2_Corner0_Rounded as X} from '#/components/icons/Times'
+import {useAgeAssurance} from '#/ageAssurance'
+import {logger} from '#/ageAssurance'
 
 export function AgeAssuranceDismissibleNotice({style}: ViewStyleProp & {}) {
   const {_} = useLingui()
-  const {isReady, isDeclaredUnderage, isAgeRestricted, lastInitiatedAt} =
-    useAgeAssurance()
+  const aa = useAgeAssurance()
   const {nux} = useNux(Nux.AgeAssuranceDismissibleNotice)
   const copy = useAgeAssuranceCopy()
   const {mutate: save, variables} = useSaveNux()
   const hidden = !!variables
 
-  if (!isReady) return null
-  if (isDeclaredUnderage) return null
-  if (!isAgeRestricted) return null
-  if (lastInitiatedAt) return null
+  if (aa.state.access === aa.Access.Full) return null
+  if (aa.state.lastInitiatedAt) return null
   if (hidden) return null
   if (nux && nux.completed) return null
 

src/components/ageAssurance/AgeAssuranceInitDialog.tsx

···
 import {useTLDs} from '#/lib/hooks/useTLDs'
 import {isEmailMaybeInvalid} from '#/lib/strings/email'
 import {type AppLanguage} from '#/locale/languages'
-import {useAgeAssuranceContext} from '#/state/ageAssurance'
-import {useInitAgeAssurance} from '#/state/ageAssurance/useInitAgeAssurance'
-import {logger} from '#/state/ageAssurance/util'
 import {useLanguagePrefs} from '#/state/preferences'
 import {useSession} from '#/state/session'
 import {atoms as a, useTheme, web} from '#/alf'
···
 import * as TextField from '#/components/forms/TextField'
 import {ShieldCheck_Stroke2_Corner0_Rounded as Shield} from '#/components/icons/Shield'
 import {LanguageSelect} from '#/components/LanguageSelect'
-import {InlineLinkText} from '#/components/Link'
+import {SimpleInlineLinkText} from '#/components/Link'
 import {Loader} from '#/components/Loader'
 import {Text} from '#/components/Typography'
+import {logger} from '#/ageAssurance'
+import {useAgeAssurance} from '#/ageAssurance'
+import {useBeginAgeAssurance} from '#/ageAssurance/useBeginAgeAssurance'
 
 export {useDialogControl} from '#/components/Dialog/context'
 
···
   const langPrefs = useLanguagePrefs()
   const cleanError = useCleanError()
   const {close} = Dialog.useDialogContext()
-  const {lastInitiatedAt} = useAgeAssuranceContext()
+  const aa = useAgeAssurance()
+  const lastInitiatedAt = aa.state.lastInitiatedAt
   const getTimeAgo = useGetTimeAgo()
   const tlds = useTLDs()
   const createSupportLink = useCreateSupportLink()
···
   )
   const [error, setError] = useState<React.ReactNode>(null)
 
-  const {mutateAsync: init, isPending} = useInitAgeAssurance()
+  const {mutateAsync: begin, isPending} = useBeginAgeAssurance()
 
   const runEmailValidation = () => {
     if (validateEmail(email)) {
···
         return
       }
 
-      await init({
+      await begin({
         email,
         language,
       })
···
               <Trans>
                 We're having issues initializing the age assurance process for
                 your account. Please{' '}
-                <InlineLinkText
+                <SimpleInlineLinkText
                   to={createSupportLink({code: SupportCode.AA_DID, email})}
                   label={_(msg`Contact support`)}>
                   contact support
-                </InlineLinkText>{' '}
+                </SimpleInlineLinkText>{' '}
                 for assistance.
               </Trans>
             </>
···
               <Text style={[a.text_sm, a.leading_snug]}>
                 <Trans>
                   We have partnered with{' '}
-                  <InlineLinkText
-                    overridePresentation
-                    disableMismatchWarning
+                  <SimpleInlineLinkText
                     label={_(msg`KWS website`)}
                     to={urls.kwsHome}
                     style={[a.text_sm, a.leading_snug]}>
                     KWS
-                  </InlineLinkText>{' '}
+                  </SimpleInlineLinkText>{' '}
                   to verify that you’re an adult. When you click "Begin" below,
                   KWS will check if you have previously verified your age using
                   this email address for other games/services powered by KWS
···
               style={[a.text_xs, a.leading_snug, t.atoms.text_contrast_medium]}>
               <Trans>
                 By continuing, you agree to the{' '}
-                <InlineLinkText
-                  overridePresentation
-                  disableMismatchWarning
+                <SimpleInlineLinkText
                   label={_(msg`KWS Terms of Use`)}
                   to={urls.kwsTermsOfUse}
                   style={[a.text_xs, a.leading_snug]}>
                   KWS Terms of Use
-                </InlineLinkText>{' '}
+                </SimpleInlineLinkText>{' '}
                 and acknowledge that KWS will store your verified status with
                 your hashed email address in accordance with the{' '}
-                <InlineLinkText
-                  overridePresentation
-                  disableMismatchWarning
+                <SimpleInlineLinkText
                   label={_(msg`KWS Privacy Policy`)}
                   to={urls.kwsPrivacyPolicy}
                   style={[a.text_xs, a.leading_snug]}>
                   KWS Privacy Policy
-                </InlineLinkText>
+                </SimpleInlineLinkText>
                 . This means you won’t need to verify again the next time you
                 use this email for other apps, games, and services powered by
                 KWS technology.

src/components/ageAssurance/AgeAssuranceRedirectDialog.tsx

···
 import {retry} from '#/lib/async/retry'
 import {wait} from '#/lib/async/wait'
 import {isNative} from '#/platform/detection'
-import {useAgeAssuranceAPIContext} from '#/state/ageAssurance'
-import {logger} from '#/state/ageAssurance/util'
 import {useAgent} from '#/state/session'
 import {atoms as a, useTheme, web} from '#/alf'
 import {AgeAssuranceBadge} from '#/components/ageAssurance/AgeAssuranceBadge'
···
 import {CircleInfo_Stroke2_Corner0_Rounded as ErrorIcon} from '#/components/icons/CircleInfo'
 import {Loader} from '#/components/Loader'
 import {Text} from '#/components/Typography'
+import {refetchAgeAssuranceServerState} from '#/ageAssurance'
+import {logger} from '#/ageAssurance'
 
 export type AgeAssuranceRedirectDialogState = {
   result: 'success' | 'unknown'
···
   const {_} = useLingui()
   const control = useAgeAssuranceRedirectDialogControl()
 
-  // TODO for testing
+  // for testing
   // Dialog.useAutoOpen(control.control, 3e3)
 
   return (
···
   const control = useAgeAssuranceRedirectDialogControl()
   const [error, setError] = useState(false)
   const [success, setSuccess] = useState(false)
-  const {refetch: refreshAgeAssuranceState} = useAgeAssuranceAPIContext()
 
   useEffect(() => {
     if (polling.current) return
···
           if (!agent.session) return
           if (unmounted.current) return
 
-          const {data} = await agent.app.bsky.unspecced.getAgeAssuranceState()
+          const data = await refetchAgeAssuranceServerState({agent})
 
-          if (data.status !== 'assured') {
+          if (data?.state.status !== 'assured') {
             throw new Error(
               `Polling for age assurance state did not receive assured status`,
             )
···
         if (!data) return
         if (!agent.session) return
         if (unmounted.current) return
-
-        // success! update state
-        await refreshAgeAssuranceState()
 
         setSuccess(true)
 
···
       .catch(() => {
         if (unmounted.current) return
         setError(true)
-        // try a refetch anyway
-        refreshAgeAssuranceState()
         logger.metric('ageAssurance:redirectDialogFail', {})
       })
 
     return () => {
       unmounted.current = true
     }
-  }, [agent, control, refreshAgeAssuranceState])
+  }, [agent, control])
 
   if (success) {
     return (

src/components/ageAssurance/AgeRestrictedScreen.tsx

···
 import {msg, Trans} from '@lingui/macro'
 import {useLingui} from '@lingui/react'
 
-import {useAgeAssurance} from '#/state/ageAssurance/useAgeAssurance'
-import {logger} from '#/state/ageAssurance/util'
 import {atoms as a} from '#/alf'
 import {Admonition} from '#/components/Admonition'
 import {AgeAssuranceBadge} from '#/components/ageAssurance/AgeAssuranceBadge'
···
 import * as Layout from '#/components/Layout'
 import {Link} from '#/components/Link'
 import {Text} from '#/components/Typography'
+import {useAgeAssurance} from '#/ageAssurance'
+import {logger} from '#/ageAssurance'
 
 export function AgeRestrictedScreen({
   children,
···
 }) {
   const {_} = useLingui()
   const copy = useAgeAssuranceCopy()
-  const {isReady, isAgeRestricted} = useAgeAssurance()
+  const aa = useAgeAssurance()
 
-  if (!isReady) {
-    return (
-      <Layout.Screen>
-        <Layout.Header.Outer>
-          <Layout.Header.Content>
-            <Layout.Header.TitleText> </Layout.Header.TitleText>
-          </Layout.Header.Content>
-          <Layout.Header.Slot />
-        </Layout.Header.Outer>
-        <Layout.Content />
-      </Layout.Screen>
-    )
-  }
-  if (!isAgeRestricted) return children
+  if (aa.state.access === aa.Access.Full) return children
 
   return (
     <Layout.Screen>

src/components/ageAssurance/useAgeAssuranceCopy.ts

···
 import {msg} from '@lingui/macro'
 import {useLingui} from '@lingui/react'
 
+import {useAgeAssurance} from '#/ageAssurance'
+
 export function useAgeAssuranceCopy() {
   const {_} = useLingui()
+  const aa = useAgeAssurance()
 
   return useMemo(() => {
     return {
-      notice: _(
-        msg`The laws in your location require you to verify you're an adult before accessing certain features on Bluesky, like adult content and direct messaging.`,
-      ),
+      notice:
+        aa.state.access === aa.Access.Safe
+          ? _(
+              msg`Due to laws in your region, certain features on Bluesky are currently restricted until you're able to verify you're an adult.`,
+            )
+          : _(
+              msg`The laws in your location require you to verify you're an adult before accessing certain features on Bluesky, like adult content and direct messaging.`,
+            ),
       banner: _(
         msg`The laws in your location require you to verify you're an adult to access certain features. Tap to learn more.`,
       ),
···
         msg`Don't worry! All existing messages and settings are saved and will be available after you verify you're an adult.`,
       ),
     }
-  }, [_])
+  }, [_, aa])
 }

src/components/dialogs/BirthDateSettings.tsx

···
 import {logger} from '#/logger'
 import {isIOS, isWeb} from '#/platform/detection'
 import {
+  useBirthdateMutation,
+  useIsBirthdateUpdateAllowed,
+} from '#/state/birthdate'
+import {
   usePreferencesQuery,
   type UsePreferencesQueryResponse,
-  usePreferencesSetBirthDateMutation,
 } from '#/state/queries/preferences'
 import {ErrorMessage} from '#/view/com/util/error/ErrorMessage'
 import {atoms as a, useTheme, web} from '#/alf'
···
 import {Button, ButtonIcon, ButtonText} from '#/components/Button'
 import * as Dialog from '#/components/Dialog'
 import {DateField} from '#/components/forms/DateField'
-import {InlineLinkText} from '#/components/Link'
+import {SimpleInlineLinkText} from '#/components/Link'
 import {Loader} from '#/components/Loader'
 import {Text} from '#/components/Typography'
 
···
   const t = useTheme()
   const {_} = useLingui()
   const {isLoading, error, data: preferences} = usePreferencesQuery()
+  const isBirthdateUpdateAllowed = useIsBirthdateUpdateAllowed()
 
   return (
     <Dialog.Outer control={control} nativeOptions={{preventExpansion: true}}>
       <Dialog.Handle />
-      <Dialog.ScrollableInner
-        label={_(msg`My Birthday`)}
-        style={web({maxWidth: 400})}>
-        <View style={[a.gap_sm]}>
-          <Text style={[a.text_xl, a.font_semi_bold]}>
-            <Trans>My Birthday</Trans>
-          </Text>
-          <Text style={[a.leading_snug, t.atoms.text_contrast_medium]}>
-            <Trans>
-              This information is private and not shared with other users.
-            </Trans>
-          </Text>
+      {isBirthdateUpdateAllowed ? (
+        <Dialog.ScrollableInner
+          label={_(msg`My Birthdate`)}
+          style={web({maxWidth: 400})}>
+          <View style={[a.gap_md]}>
+            <Text style={[a.text_xl, a.font_semi_bold]}>
+              <Trans>My Birthdate</Trans>
+            </Text>
+            <Text
+              style={[a.text_md, a.leading_snug, t.atoms.text_contrast_medium]}>
+              <Trans>
+                This information is private and not shared with other users.
+              </Trans>
+            </Text>
 
-          {isLoading ? (
-            <Loader size="xl" />
-          ) : error || !preferences ? (
-            <ErrorMessage
-              message={
-                error?.toString() ||
-                _(
-                  msg`We were unable to load your birth date preferences. Please try again.`,
-                )
-              }
-              style={[a.rounded_sm]}
-            />
-          ) : (
-            <BirthdayInner control={control} preferences={preferences} />
-          )}
-        </View>
+            {isLoading ? (
+              <Loader size="xl" />
+            ) : error || !preferences ? (
+              <ErrorMessage
+                message={
+                  error?.toString() ||
+                  _(
+                    msg`We were unable to load your birthdate preferences. Please try again.`,
+                  )
+                }
+                style={[a.rounded_sm]}
+              />
+            ) : (
+              <BirthdayInner control={control} preferences={preferences} />
+            )}
+          </View>
 
-        <Dialog.Close />
-      </Dialog.ScrollableInner>
+          <Dialog.Close />
+        </Dialog.ScrollableInner>
+      ) : (
+        <Dialog.ScrollableInner
+          label={_(msg`You recently changed your birthdate`)}
+          style={web({maxWidth: 400})}>
+          <View style={[a.gap_sm]}>
+            <Text
+              style={[
+                a.text_xl,
+                a.font_semi_bold,
+                a.leading_snug,
+                {paddingRight: 32},
+              ]}>
+              <Trans>You recently changed your birthdate</Trans>
+            </Text>
+            <Text
+              style={[a.text_md, a.leading_snug, t.atoms.text_contrast_medium]}>
+              <Trans>
+                There is a limit to how often you can change your birthdate. You
+                may need to wait a day or two before updating it again.
+              </Trans>
+            </Text>
+          </View>
+
+          <Dialog.Close />
+        </Dialog.ScrollableInner>
+      )}
     </Dialog.Outer>
   )
 }
···
     isError,
     error,
     mutateAsync: setBirthDate,
-  } = usePreferencesSetBirthDateMutation()
+  } = useBirthdateMutation()
   const hasChanged = date !== preferences.birthDate
 
   const age = getAge(new Date(date))
···
           testID="birthdayInput"
           value={date}
           onChangeDate={newDate => setDate(new Date(newDate))}
-          label={_(msg`Birthday`)}
-          accessibilityHint={_(msg`Enter your birth date`)}
+          label={_(msg`Birthdate`)}
+          accessibilityHint={_(msg`Enter your birthdate`)}
         />
       </View>
 
···
         <Admonition type="error">
           <Trans>
             You must be at least 13 years old to use Bluesky. Read our{' '}
-            <InlineLinkText
+            <SimpleInlineLinkText
               to="https://bsky.social/about/support/tos"
               label={_(msg`Terms of Service`)}>
               Terms of Service
-            </InlineLinkText>{' '}
+            </SimpleInlineLinkText>{' '}
             for more information.
           </Trans>
         </Admonition>
···
 
       <View style={isWeb && [a.flex_row, a.justify_end]}>
         <Button
-          label={hasChanged ? _(msg`Save birthday`) : _(msg`Done`)}
+          label={hasChanged ? _(msg`Save birthdate`) : _(msg`Done`)}
           size="large"
           onPress={onSave}
           variant="solid"

src/components/dialogs/DeviceLocationRequestDialog.tsx

···
 import {isNetworkError, useCleanError} from '#/lib/hooks/useCleanError'
 import {logger} from '#/logger'
 import {isWeb} from '#/platform/detection'
-import {
-  computeGeolocationStatus,
-  type GeolocationStatus,
-  useGeolocationConfig,
-} from '#/state/geolocation'
-import {useRequestDeviceLocation} from '#/state/geolocation/useRequestDeviceLocation'
 import {atoms as a, useTheme, web} from '#/alf'
 import {Admonition} from '#/components/Admonition'
 import {Button, ButtonIcon, ButtonText} from '#/components/Button'
···
 import {PinLocation_Stroke2_Corner0_Rounded as LocationIcon} from '#/components/icons/PinLocation'
 import {Loader} from '#/components/Loader'
 import {Text} from '#/components/Typography'
+import {type Geolocation, useRequestDeviceGeolocation} from '#/geolocation'
 
 export type Props = {
   onLocationAcquired?: (props: {
-    geolocationStatus: GeolocationStatus
+    geolocation: Geolocation
     setDialogError: (error: string) => void
     disableDialogAction: () => void
     closeDialog: (callback?: () => void) => void
···
   const t = useTheme()
   const {_} = useLingui()
   const {close} = Dialog.useDialogContext()
-  const requestDeviceLocation = useRequestDeviceLocation()
-  const {config} = useGeolocationConfig()
+  const requestDeviceLocation = useRequestDeviceGeolocation()
   const cleanError = useCleanError()
 
   const [isRequesting, setIsRequesting] = useState(false)
···
         const location = req.location
 
         if (location && location.countryCode) {
-          const geolocationStatus = computeGeolocationStatus(location, config)
           onLocationAcquired?.({
-            geolocationStatus,
+            geolocation: location,
             setDialogError: setError,
             disableDialogAction: () => setDialogDisabled(true),
             closeDialog: close,

src/env/common.ts

···
     : Number(process.env.EXPO_PUBLIC_GCP_PROJECT_ID)
 
 /**
- * URL for the bapp-config web worker _development_ environment. Can be a
+ * URLs for the app config web worker. Can be a
  * locally running server, see `env.example` for more.
  */
 export const BAPP_CONFIG_DEV_URL = process.env.BAPP_CONFIG_DEV_URL
-
-/**
- * Dev environment passthrough value for bapp-config web worker. Allows local
- * dev access to the web worker running in `development` mode.
- */
-export const BAPP_CONFIG_DEV_BYPASS_SECRET: string =
-  process.env.BAPP_CONFIG_DEV_BYPASS_SECRET
+export const BAPP_CONFIG_PROD_URL = `https://ip.bsky.app`
+export const BAPP_CONFIG_URL = IS_DEV
+  ? (BAPP_CONFIG_DEV_URL ?? BAPP_CONFIG_PROD_URL)
+  : BAPP_CONFIG_PROD_URL

src/geolocation/const.ts

···
+import {BAPP_CONFIG_URL} from '#/env'
+import {type Geolocation} from '#/geolocation/types'
+
+export const GEOLOCATION_SERVICE_URL = `${BAPP_CONFIG_URL}/geolocation`
+
+/**
+ * Default geolocation config.
+ */
+export const FALLBACK_GEOLOCATION_SERVICE_RESPONSE: Geolocation = {
+  countryCode: undefined,
+  regionCode: undefined,
+}

src/geolocation/debug.ts

···
+import * as aaDebug from '#/ageAssurance/debug'
+import {IS_DEV} from '#/env'
+import {type Geolocation} from '#/geolocation/types'
+
+const localEnabled = false
+export const enabled = IS_DEV && (localEnabled || aaDebug.geolocation)
+export const geolocation: Geolocation = aaDebug.geolocation ?? {
+  countryCode: 'AU',
+  regionCode: undefined,
+}
+export const deviceGeolocation: Geolocation = aaDebug.deviceGeolocation ?? {
+  countryCode: 'AU',
+  regionCode: undefined,
+}
+
+export async function resolve<T>(data: T) {
+  await new Promise(y => setTimeout(y, 2000)) // simulate network
+  return data
+}

src/geolocation/device.ts

···
+import {useCallback, useEffect, useRef} from 'react'
+import * as Location from 'expo-location'
+import {createPermissionHook} from 'expo-modules-core'
+
+import {isNative} from '#/platform/detection'
+import * as debug from '#/geolocation/debug'
+import {logger} from '#/geolocation/logger'
+import {type Geolocation} from '#/geolocation/types'
+import {normalizeDeviceLocation} from '#/geolocation/util'
+import {device} from '#/storage'
+
+/**
+ * Location.useForegroundPermissions on web just errors if the
+ * navigator.permissions API is not available. We need to catch and ignore it,
+ * since it's effectively denied.
+ *
+ * @see https://github.com/expo/expo/blob/72f1562ed9cce5ff6dfe04aa415b71632a3d4b87/packages/expo-location/src/Location.ts#L290-L293
+ */
+const useForegroundPermissions = createPermissionHook({
+  getMethod: () =>
+    Location.getForegroundPermissionsAsync().catch(error => {
+      logger.debug(
+        'useForegroundPermission: error getting location permissions',
+        {safeMessage: error},
+      )
+      return {
+        status: Location.PermissionStatus.DENIED,
+        granted: false,
+        canAskAgain: false,
+        expires: 0,
+      }
+    }),
+  requestMethod: () =>
+    Location.requestForegroundPermissionsAsync().catch(error => {
+      logger.debug(
+        'useForegroundPermission: error requesting location permissions',
+        {safeMessage: error},
+      )
+      return {
+        status: Location.PermissionStatus.DENIED,
+        granted: false,
+        canAskAgain: false,
+        expires: 0,
+      }
+    }),
+})
+
+export async function getDeviceGeolocation(): Promise<Geolocation> {
+  if (debug.enabled) return debug.resolve(debug.deviceGeolocation)
+
+  try {
+    const geocode = await Location.getCurrentPositionAsync()
+    const locations = await Location.reverseGeocodeAsync({
+      latitude: geocode.coords.latitude,
+      longitude: geocode.coords.longitude,
+    })
+    const location = locations.at(0)
+    const normalized = location ? normalizeDeviceLocation(location) : undefined
+    return {
+      countryCode: normalized?.countryCode ?? undefined,
+      regionCode: normalized?.regionCode ?? undefined,
+    }
+  } catch (e) {
+    logger.error('getDeviceGeolocation: failed', {safeMessage: e})
+    return {
+      countryCode: undefined,
+      regionCode: undefined,
+    }
+  }
+}
+
+export function useRequestDeviceGeolocation(): () => Promise<
+  | {
+      granted: true
+      location: Geolocation | undefined
+    }
+  | {
+      granted: false
+    }
+> {
+  return useCallback(async () => {
+    const status = await Location.requestForegroundPermissionsAsync()
+    if (status.granted) {
+      return {
+        granted: true,
+        location: await getDeviceGeolocation(),
+      }
+    } else {
+      return {
+        granted: false,
+      }
+    }
+  }, [])
+}
+
+/**
+ * Hook to get and sync the device geolocation from the device GPS and store it
+ * using device storage. If permissions are not granted, it will clear any cached
+ * storage value.
+ */
+export function useSyncDeviceGeolocationOnStartup(
+  sync: (location: Geolocation | undefined) => void,
+) {
+  const synced = useRef(false)
+  const [status] = useForegroundPermissions()
+  useEffect(() => {
+    if (!isNative) return
+
+    async function get() {
+      // no need to set this more than once per session
+      if (synced.current) return
+      logger.debug('useSyncDeviceGeolocationOnStartup: checking perms')
+      if (status?.granted) {
+        const location = await getDeviceGeolocation()
+        if (location) {
+          logger.debug('useSyncDeviceGeolocationOnStartup: got location')
+          sync(location)
+          synced.current = true
+        }
+      } else {
+        const hasCachedValue = device.get(['deviceGeolocation']) !== undefined
+        /**
+         * If we have a cached value, but user has revoked permissions,
+         * quietly (will take effect lazily) clear this out.
+         */
+        if (hasCachedValue) {
+          logger.debug(
+            'useSyncDeviceGeolocationOnStartup: clearing cached location, perms revoked',
+          )
+          device.set(['deviceGeolocation'], undefined)
+        }
+      }
+    }
+
+    get().catch(e => {
+      logger.error(
+        'useSyncDeviceGeolocationOnStartup: failed to get location',
+        {
+          safeMessage: e,
+        },
+      )
+    })
+  }, [status, sync])
+}

src/geolocation/index.tsx

···
+import {
+  createContext,
+  type ReactNode,
+  useContext,
+  useEffect,
+  useMemo,
+} from 'react'
+
+import {useSyncDeviceGeolocationOnStartup} from '#/geolocation/device'
+import {useGeolocationServiceResponse} from '#/geolocation/service'
+import {type Geolocation} from '#/geolocation/types'
+import {mergeGeolocations} from '#/geolocation/util'
+import {device, useStorage} from '#/storage'
+
+export {useRequestDeviceGeolocation} from '#/geolocation/device'
+export {resolve} from '#/geolocation/service'
+export * from '#/geolocation/types'
+
+const GeolocationContext = createContext<Geolocation>({
+  countryCode: undefined,
+  regionCode: undefined,
+})
+
+const DeviceGeolocationAPIContext = createContext<{
+  setDeviceGeolocation(deviceGeolocation: Geolocation): void
+}>({
+  setDeviceGeolocation: () => {},
+})
+
+export function useGeolocation() {
+  return useContext(GeolocationContext)
+}
+
+export function useDeviceGeolocationApi() {
+  return useContext(DeviceGeolocationAPIContext)
+}
+
+export function Provider({children}: {children: ReactNode}) {
+  const geolocationService = useGeolocationServiceResponse()
+  const [deviceGeolocation, setDeviceGeolocation] = useStorage(device, [
+    'deviceGeolocation',
+  ])
+  const geolocation = useMemo(() => {
+    return mergeGeolocations(deviceGeolocation, geolocationService)
+  }, [deviceGeolocation, geolocationService])
+
+  useEffect(() => {
+    /**
+     * Save this for out-of-band-reads during future cold starts of the app.
+     * Needs to be available for the data prefetching we do on boot.
+     */
+    device.set(['mergedGeolocation'], geolocation)
+  }, [geolocation])
+
+  useSyncDeviceGeolocationOnStartup(setDeviceGeolocation)
+
+  return (
+    <GeolocationContext.Provider value={geolocation}>
+      <DeviceGeolocationAPIContext.Provider
+        value={useMemo(() => ({setDeviceGeolocation}), [setDeviceGeolocation])}>
+        {children}
+      </DeviceGeolocationAPIContext.Provider>
+    </GeolocationContext.Provider>
+  )
+}

src/geolocation/service.ts

···
+import {useEffect, useState} from 'react'
+import EventEmitter from 'eventemitter3'
+
+import {networkRetry} from '#/lib/async/retry'
+import {
+  FALLBACK_GEOLOCATION_SERVICE_RESPONSE,
+  GEOLOCATION_SERVICE_URL,
+} from '#/geolocation/const'
+import * as debug from '#/geolocation/debug'
+import {logger} from '#/geolocation/logger'
+import {type Geolocation} from '#/geolocation/types'
+import {device} from '#/storage'
+
+const events = new EventEmitter()
+const EVENT = 'geolocation-service-response-updated'
+const emitGeolocationServiceResponseUpdate = (data: Geolocation) => {
+  events.emit(EVENT, data)
+}
+const onGeolocationServiceResponseUpdate = (
+  listener: (data: Geolocation) => void,
+) => {
+  events.on(EVENT, listener)
+  return () => {
+    events.off(EVENT, listener)
+  }
+}
+
+async function fetchGeolocationServiceData(
+  url: string,
+): Promise<Geolocation | undefined> {
+  if (debug.enabled) return debug.resolve(debug.geolocation)
+  const res = await fetch(url)
+  if (!res.ok) {
+    throw new Error(`fetchGeolocationServiceData failed ${res.status}`)
+  }
+  return res.json() as Promise<Geolocation>
+}
+
+/**
+ * Local promise used within this file only.
+ */
+let geolocationServicePromise: Promise<{success: boolean}> | undefined
+
+/**
+ * Begin the process of resolving geolocation config. This is called right away
+ * at app start, and the promise is awaited later before proceeding with app
+ * startup.
+ */
+export async function resolve() {
+  if (geolocationServicePromise) {
+    const cached = device.get(['geolocationServiceResponse'])
+    if (cached) {
+      logger.debug(`resolve(): using cache`)
+    } else {
+      logger.debug(`resolve(): no cache`)
+      const {success} = await geolocationServicePromise
+      if (success) {
+        logger.debug(`resolve(): resolved`)
+      } else {
+        logger.info(`resolve(): failed`)
+      }
+    }
+  } else {
+    logger.debug(`resolve(): initiating`)
+
+    /**
+     * THIS PROMISE SHOULD NEVER `reject()`! We want the app to proceed with
+     * startup, even if geolocation resolution fails.
+     */
+    geolocationServicePromise = new Promise(async resolve => {
+      let success = false
+
+      function cacheResponseOrThrow(response: Geolocation | undefined) {
+        if (response) {
+          device.set(['geolocationServiceResponse'], response)
+          emitGeolocationServiceResponseUpdate(response)
+        } else {
+          // endpoint should throw on all failures, this is insurance
+          throw new Error(`fetchGeolocationServiceData returned no data`)
+        }
+      }
+
+      try {
+        // Try once, fail fast
+        const config = await fetchGeolocationServiceData(
+          GEOLOCATION_SERVICE_URL,
+        )
+        cacheResponseOrThrow(config)
+        success = true
+      } catch (e: any) {
+        logger.debug(
+          `resolve(): fetchGeolocationServiceData failed initial request`,
+          {
+            safeMessage: e.message,
+          },
+        )
+
+        // retry 3 times, but don't await, proceed with default
+        networkRetry(3, () =>
+          fetchGeolocationServiceData(GEOLOCATION_SERVICE_URL),
+        )
+          .then(config => {
+            cacheResponseOrThrow(config)
+          })
+          .catch((e: any) => {
+            // complete fail closed
+            logger.debug(
+              `resolve(): fetchGeolocationServiceData failed retries`,
+              {
+                safeMessage: e.message,
+              },
+            )
+          })
+      } finally {
+        resolve({success})
+      }
+    })
+  }
+}
+
+export function useGeolocationServiceResponse() {
+  const [config, setConfig] = useState(() => {
+    const initial =
+      device.get(['geolocationServiceResponse']) ||
+      FALLBACK_GEOLOCATION_SERVICE_RESPONSE
+    return initial
+  })
+
+  useEffect(() => {
+    return onGeolocationServiceResponseUpdate(config => {
+      setConfig(config!)
+    })
+  }, [])
+
+  return config
+}

src/geolocation/types.ts

···
+export type Geolocation = {
+  countryCode: string | undefined
+  regionCode: string | undefined
+}

src/geolocation/util.ts

···
+import {type LocationGeocodedAddress} from 'expo-location'
+
+import {logger} from '#/geolocation/logger'
+import {type Geolocation} from '#/geolocation/types'
+
+/**
+ * Maps full US region names to their short codes.
+ *
+ * Context: in some cases, like on Android, we get the full region name instead
+ * of the short code. We may need to expand this in the future to other
+ * countries, hence the prefix.
+ */
+export const USRegionNameToRegionCode: {
+  [regionName: string]: string
+} = {
+  Alabama: 'AL',
+  Alaska: 'AK',
+  Arizona: 'AZ',
+  Arkansas: 'AR',
+  California: 'CA',
+  Colorado: 'CO',
+  Connecticut: 'CT',
+  Delaware: 'DE',
+  Florida: 'FL',
+  Georgia: 'GA',
+  Hawaii: 'HI',
+  Idaho: 'ID',
+  Illinois: 'IL',
+  Indiana: 'IN',
+  Iowa: 'IA',
+  Kansas: 'KS',
+  Kentucky: 'KY',
+  Louisiana: 'LA',
+  Maine: 'ME',
+  Maryland: 'MD',
+  Massachusetts: 'MA',
+  Michigan: 'MI',
+  Minnesota: 'MN',
+  Mississippi: 'MS',
+  Missouri: 'MO',
+  Montana: 'MT',
+  Nebraska: 'NE',
+  Nevada: 'NV',
+  ['New Hampshire']: 'NH',
+  ['New Jersey']: 'NJ',
+  ['New Mexico']: 'NM',
+  ['New York']: 'NY',
+  ['North Carolina']: 'NC',
+  ['North Dakota']: 'ND',
+  Ohio: 'OH',
+  Oklahoma: 'OK',
+  Oregon: 'OR',
+  Pennsylvania: 'PA',
+  ['Rhode Island']: 'RI',
+  ['South Carolina']: 'SC',
+  ['South Dakota']: 'SD',
+  Tennessee: 'TN',
+  Texas: 'TX',
+  Utah: 'UT',
+  Vermont: 'VT',
+  Virginia: 'VA',
+  Washington: 'WA',
+  ['West Virginia']: 'WV',
+  Wisconsin: 'WI',
+  Wyoming: 'WY',
+}
+
+/**
+ * Normalizes a `LocationGeocodedAddress` into a `Geolocation`.
+ *
+ * We don't want or care about the full location data, so we trim it down and
+ * normalize certain fields, like region, into the format we need.
+ */
+export function normalizeDeviceLocation(
+  location: LocationGeocodedAddress,
+): Geolocation {
+  let {isoCountryCode, region} = location
+
+  if (region) {
+    if (isoCountryCode === 'US') {
+      region = USRegionNameToRegionCode[region] ?? region
+    }
+  }
+
+  return {
+    countryCode: isoCountryCode ?? undefined,
+    regionCode: region ?? undefined,
+  }
+}
+
+/**
+ * Combines precise location data with the geolocation config fetched from the
+ * IP service, with preference to the precise data.
+ */
+export function mergeGeolocations(
+  device?: Geolocation,
+  geolocationService?: Geolocation,
+): Geolocation {
+  let geolocation: Geolocation = {
+    countryCode: geolocationService?.countryCode ?? undefined,
+    regionCode: geolocationService?.regionCode ?? undefined,
+  }
+  // prefer GPS
+  if (device?.countryCode) {
+    geolocation = device
+  }
+  logger.debug('merged geolocation data', {
+    device,
+    service: geolocationService,
+    merged: geolocation,
+  })
+  return geolocation
+}

src/lib/__tests__/parseLinkingUrl.test.ts

···
+import {describe, expect, it} from '@jest/globals'
+
+import {parseLinkingUrl} from '../parseLinkingUrl'
+
+describe('parseLinkingUrl', () => {
+  it('should correctly parse bluesky:// URLs', () => {
+    const url =
+      'bluesky://intent/age-assurance?result=success&actorDid=did:example:123'
+    const urlp = parseLinkingUrl(url)
+    expect(urlp.protocol).toBe('bluesky:')
+    expect(urlp.host).toBe('')
+    expect(urlp.pathname).toBe('/intent/age-assurance')
+  })
+
+  it('should correctly parse standard URLs', () => {
+    const url =
+      'https://bsky.app/intent/age-assurance?result=success&actorDid=did:example:123'
+    const urlp = parseLinkingUrl(url)
+    expect(urlp.protocol).toBe('https:')
+    expect(urlp.host).toBe('bsky.app')
+    expect(urlp.pathname).toBe('/intent/age-assurance')
+  })
+})

src/lib/api/resolve.ts

···
       const res = await agent.resolveHandle({
         handle: urip.host,
       })
+      // @ts-expect-error TODO new-sdk-migration
       urip.host = res.data.did
     }
     const res = await agent.getPosts({

src/lib/constants.ts

···
 export const PUBLIC_STAGING_APPVIEW_DID = 'did:web:api.staging.bsky.dev'
 
 export const DEV_ENV_APPVIEW = `http://localhost:2584` // always the same
+export const DEV_ENV_APPVIEW_DID = `did:plc:dw4kbjf5mn7nhenabiqpkyh3` // always the same
 
 // temp hack for e2e - esb
 export const BLUESKY_PROXY_HEADER = {

src/lib/currency.ts

···
 import React from 'react'
 
 import {deviceLocales} from '#/locale/deviceLocales'
-import {useGeolocationStatus} from '#/state/geolocation'
 import {useLanguagePrefs} from '#/state/preferences'
+import {useGeolocation} from '#/geolocation'
 
 /**
  * From react-native-localize
···
 export function useFormatCurrency(
   options?: Parameters<typeof Intl.NumberFormat>[1],
 ) {
-  const {location: geolocation} = useGeolocationStatus()
+  const geolocation = useGeolocation()
   const {appLanguage} = useLanguagePrefs()
   return React.useMemo(() => {
     const locale = deviceLocales.at(0)

src/lib/hooks/useAccountSwitcher.ts

···
             // So we change the URL ourselves. The navigator will pick it up on remount.
             history.pushState(null, '', '/')
           }
-          await resumeSession(account)
+          await resumeSession(account, true)
           logEvent('account:loggedIn', {logContext, withPassword: false})
           Toast.show(_(msg`Signed in as @${account.handle}`))
         } else {

src/lib/hooks/useCreateSupportLink.ts

···
 
 export enum SupportCode {
   AA_DID = 'AA_DID',
+  AA_BIRTHDATE = 'AA_BIRTHDATE',
 }
 
 /**

src/lib/hooks/useIntentHandler.ts

···
 import * as WebBrowser from 'expo-web-browser'
 
 import {useOpenComposer} from '#/lib/hooks/useOpenComposer'
+import {parseLinkingUrl} from '#/lib/parseLinkingUrl'
 import {logger} from '#/logger'
 import {isIOS, isNative} from '#/platform/detection'
 import {useSession} from '#/state/session'
 import {useCloseAllActiveElements} from '#/state/util'
-import {
-  parseAgeAssuranceRedirectDialogState,
-  useAgeAssuranceRedirectDialogControl,
-} from '#/components/ageAssurance/AgeAssuranceRedirectDialog'
 import {useIntentDialogs} from '#/components/intents/IntentDialogs'
 import {Referrer} from '../../../modules/expo-bluesky-swiss-army'
 import {useApplyPullRequestOTAUpdate} from './useOTAUpdates'
···
   const incomingUrl = Linking.useLinkingURL()
   const composeIntent = useComposeIntent()
   const verifyEmailIntent = useVerifyEmailIntent()
-  const ageAssuranceRedirectDialogControl =
-    useAgeAssuranceRedirectDialogControl()
   const {currentAccount} = useSession()
   const {tryApplyUpdate} = useApplyPullRequestOTAUpdate()
 
···
           hostname: referrerInfo?.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
-      // path parameter is in pathname rather than in hostname.
-      if (url.startsWith('bluesky://') && !url.startsWith('bluesky:///')) {
-        url = url.replace('bluesky://', 'bluesky:///')
-      }
-
-      const urlp = new URL(url)
-      const [__, intent, intentType] = urlp.pathname.split('/')
+      const urlp = parseLinkingUrl(url)
+      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
···
           return
         }
         case 'age-assurance': {
-          const state = parseAgeAssuranceRedirectDialogState({
-            result: params.get('result') ?? undefined,
-            actorDid: params.get('actorDid') ?? undefined,
-          })
-
-          /*
-           * If we don't have an account or the account doesn't match, do
-           * nothing. By the time the user switches to their other account, AA
-           * state should be ready for them.
-           */
-          if (
-            state &&
-            currentAccount &&
-            state.actorDid === currentAccount.did
-          ) {
-            ageAssuranceRedirectDialogControl.open(state)
-          }
+          // Handled in `#/ageAssurance/components/RedirectOverlay.tsx`
           return
         }
         case 'apply-ota': {
···
     incomingUrl,
     composeIntent,
     verifyEmailIntent,
-    ageAssuranceRedirectDialogControl,
     currentAccount,
     tryApplyUpdate,
   ])

src/lib/notifications/notifications.ts

···
 import {logger as notyLogger} from '#/lib/notifications/util'
 import {isNetworkError} from '#/lib/strings/errors'
 import {isNative} from '#/platform/detection'
-import {useAgeAssuranceContext} from '#/state/ageAssurance'
 import {type SessionAccount, useAgent, useSession} from '#/state/session'
 import BackgroundNotificationHandler from '#/../modules/expo-background-notification-handler'
+import {useAgeAssurance} from '#/ageAssurance'
 import {IS_DEV} from '#/env'
 
 /**
···
  * @see https://github.com/bluesky-social/social-app/pull/4467
  */
 export function useGetAndRegisterPushToken() {
-  const {isAgeRestricted} = useAgeAssuranceContext()
+  const aa = useAgeAssurance()
   const registerPushToken = useRegisterPushToken()
   return useCallback(
     async ({
···
          */
         registerPushToken({
           token,
-          isAgeRestricted: isAgeRestrictedOverride ?? isAgeRestricted,
+          isAgeRestricted:
+            isAgeRestrictedOverride ?? aa.state.access !== aa.Access.Full,
         })
       }
 
       return token
     },
-    [registerPushToken, isAgeRestricted],
+    [registerPushToken, aa],
   )
 }
 
···
   const {currentAccount} = useSession()
   const registerPushToken = useRegisterPushToken()
   const getAndRegisterPushToken = useGetAndRegisterPushToken()
-  const {isReady: isAgeRestrictionReady, isAgeRestricted} =
-    useAgeAssuranceContext()
+  const aa = useAgeAssurance()
 
   useEffect(() => {
     /**
      * We want this to init right away _after_ we have a logged in user, and
      * _after_ we've loaded their age assurance state.
      */
-    if (!currentAccount || !isAgeRestrictionReady) return
+    if (!currentAccount) return
 
     notyLogger.debug(`useNotificationsRegistration`)
 
···
      * @see https://docs.expo.dev/versions/latest/sdk/notifications/#addpushtokenlistenerlistener
      */
     const subscription = Notifications.addPushTokenListener(async token => {
-      registerPushToken({token, isAgeRestricted: isAgeRestricted})
+      registerPushToken({
+        token,
+        isAgeRestricted: aa.state.access !== aa.Access.Full,
+      })
       notyLogger.debug(`addPushTokenListener callback`, {token})
     })
 
     return () => {
       subscription.remove()
     }
-  }, [
-    currentAccount,
-    getAndRegisterPushToken,
-    registerPushToken,
-    isAgeRestrictionReady,
-    isAgeRestricted,
-  ])
+  }, [currentAccount, getAndRegisterPushToken, registerPushToken, aa])
 }
 
 export function useRequestNotificationsPermission() {

src/lib/parseLinkingUrl.ts

···
+export function parseLinkingUrl(url: string): URL {
+  /*
+   * Hack: add a third slash to bluesky:// urls so that `URL.host` is empty and
+   * `URL.pathname` has the full path.
+   */
+  if (url.startsWith('bluesky://') && !url.startsWith('bluesky:///')) {
+    url = url.replace('bluesky://', 'bluesky:///')
+  }
+  return new URL(url)
+}

src/lib/strings/url-helpers.ts

···
   collection: string,
   rkey: string,
 ) {
-  const urip = new AtUri('at://host/')
+  const urip = new AtUri('at://placeholder.placeholder/')
+  // @ts-expect-error TODO new-sdk-migration
   urip.host = didOrName
   urip.collection = collection
   urip.rkey = rkey

src/logger/metrics.ts

···
       | 'SignupQueued'
       | 'Deactivated'
       | 'Takendown'
+      | 'AgeAssuranceNoAccessScreen'
     scope: 'current' | 'every'
   }
   'notifications:openApp': {

src/screens/Login/ChooseAccountForm.tsx

···
       }
       try {
         setPendingDid(account.did)
-        await resumeSession(account)
+        await resumeSession(account, true)
         logEvent('account:loggedIn', {
           logContext: 'ChooseAccountForm',
           withPassword: false,

src/screens/Moderation/index.tsx

···
 } from '#/lib/routes/types'
 import {logger} from '#/logger'
 import {isIOS} from '#/platform/detection'
-import {useAgeAssurance} from '#/state/ageAssurance/useAgeAssurance'
 import {
   useMyLabelersQuery,
   usePreferencesQuery,
···
 import {isNonConfigurableModerationAuthority} from '#/state/session/additional-moderation-authorities'
 import {useSetMinimalShellMode} from '#/state/shell'
 import {atoms as a, useBreakpoints, useTheme, type ViewStyleProp} from '#/alf'
-import {Admonition} from '#/components/Admonition'
 import {AgeAssuranceAdmonition} from '#/components/ageAssurance/AgeAssuranceAdmonition'
-import {Button, ButtonText} from '#/components/Button'
-import * as Dialog from '#/components/Dialog'
-import {BirthDateSettingsDialog} from '#/components/dialogs/BirthDateSettings'
+import {Button} from '#/components/Button'
 import {useGlobalDialogsControlContext} from '#/components/dialogs/Context'
 import {Divider} from '#/components/Divider'
 import * as Toggle from '#/components/forms/Toggle'
···
 import {Loader} from '#/components/Loader'
 import {GlobalLabelPreference} from '#/components/moderation/LabelPreference'
 import {Text} from '#/components/Typography'
+import {useAgeAssurance} from '#/ageAssurance'
 
 function ErrorState({error}: {error: string}) {
   const t = useTheme()
···
     error: preferencesError,
     data: preferences,
   } = usePreferencesQuery()
-  const {isReady: isAgeInfoReady} = useAgeAssurance()
 
-  const isLoading = isPreferencesLoading || !isAgeInfoReady
+  const isLoading = isPreferencesLoading
   const error = preferencesError
 
   return (
···
   const setMinimalShellMode = useSetMinimalShellMode()
   const {gtMobile} = useBreakpoints()
   const {mutedWordsDialogControl} = useGlobalDialogsControlContext()
-  const birthdateDialogControl = Dialog.useDialogControl()
   const {
     isLoading: isLabelersLoading,
     data: labelers,
     error: labelersError,
   } = useMyLabelersQuery()
-  const {declaredAge, isDeclaredUnderage, isAgeRestricted} = useAgeAssurance()
+  const aa = useAgeAssurance()
 
   useFocusEffect(
     useCallback(() => {
···
 
   return (
     <View style={[a.pt_2xl, a.px_lg, gtMobile && a.px_2xl]}>
-      {isDeclaredUnderage && (
-        <View style={[a.pb_2xl]}>
-          <Admonition type="tip" style={[a.pb_md]}>
-            <Trans>
-              Your declared age is under 18. Some settings below may be
-              disabled. If this was a mistake, you may edit your birthdate in
-              your{' '}
-              <InlineLinkText
-                to="/settings/account"
-                label={_(msg`Go to account settings`)}>
-                account settings
-              </InlineLinkText>
-              .
-            </Trans>
-          </Admonition>
-        </View>
-      )}
-
       <Text
         style={[
           a.text_md,
···
         </Link>
       </View>
 
-      {(!isDeclaredUnderage || declaredAge === undefined) && (
-        <Text
+      <Text
+        style={[
+          a.pt_2xl,
+          a.pb_md,
+          a.text_md,
+          a.font_semi_bold,
+          t.atoms.text_contrast_high,
+        ]}>
+        <Trans>Content filters</Trans>
+      </Text>
+
+      <AgeAssuranceAdmonition style={[a.pb_md]}>
+        <Trans>
+          You must complete age assurance in order to access content filters.
+        </Trans>
+      </AgeAssuranceAdmonition>
+
+      <View style={[a.gap_md]}>
+        <View
           style={[
-            a.pt_2xl,
-            a.pb_md,
-            a.text_md,
-            a.font_semi_bold,
-            t.atoms.text_contrast_high,
+            a.w_full,
+            a.rounded_md,
+            a.overflow_hidden,
+            t.atoms.bg_contrast_25,
           ]}>
-          <Trans>Content filters</Trans>
-        </Text>
-      )}
-
-      {declaredAge === undefined ? (
-        <>
-          <Button
-            label={_(msg`Confirm your birthdate`)}
-            size="small"
-            variant="solid"
-            color="secondary"
-            onPress={() => {
-              birthdateDialogControl.open()
-            }}
-            style={[a.justify_between, a.rounded_md, a.px_lg, a.py_lg]}>
-            <ButtonText>
-              <Trans>Confirm your age:</Trans>
-            </ButtonText>
-            <ButtonText>
-              <Trans>Set birthdate</Trans>
-            </ButtonText>
-          </Button>
-
-          <BirthDateSettingsDialog control={birthdateDialogControl} />
-        </>
-      ) : !isDeclaredUnderage ? (
-        <>
-          <AgeAssuranceAdmonition style={[a.pb_md]}>
-            <Trans>
-              You must complete age assurance in order to access the settings
-              below.
-            </Trans>
-          </AgeAssuranceAdmonition>
-
-          <View style={[a.gap_md]}>
-            <View
-              style={[
-                a.w_full,
-                a.rounded_md,
-                a.overflow_hidden,
-                t.atoms.bg_contrast_25,
-              ]}>
-              {!isDeclaredUnderage && (
-                <>
-                  <View
-                    style={[
-                      a.py_lg,
-                      a.px_lg,
-                      a.flex_row,
-                      a.align_center,
-                      a.justify_between,
-                      disabledOnIOS && {opacity: 0.5},
-                    ]}>
-                    <Text
-                      style={[a.font_semi_bold, t.atoms.text_contrast_high]}>
-                      <Trans>Enable adult content</Trans>
+          {aa.state.access === aa.Access.Full && (
+            <>
+              <View
+                style={[
+                  a.py_lg,
+                  a.px_lg,
+                  a.flex_row,
+                  a.align_center,
+                  a.justify_between,
+                  disabledOnIOS && {opacity: 0.5},
+                ]}>
+                <Text style={[a.font_semi_bold, t.atoms.text_contrast_high]}>
+                  <Trans>Enable adult content</Trans>
+                </Text>
+                <Toggle.Item
+                  label={_(msg`Toggle to enable or disable adult content`)}
+                  disabled={disabledOnIOS}
+                  name="adultContent"
+                  value={adultContentEnabled}
+                  onChange={onToggleAdultContentEnabled}>
+                  <View style={[a.flex_row, a.align_center, a.gap_sm]}>
+                    <Text style={[t.atoms.text_contrast_medium]}>
+                      {adultContentEnabled ? (
+                        <Trans>Enabled</Trans>
+                      ) : (
+                        <Trans>Disabled</Trans>
+                      )}
                     </Text>
-                    <Toggle.Item
-                      label={_(msg`Toggle to enable or disable adult content`)}
-                      disabled={disabledOnIOS || isAgeRestricted}
-                      name="adultContent"
-                      value={adultContentEnabled}
-                      onChange={onToggleAdultContentEnabled}>
-                      <View style={[a.flex_row, a.align_center, a.gap_sm]}>
-                        <Text style={[t.atoms.text_contrast_medium]}>
-                          {adultContentEnabled ? (
-                            <Trans>Enabled</Trans>
-                          ) : (
-                            <Trans>Disabled</Trans>
-                          )}
-                        </Text>
-                        <Toggle.Switch />
-                      </View>
-                    </Toggle.Item>
+                    <Toggle.Switch />
                   </View>
-                  {disabledOnIOS && (
-                    <View style={[a.pb_lg, a.px_lg]}>
-                      <Text>
-                        <Trans>
-                          Adult content can only be enabled via the Web at{' '}
-                          <InlineLinkText
-                            label={_(msg`The Bluesky web application`)}
-                            to=""
-                            onPress={evt => {
-                              evt.preventDefault()
-                              Linking.openURL('https://bsky.app/')
-                              return false
-                            }}>
-                            bsky.app
-                          </InlineLinkText>
-                          .
-                        </Trans>
-                      </Text>
-                    </View>
-                  )}
+                </Toggle.Item>
+              </View>
+              {disabledOnIOS && (
+                <View style={[a.pb_lg, a.px_lg]}>
+                  <Text>
+                    <Trans>
+                      Adult content can only be enabled via the Web at{' '}
+                      <InlineLinkText
+                        label={_(msg`The Bluesky web application`)}
+                        to=""
+                        onPress={evt => {
+                          evt.preventDefault()
+                          Linking.openURL('https://bsky.app/')
+                          return false
+                        }}>
+                        bsky.app
+                      </InlineLinkText>
+                      .
+                    </Trans>
+                  </Text>
+                </View>
+              )}
 
-                  {adultContentEnabled && (
-                    <>
-                      <Divider />
-                      <GlobalLabelPreference labelDefinition={LABELS.porn} />
-                      <Divider />
-                      <GlobalLabelPreference labelDefinition={LABELS.sexual} />
-                      <Divider />
-                      <GlobalLabelPreference
-                        labelDefinition={LABELS['graphic-media']}
-                      />
-                      <Divider />
-                      <GlobalLabelPreference
-                        disabled={isDeclaredUnderage || isAgeRestricted}
-                        labelDefinition={LABELS.nudity}
-                      />
-                    </>
-                  )}
+              {adultContentEnabled && (
+                <>
+                  <Divider />
+                  <GlobalLabelPreference labelDefinition={LABELS.porn} />
+                  <Divider />
+                  <GlobalLabelPreference labelDefinition={LABELS.sexual} />
+                  <Divider />
+                  <GlobalLabelPreference
+                    labelDefinition={LABELS['graphic-media']}
+                  />
+                  <Divider />
+                  <GlobalLabelPreference labelDefinition={LABELS.nudity} />
                 </>
               )}
-            </View>
-          </View>
-        </>
-      ) : null}
+            </>
+          )}
+        </View>
+      </View>
 
       <Text
         style={[

src/screens/Onboarding/StepSuggestedAccounts/index.tsx

···
   return (
     <View
       style={[
-        a.flex_1,
         a.w_full,
         a.py_lg,
         a.px_xl,

src/state/__mocks__/birthdate.ts

···
+export const snoozeBirthdateUpdateAllowedForDid = () => {}

src/state/ageAssurance/const.ts

···
-import {type ModerationPrefs} from '@atproto/api'
-
-import {DEFAULT_LOGGED_OUT_LABEL_PREFERENCES} from '#/state/queries/preferences/moderation'
-
-export const makeAgeRestrictedModerationPrefs = (
-  prefs: ModerationPrefs,
-): ModerationPrefs => ({
-  ...prefs,
-  adultContentEnabled: false,
-  labels: DEFAULT_LOGGED_OUT_LABEL_PREFERENCES,
-})

src/state/ageAssurance/index.tsx

···
-import {createContext, useContext, useMemo, useState} from 'react'
-import {type AppBskyUnspeccedDefs} from '@atproto/api'
-import {useQuery} from '@tanstack/react-query'
-
-import {networkRetry} from '#/lib/async/retry'
-import {useGetAndRegisterPushToken} from '#/lib/notifications/notifications'
-import {isNetworkError} from '#/lib/strings/errors'
-import {
-  type AgeAssuranceAPIContextType,
-  type AgeAssuranceContextType,
-} from '#/state/ageAssurance/types'
-import {useIsAgeAssuranceEnabled} from '#/state/ageAssurance/useIsAgeAssuranceEnabled'
-import {logger} from '#/state/ageAssurance/util'
-import {useGeolocationStatus} from '#/state/geolocation'
-import {useAgent} from '#/state/session'
-
-export const createAgeAssuranceQueryKey = (did: string) =>
-  ['ageAssurance', did] as const
-
-const DEFAULT_AGE_ASSURANCE_STATE: AppBskyUnspeccedDefs.AgeAssuranceState = {
-  lastInitiatedAt: undefined,
-  status: 'unknown',
-}
-
-const AgeAssuranceContext = createContext<AgeAssuranceContextType>({
-  status: 'unknown',
-  isReady: false,
-  lastInitiatedAt: undefined,
-  isAgeRestricted: false,
-})
-AgeAssuranceContext.displayName = 'AgeAssuranceContext'
-
-const AgeAssuranceAPIContext = createContext<AgeAssuranceAPIContextType>({
-  // @ts-ignore can't be bothered to type this
-  refetch: () => Promise.resolve(),
-})
-AgeAssuranceAPIContext.displayName = 'AgeAssuranceAPIContext'
-
-/**
- * Low-level provider for fetching age assurance state on app load. Do not add
- * any other data fetching in here to avoid complications and reduced
- * performance.
- */
-export function Provider({children}: {children: React.ReactNode}) {
-  const agent = useAgent()
-  const {status: geolocation} = useGeolocationStatus()
-  const isAgeAssuranceEnabled = useIsAgeAssuranceEnabled()
-  const getAndRegisterPushToken = useGetAndRegisterPushToken()
-  const [refetchWhilePending, setRefetchWhilePending] = useState(false)
-
-  const {data, isFetched, refetch} = useQuery({
-    /**
-     * This is load bearing. We always want this query to run and end in a
-     * "fetched" state, even if we fall back to defaults. This lets the rest of
-     * the app know that we've at least attempted to load the AA state.
-     *
-     * However, it only needs to run if AA is enabled.
-     */
-    enabled: isAgeAssuranceEnabled,
-    refetchOnWindowFocus: refetchWhilePending,
-    queryKey: createAgeAssuranceQueryKey(agent.session?.did ?? 'never'),
-    async queryFn() {
-      if (!agent.session) return null
-
-      try {
-        const {data} = await networkRetry(3, () =>
-          agent.app.bsky.unspecced.getAgeAssuranceState(),
-        )
-        // const {data} = {
-        //   data: {
-        //     lastInitiatedAt: new Date().toISOString(),
-        //     status: 'pending',
-        //   } as AppBskyUnspeccedDefs.AgeAssuranceState,
-        // }
-
-        logger.debug(`fetch`, {
-          data,
-          account: agent.session?.did,
-        })
-
-        await getAndRegisterPushToken({
-          isAgeRestricted:
-            !!geolocation?.isAgeRestrictedGeo && data.status !== 'assured',
-        })
-
-        return data
-      } catch (e) {
-        if (!isNetworkError(e)) {
-          logger.error(`ageAssurance: failed to fetch`, {safeMessage: e})
-        }
-        // don't re-throw error, we'll just fall back to defaults
-        return null
-      }
-    },
-  })
-
-  /**
-   * Derive state, or fall back to defaults
-   */
-  const ageAssuranceContext = useMemo<AgeAssuranceContextType>(() => {
-    const {status, lastInitiatedAt} = data || DEFAULT_AGE_ASSURANCE_STATE
-    const ctx: AgeAssuranceContextType = {
-      isReady: isFetched || !isAgeAssuranceEnabled,
-      status,
-      lastInitiatedAt,
-      isAgeRestricted: isAgeAssuranceEnabled ? status !== 'assured' : false,
-    }
-    logger.debug(`context`, ctx)
-    return ctx
-  }, [isFetched, data, isAgeAssuranceEnabled])
-
-  if (
-    !!ageAssuranceContext.lastInitiatedAt &&
-    ageAssuranceContext.status === 'pending' &&
-    !refetchWhilePending
-  ) {
-    /*
-     * If we have a pending state, we want to refetch on window focus to ensure
-     * that we get the latest state when the user returns to the app.
-     */
-    setRefetchWhilePending(true)
-  } else if (
-    !!ageAssuranceContext.lastInitiatedAt &&
-    ageAssuranceContext.status !== 'pending' &&
-    refetchWhilePending
-  ) {
-    setRefetchWhilePending(false)
-  }
-
-  const ageAssuranceAPIContext = useMemo<AgeAssuranceAPIContextType>(
-    () => ({
-      refetch,
-    }),
-    [refetch],
-  )
-
-  return (
-    <AgeAssuranceAPIContext.Provider value={ageAssuranceAPIContext}>
-      <AgeAssuranceContext.Provider value={ageAssuranceContext}>
-        {children}
-      </AgeAssuranceContext.Provider>
-    </AgeAssuranceAPIContext.Provider>
-  )
-}
-
-/**
- * Access to low-level AA state. Prefer using {@link useAgeInfo} for a
- * more user-friendly interface.
- */
-export function useAgeAssuranceContext() {
-  return useContext(AgeAssuranceContext)
-}
-
-export function useAgeAssuranceAPIContext() {
-  return useContext(AgeAssuranceAPIContext)
-}

src/state/ageAssurance/types.ts

···
-import {type AppBskyUnspeccedDefs} from '@atproto/api'
-import {type QueryObserverBaseResult} from '@tanstack/react-query'
-
-export type AgeAssuranceContextType = {
-  /**
-   * Whether the age assurance state has been fetched from the server. If user
-   * is not in a region that requires AA, or AA is otherwise disabled, this
-   * will always be `true`.
-   */
-  isReady: boolean
-  /**
-   * The server-reported status of the user's age verification process.
-   */
-  status: AppBskyUnspeccedDefs.AgeAssuranceState['status']
-  /**
-   * The last time the age assurance state was attempted by the user.
-   */
-  lastInitiatedAt: AppBskyUnspeccedDefs.AgeAssuranceState['lastInitiatedAt']
-  /**
-   * Indicates the user is age restricted based on the requirements of their
-   * region, and their server-provided age assurance status. Does not factor in
-   * the user's declared age. If AA is otherise disabled, this will always be
-   * `false`.
-   */
-  isAgeRestricted: boolean
-}
-
-export type AgeAssuranceAPIContextType = {
-  /**
-   * Refreshes the age assurance state by fetching it from the server.
-   */
-  refetch: QueryObserverBaseResult['refetch']
-}

src/state/ageAssurance/useAgeAssurance.ts

···
-import {useMemo} from 'react'
-
-import {useAgeAssuranceContext} from '#/state/ageAssurance'
-import {logger} from '#/state/ageAssurance/util'
-import {usePreferencesQuery} from '#/state/queries/preferences'
-
-type AgeAssurance = ReturnType<typeof useAgeAssuranceContext> & {
-  /**
-   * The age the user has declared in their preferences, if any.
-   */
-  declaredAge: number | undefined
-  /**
-   * Indicates whether the user has declared an age under 18.
-   */
-  isDeclaredUnderage: boolean
-}
-
-/**
- * Computed age information based on age assurance status and the user's
- * declared age. Use this instead of {@link useAgeAssuranceContext} to get a
- * more user-friendly interface.
- */
-export function useAgeAssurance(): AgeAssurance {
-  const aa = useAgeAssuranceContext()
-  const {isFetched: preferencesLoaded, data: preferences} =
-    usePreferencesQuery()
-  const declaredAge = preferences?.userAge
-
-  return useMemo(() => {
-    const isReady = aa.isReady && preferencesLoaded
-    const isDeclaredUnderage =
-      declaredAge !== undefined ? declaredAge < 18 : false
-    const state: AgeAssurance = {
-      isReady,
-      status: aa.status,
-      lastInitiatedAt: aa.lastInitiatedAt,
-      isAgeRestricted: aa.isAgeRestricted,
-      declaredAge,
-      isDeclaredUnderage,
-    }
-    logger.debug(`state`, state)
-    return state
-  }, [aa, preferencesLoaded, declaredAge])
-}

src/state/ageAssurance/useInitAgeAssurance.ts

···
-import {
-  type AppBskyUnspeccedDefs,
-  type AppBskyUnspeccedInitAgeAssurance,
-  AtpAgent,
-} from '@atproto/api'
-import {useMutation, useQueryClient} from '@tanstack/react-query'
-
-import {wait} from '#/lib/async/wait'
-import {
-  // DEV_ENV_APPVIEW,
-  PUBLIC_APPVIEW,
-  PUBLIC_APPVIEW_DID,
-} from '#/lib/constants'
-import {isNetworkError} from '#/lib/hooks/useCleanError'
-import {logger} from '#/logger'
-import {createAgeAssuranceQueryKey} from '#/state/ageAssurance'
-import {type DeviceLocation, useGeolocationStatus} from '#/state/geolocation'
-import {useAgent} from '#/state/session'
-
-let APPVIEW = PUBLIC_APPVIEW
-let APPVIEW_DID = PUBLIC_APPVIEW_DID
-
-/*
- * Uncomment if using the local dev-env
- */
-// if (__DEV__) {
-//   APPVIEW = DEV_ENV_APPVIEW
-//   /*
-//    * IMPORTANT: you need to get this value from `http://localhost:2581`
-//    * introspection endpoint and updated in `constants`, since it changes
-//    * every time you run the dev-env.
-//    */
-//   APPVIEW_DID = ``
-// }
-
-/**
- * Creates an ISO country code string from the given geolocation data.
- * Examples: `GB` or `GB-ENG`
- */
-function createISOCountryCode(
-  geolocation: Omit<DeviceLocation, 'countryCode'> & {
-    countryCode: string
-  },
-): string {
-  return geolocation.countryCode.toUpperCase()
-}
-
-export function useInitAgeAssurance() {
-  const qc = useQueryClient()
-  const agent = useAgent()
-  const {status: geolocation} = useGeolocationStatus()
-  return useMutation({
-    async mutationFn(
-      props: Omit<AppBskyUnspeccedInitAgeAssurance.InputSchema, 'countryCode'>,
-    ) {
-      const countryCode = geolocation?.countryCode
-      const regionCode = geolocation?.regionCode
-      if (!countryCode) {
-        throw new Error(`Geolocation not available, cannot init age assurance.`)
-      }
-
-      const {
-        data: {token},
-      } = await agent.com.atproto.server.getServiceAuth({
-        aud: APPVIEW_DID,
-        lxm: `app.bsky.unspecced.initAgeAssurance`,
-      })
-
-      const appView = new AtpAgent({service: APPVIEW})
-      appView.sessionManager.session = {...agent.session!}
-      appView.sessionManager.session.accessJwt = token
-      appView.sessionManager.session.refreshJwt = ''
-
-      /*
-       * 2s wait is good actually. Email sending takes a hot sec and this helps
-       * ensure the email is ready for the user once they open their inbox.
-       */
-      const {data} = await wait(
-        2e3,
-        appView.app.bsky.unspecced.initAgeAssurance({
-          ...props,
-          countryCode: createISOCountryCode({
-            countryCode,
-            regionCode,
-          }),
-        }),
-      )
-
-      qc.setQueryData<AppBskyUnspeccedDefs.AgeAssuranceState>(
-        createAgeAssuranceQueryKey(agent.session?.did ?? 'never'),
-        () => data,
-      )
-    },
-    onError(e) {
-      if (!isNetworkError(e)) {
-        logger.error(`useInitAgeAssurance failed`, {
-          safeMessage: e,
-        })
-      }
-    },
-  })
-}

src/state/ageAssurance/useIsAgeAssuranceEnabled.ts

···
-import {useMemo} from 'react'
-
-import {useGeolocationStatus} from '#/state/geolocation'
-
-export function useIsAgeAssuranceEnabled() {
-  const {status: geolocation} = useGeolocationStatus()
-
-  return useMemo(() => {
-    return !!geolocation?.isAgeRestrictedGeo
-  }, [geolocation])
-}

src/state/birthdate.ts

···
+import {useMemo} from 'react'
+import {useMutation, useQueryClient} from '@tanstack/react-query'
+
+import {preferencesQueryKey} from '#/state/queries/preferences'
+import {useAgent, useSession} from '#/state/session'
+import {usePatchAgeAssuranceOtherRequiredData} from '#/ageAssurance'
+import {IS_DEV} from '#/env'
+import {account} from '#/storage'
+
+// 6s in dev, 48h in prod
+const BIRTHDATE_DELAY_HOURS = IS_DEV ? 0.001 : 48
+
+/**
+ * Stores the timestamp of the birthday update locally. This is used to
+ * debounce birthday updates globally.
+ *
+ * Use {@link useIsBirthDateUpdateAllowed} to check if an update is allowed.
+ */
+export function snoozeBirthdateUpdateAllowedForDid(did: string) {
+  account.set([did, 'birthdateLastUpdatedAt'], new Date().toISOString())
+}
+
+/**
+ * Returns whether a birthdate update is currently allowed, based on the
+ * last update timestamp stored locally.
+ */
+export function useIsBirthdateUpdateAllowed() {
+  const {currentAccount} = useSession()
+  return useMemo(() => {
+    if (!currentAccount) return false
+    const lastUpdated = account.get([
+      currentAccount.did,
+      'birthdateLastUpdatedAt',
+    ])
+    if (!lastUpdated) return true
+    const lastUpdatedDate = new Date(lastUpdated)
+    const diffMs = Date.now() - lastUpdatedDate.getTime()
+    const diffHours = diffMs / (1000 * 60 * 60)
+    return diffHours >= BIRTHDATE_DELAY_HOURS
+  }, [currentAccount])
+}
+
+export function useBirthdateMutation() {
+  const queryClient = useQueryClient()
+  const agent = useAgent()
+  const patchOtherRequiredData = usePatchAgeAssuranceOtherRequiredData()
+
+  return useMutation<void, unknown, {birthDate: Date}>({
+    mutationFn: async ({birthDate}: {birthDate: Date}) => {
+      const bday = birthDate.toISOString()
+      await agent.setPersonalDetails({birthDate: bday})
+      // triggers a refetch
+      await queryClient.invalidateQueries({
+        queryKey: preferencesQueryKey,
+      })
+      /**
+       * Also patch the age assurance other required data with the new
+       * birthdate, which may change the user's age assurance access level.
+       */
+      patchOtherRequiredData({birthdate: bday})
+      snoozeBirthdateUpdateAllowedForDid(agent.sessionManager.did!)
+    },
+  })
+}

src/state/geolocation/config.ts

···
-import {networkRetry} from '#/lib/async/retry'
-import {
-  DEFAULT_GEOLOCATION_CONFIG,
-  GEOLOCATION_CONFIG_URL,
-} from '#/state/geolocation/const'
-import {emitGeolocationConfigUpdate} from '#/state/geolocation/events'
-import {logger} from '#/state/geolocation/logger'
-import {BAPP_CONFIG_DEV_BYPASS_SECRET, IS_DEV} from '#/env'
-import {type Device, device} from '#/storage'
-
-async function getGeolocationConfig(
-  url: string,
-): Promise<Device['geolocation']> {
-  const res = await fetch(url, {
-    headers: IS_DEV
-      ? {
-          'x-dev-bypass-secret': BAPP_CONFIG_DEV_BYPASS_SECRET,
-        }
-      : undefined,
-  })
-
-  if (!res.ok) {
-    throw new Error(`config: fetch failed ${res.status}`)
-  }
-
-  const json = await res.json()
-
-  if (json.countryCode) {
-    /**
-     * Only construct known values here, ignore any extras.
-     */
-    const config: Device['geolocation'] = {
-      countryCode: json.countryCode,
-      regionCode: json.regionCode ?? undefined,
-      ageRestrictedGeos: json.ageRestrictedGeos ?? [],
-      ageBlockedGeos: json.ageBlockedGeos ?? [],
-    }
-    logger.debug(`config: success`)
-    return config
-  } else {
-    return undefined
-  }
-}
-
-/**
- * Local promise used within this file only.
- */
-let geolocationConfigResolution: Promise<{success: boolean}> | undefined
-
-/**
- * Begin the process of resolving geolocation config. This should be called
- * once at app start.
- *
- * THIS METHOD SHOULD NEVER THROW.
- *
- * This method is otherwise not used for any purpose. To ensure geolocation
- * config is resolved, use {@link ensureGeolocationConfigIsResolved}
- */
-export function beginResolveGeolocationConfig() {
-  /**
-   * Here for debug purposes. Uncomment to prevent hitting the remote geo service, and apply whatever data you require for testing.
-   */
-  // if (__DEV__) {
-  //   geolocationConfigResolution = new Promise(y => y({success: true}))
-  //   device.set(['deviceGeolocation'], undefined) // clears GPS data
-  //   device.set(['geolocation'], DEFAULT_GEOLOCATION_CONFIG) // clears bapp-config data
-  //   return
-  // }
-
-  geolocationConfigResolution = new Promise(async resolve => {
-    let success = true
-
-    try {
-      // Try once, fail fast
-      const config = await getGeolocationConfig(GEOLOCATION_CONFIG_URL)
-      if (config) {
-        device.set(['geolocation'], config)
-        emitGeolocationConfigUpdate(config)
-      } else {
-        // endpoint should throw on all failures, this is insurance
-        throw new Error(
-          `geolocation config: nothing returned from initial request`,
-        )
-      }
-    } catch (e: any) {
-      success = false
-
-      logger.debug(`config: failed initial request`, {
-        safeMessage: e.message,
-      })
-
-      // set to default
-      device.set(['geolocation'], DEFAULT_GEOLOCATION_CONFIG)
-
-      // retry 3 times, but don't await, proceed with default
-      networkRetry(3, () => getGeolocationConfig(GEOLOCATION_CONFIG_URL))
-        .then(config => {
-          if (config) {
-            device.set(['geolocation'], config)
-            emitGeolocationConfigUpdate(config)
-            success = true
-          } else {
-            // endpoint should throw on all failures, this is insurance
-            throw new Error(`config: nothing returned from retries`)
-          }
-        })
-        .catch((e: any) => {
-          // complete fail closed
-          logger.debug(`config: failed retries`, {
-            safeMessage: e.message,
-          })
-        })
-    } finally {
-      resolve({success})
-    }
-  })
-}
-
-/**
- * Ensure that geolocation config has been resolved, or at the very least attempted
- * once. Subsequent retries will not be captured by this `await`. Those will be
- * reported via {@link emitGeolocationConfigUpdate}.
- */
-export async function ensureGeolocationConfigIsResolved() {
-  if (!geolocationConfigResolution) {
-    throw new Error(`config: beginResolveGeolocationConfig not called yet`)
-  }
-
-  const cached = device.get(['geolocation'])
-  if (cached) {
-    logger.debug(`config: using cache`)
-  } else {
-    logger.debug(`config: no cache`)
-    const {success} = await geolocationConfigResolution
-    if (success) {
-      logger.debug(`config: resolved`)
-    } else {
-      logger.info(`config: failed to resolve`)
-    }
-  }
-}

src/state/geolocation/const.ts

···
-import {type GeolocationStatus} from '#/state/geolocation/types'
-import {BAPP_CONFIG_DEV_URL, IS_DEV} from '#/env'
-import {type Device} from '#/storage'
-
-export const IPCC_URL = `https://bsky.app/ipcc`
-export const BAPP_CONFIG_URL_PROD = `https://ip.bsky.app/config`
-export const BAPP_CONFIG_URL = IS_DEV
-  ? (BAPP_CONFIG_DEV_URL ?? BAPP_CONFIG_URL_PROD)
-  : BAPP_CONFIG_URL_PROD
-export const GEOLOCATION_CONFIG_URL = BAPP_CONFIG_URL
-
-/**
- * Default geolocation config.
- */
-export const DEFAULT_GEOLOCATION_CONFIG: Device['geolocation'] = {
-  countryCode: undefined,
-  regionCode: undefined,
-  ageRestrictedGeos: [],
-  ageBlockedGeos: [],
-}
-
-/**
- * Default geolocation status.
- */
-export const DEFAULT_GEOLOCATION_STATUS: GeolocationStatus = {
-  countryCode: undefined,
-  regionCode: undefined,
-  isAgeRestrictedGeo: false,
-  isAgeBlockedGeo: false,
-}

src/state/geolocation/events.ts

···
-import EventEmitter from 'eventemitter3'
-
-import {type Device} from '#/storage'
-
-const events = new EventEmitter()
-const EVENT = 'geolocation-config-updated'
-
-export const emitGeolocationConfigUpdate = (config: Device['geolocation']) => {
-  events.emit(EVENT, config)
-}
-
-export const onGeolocationConfigUpdate = (
-  listener: (config: Device['geolocation']) => void,
-) => {
-  events.on(EVENT, listener)
-  return () => {
-    events.off(EVENT, listener)
-  }
-}

src/state/geolocation/index.tsx

···
-import React from 'react'
-
-import {
-  DEFAULT_GEOLOCATION_CONFIG,
-  DEFAULT_GEOLOCATION_STATUS,
-} from '#/state/geolocation/const'
-import {onGeolocationConfigUpdate} from '#/state/geolocation/events'
-import {logger} from '#/state/geolocation/logger'
-import {
-  type DeviceLocation,
-  type GeolocationStatus,
-} from '#/state/geolocation/types'
-import {useSyncedDeviceGeolocation} from '#/state/geolocation/useSyncedDeviceGeolocation'
-import {
-  computeGeolocationStatus,
-  mergeGeolocation,
-} from '#/state/geolocation/util'
-import {type Device, device} from '#/storage'
-
-export * from '#/state/geolocation/config'
-export * from '#/state/geolocation/types'
-export * from '#/state/geolocation/util'
-
-type DeviceGeolocationContext = {
-  deviceGeolocation: DeviceLocation | undefined
-}
-
-type DeviceGeolocationAPIContext = {
-  setDeviceGeolocation(deviceGeolocation: DeviceLocation): void
-}
-
-type GeolocationConfigContext = {
-  config: Device['geolocation']
-}
-
-type GeolocationStatusContext = {
-  /**
-   * Merged geolocation from config and device GPS (if available).
-   */
-  location: DeviceLocation
-  /**
-   * Computed geolocation status based on the merged location and config.
-   */
-  status: GeolocationStatus
-}
-
-const DeviceGeolocationContext = React.createContext<DeviceGeolocationContext>({
-  deviceGeolocation: undefined,
-})
-DeviceGeolocationContext.displayName = 'DeviceGeolocationContext'
-
-const DeviceGeolocationAPIContext =
-  React.createContext<DeviceGeolocationAPIContext>({
-    setDeviceGeolocation: () => {},
-  })
-DeviceGeolocationAPIContext.displayName = 'DeviceGeolocationAPIContext'
-
-const GeolocationConfigContext = React.createContext<GeolocationConfigContext>({
-  config: DEFAULT_GEOLOCATION_CONFIG,
-})
-GeolocationConfigContext.displayName = 'GeolocationConfigContext'
-
-const GeolocationStatusContext = React.createContext<GeolocationStatusContext>({
-  location: {
-    countryCode: undefined,
-    regionCode: undefined,
-  },
-  status: DEFAULT_GEOLOCATION_STATUS,
-})
-GeolocationStatusContext.displayName = 'GeolocationStatusContext'
-
-/**
- * Provider of geolocation config and computed geolocation status.
- */
-export function GeolocationStatusProvider({
-  children,
-}: {
-  children: React.ReactNode
-}) {
-  const {deviceGeolocation} = React.useContext(DeviceGeolocationContext)
-  const [config, setConfig] = React.useState(() => {
-    const initial = device.get(['geolocation']) || DEFAULT_GEOLOCATION_CONFIG
-    return initial
-  })
-
-  React.useEffect(() => {
-    return onGeolocationConfigUpdate(config => {
-      setConfig(config!)
-    })
-  }, [])
-
-  const configContext = React.useMemo(() => ({config}), [config])
-  const statusContext = React.useMemo(() => {
-    if (deviceGeolocation?.countryCode) {
-      logger.debug('has device geolocation available')
-    }
-    const geolocation = mergeGeolocation(deviceGeolocation, config)
-    const status = computeGeolocationStatus(geolocation, config)
-    // ensure this remains debug and never leaves device
-    logger.debug('result', {deviceGeolocation, geolocation, status, config})
-    return {location: geolocation, status}
-  }, [config, deviceGeolocation])
-
-  return (
-    <GeolocationConfigContext.Provider value={configContext}>
-      <GeolocationStatusContext.Provider value={statusContext}>
-        {children}
-      </GeolocationStatusContext.Provider>
-    </GeolocationConfigContext.Provider>
-  )
-}
-
-/**
- * Provider of providers. Provides device geolocation data to lower-level
- * `GeolocationStatusProvider`, and device geolocation APIs to children.
- */
-export function Provider({children}: {children: React.ReactNode}) {
-  const [deviceGeolocation, setDeviceGeolocation] = useSyncedDeviceGeolocation()
-
-  const handleSetDeviceGeolocation = React.useCallback(
-    (location: DeviceLocation) => {
-      logger.debug('setting device geolocation')
-      setDeviceGeolocation({
-        countryCode: location.countryCode ?? undefined,
-        regionCode: location.regionCode ?? undefined,
-      })
-    },
-    [setDeviceGeolocation],
-  )
-
-  return (
-    <DeviceGeolocationAPIContext.Provider
-      value={React.useMemo(
-        () => ({setDeviceGeolocation: handleSetDeviceGeolocation}),
-        [handleSetDeviceGeolocation],
-      )}>
-      <DeviceGeolocationContext.Provider
-        value={React.useMemo(() => ({deviceGeolocation}), [deviceGeolocation])}>
-        <GeolocationStatusProvider>{children}</GeolocationStatusProvider>
-      </DeviceGeolocationContext.Provider>
-    </DeviceGeolocationAPIContext.Provider>
-  )
-}
-
-export function useDeviceGeolocationApi() {
-  return React.useContext(DeviceGeolocationAPIContext)
-}
-
-export function useGeolocationConfig() {
-  return React.useContext(GeolocationConfigContext)
-}
-
-export function useGeolocationStatus() {
-  return React.useContext(GeolocationStatusContext)
-}

src/state/geolocation/types.ts

···
-export type DeviceLocation = {
-  countryCode: string | undefined
-  regionCode: string | undefined
-}
-
-export type GeolocationStatus = DeviceLocation & {
-  isAgeRestrictedGeo: boolean
-  isAgeBlockedGeo: boolean
-}

src/state/geolocation/useRequestDeviceLocation.ts

···
-import {useCallback} from 'react'
-import * as Location from 'expo-location'
-
-import {type DeviceLocation} from '#/state/geolocation/types'
-import {getDeviceGeolocation} from '#/state/geolocation/util'
-
-export {PermissionStatus} from 'expo-location'
-
-export function useRequestDeviceLocation(): () => Promise<
-  | {
-      granted: true
-      location: DeviceLocation | undefined
-    }
-  | {
-      granted: false
-      status: {
-        canAskAgain: boolean
-        /**
-         * Enum, use `PermissionStatus` export for comparisons
-         */
-        permissionStatus: Location.PermissionStatus
-      }
-    }
-> {
-  return useCallback(async () => {
-    const status = await Location.requestForegroundPermissionsAsync()
-
-    if (status.granted) {
-      return {
-        granted: true,
-        location: await getDeviceGeolocation(),
-      }
-    } else {
-      return {
-        granted: false,
-        status: {
-          canAskAgain: status.canAskAgain,
-          permissionStatus: status.status,
-        },
-      }
-    }
-  }, [])
-}

src/state/geolocation/useSyncedDeviceGeolocation.ts

···
-import {useEffect, useRef} from 'react'
-import * as Location from 'expo-location'
-import {createPermissionHook} from 'expo-modules-core'
-
-import {logger} from '#/state/geolocation/logger'
-import {getDeviceGeolocation} from '#/state/geolocation/util'
-import {device, useStorage} from '#/storage'
-
-/**
- * Location.useForegroundPermissions on web just errors if the navigator.permissions API is not available.
- * We need to catch and ignore it, since it's effectively denied.
- * @see https://github.com/expo/expo/blob/72f1562ed9cce5ff6dfe04aa415b71632a3d4b87/packages/expo-location/src/Location.ts#L290-L293
- */
-const useForegroundPermissions = createPermissionHook({
-  getMethod: () =>
-    Location.getForegroundPermissionsAsync().catch(error => {
-      logger.debug(
-        'useForegroundPermission: error getting location permissions',
-        {safeMessage: error},
-      )
-      return {
-        status: Location.PermissionStatus.DENIED,
-        granted: false,
-        canAskAgain: false,
-        expires: 0,
-      }
-    }),
-  requestMethod: () =>
-    Location.requestForegroundPermissionsAsync().catch(error => {
-      logger.debug(
-        'useForegroundPermission: error requesting location permissions',
-        {safeMessage: error},
-      )
-      return {
-        status: Location.PermissionStatus.DENIED,
-        granted: false,
-        canAskAgain: false,
-        expires: 0,
-      }
-    }),
-})
-
-/**
- * Hook to get and sync the device geolocation from the device GPS and store it
- * using device storage. If permissions are not granted, it will clear any cached
- * storage value.
- */
-export function useSyncedDeviceGeolocation() {
-  const synced = useRef(false)
-  const [status] = useForegroundPermissions()
-  const [deviceGeolocation, setDeviceGeolocation] = useStorage(device, [
-    'deviceGeolocation',
-  ])
-
-  useEffect(() => {
-    async function get() {
-      // no need to set this more than once per session
-      if (synced.current) return
-
-      logger.debug('useSyncedDeviceGeolocation: checking perms')
-
-      if (status?.granted) {
-        const location = await getDeviceGeolocation()
-        if (location) {
-          logger.debug('useSyncedDeviceGeolocation: syncing location')
-          setDeviceGeolocation(location)
-          synced.current = true
-        }
-      } else {
-        const hasCachedValue = device.get(['deviceGeolocation']) !== undefined
-
-        /**
-         * If we have a cached value, but user has revoked permissions,
-         * quietly (will take effect lazily) clear this out.
-         */
-        if (hasCachedValue) {
-          logger.debug(
-            'useSyncedDeviceGeolocation: clearing cached location, perms revoked',
-          )
-          device.set(['deviceGeolocation'], undefined)
-        }
-      }
-    }
-
-    get().catch(e => {
-      logger.error('useSyncedDeviceGeolocation: failed to sync', {
-        safeMessage: e,
-      })
-    })
-  }, [status, setDeviceGeolocation])
-
-  return [deviceGeolocation, setDeviceGeolocation] as const
-}

src/state/geolocation/util.ts

···
-import {
-  getCurrentPositionAsync,
-  type LocationGeocodedAddress,
-  reverseGeocodeAsync,
-} from 'expo-location'
-
-import {logger} from '#/state/geolocation/logger'
-import {type DeviceLocation} from '#/state/geolocation/types'
-import {type Device} from '#/storage'
-
-/**
- * Maps full US region names to their short codes.
- *
- * Context: in some cases, like on Android, we get the full region name instead
- * of the short code. We may need to expand this in the future to other
- * countries, hence the prefix.
- */
-export const USRegionNameToRegionCode: {
-  [regionName: string]: string
-} = {
-  Alabama: 'AL',
-  Alaska: 'AK',
-  Arizona: 'AZ',
-  Arkansas: 'AR',
-  California: 'CA',
-  Colorado: 'CO',
-  Connecticut: 'CT',
-  Delaware: 'DE',
-  Florida: 'FL',
-  Georgia: 'GA',
-  Hawaii: 'HI',
-  Idaho: 'ID',
-  Illinois: 'IL',
-  Indiana: 'IN',
-  Iowa: 'IA',
-  Kansas: 'KS',
-  Kentucky: 'KY',
-  Louisiana: 'LA',
-  Maine: 'ME',
-  Maryland: 'MD',
-  Massachusetts: 'MA',
-  Michigan: 'MI',
-  Minnesota: 'MN',
-  Mississippi: 'MS',
-  Missouri: 'MO',
-  Montana: 'MT',
-  Nebraska: 'NE',
-  Nevada: 'NV',
-  ['New Hampshire']: 'NH',
-  ['New Jersey']: 'NJ',
-  ['New Mexico']: 'NM',
-  ['New York']: 'NY',
-  ['North Carolina']: 'NC',
-  ['North Dakota']: 'ND',
-  Ohio: 'OH',
-  Oklahoma: 'OK',
-  Oregon: 'OR',
-  Pennsylvania: 'PA',
-  ['Rhode Island']: 'RI',
-  ['South Carolina']: 'SC',
-  ['South Dakota']: 'SD',
-  Tennessee: 'TN',
-  Texas: 'TX',
-  Utah: 'UT',
-  Vermont: 'VT',
-  Virginia: 'VA',
-  Washington: 'WA',
-  ['West Virginia']: 'WV',
-  Wisconsin: 'WI',
-  Wyoming: 'WY',
-}
-
-/**
- * Normalizes a `LocationGeocodedAddress` into a `DeviceLocation`.
- *
- * We don't want or care about the full location data, so we trim it down and
- * normalize certain fields, like region, into the format we need.
- */
-export function normalizeDeviceLocation(
-  location: LocationGeocodedAddress,
-): DeviceLocation {
-  let {isoCountryCode, region} = location
-
-  if (region) {
-    if (isoCountryCode === 'US') {
-      region = USRegionNameToRegionCode[region] ?? region
-    }
-  }
-
-  return {
-    countryCode: isoCountryCode ?? undefined,
-    regionCode: region ?? undefined,
-  }
-}
-
-/**
- * Combines precise location data with the geolocation config fetched from the
- * IP service, with preference to the precise data.
- */
-export function mergeGeolocation(
-  location?: DeviceLocation,
-  config?: Device['geolocation'],
-): DeviceLocation {
-  if (location?.countryCode) return location
-  return {
-    countryCode: config?.countryCode,
-    regionCode: config?.regionCode,
-  }
-}
-
-/**
- * Computes the geolocation status (age-restricted, age-blocked) based on the
- * given location and geolocation config. `location` here should be merged with
- * `mergeGeolocation()` ahead of time if needed.
- */
-export function computeGeolocationStatus(
-  location: DeviceLocation,
-  config: Device['geolocation'],
-) {
-  /**
-   * We can't do anything if we don't have this data.
-   */
-  if (!location.countryCode) {
-    return {
-      ...location,
-      isAgeRestrictedGeo: false,
-      isAgeBlockedGeo: false,
-    }
-  }
-
-  const isAgeRestrictedGeo = config?.ageRestrictedGeos?.some(rule => {
-    if (rule.countryCode === location.countryCode) {
-      if (!rule.regionCode) {
-        return true // whole country is blocked
-      } else if (rule.regionCode === location.regionCode) {
-        return true
-      }
-    }
-  })
-
-  const isAgeBlockedGeo = config?.ageBlockedGeos?.some(rule => {
-    if (rule.countryCode === location.countryCode) {
-      if (!rule.regionCode) {
-        return true // whole country is blocked
-      } else if (rule.regionCode === location.regionCode) {
-        return true
-      }
-    }
-  })
-
-  return {
-    ...location,
-    isAgeRestrictedGeo: !!isAgeRestrictedGeo,
-    isAgeBlockedGeo: !!isAgeBlockedGeo,
-  }
-}
-
-export async function getDeviceGeolocation(): Promise<DeviceLocation> {
-  try {
-    const geocode = await getCurrentPositionAsync()
-    const locations = await reverseGeocodeAsync({
-      latitude: geocode.coords.latitude,
-      longitude: geocode.coords.longitude,
-    })
-    const location = locations.at(0)
-    const normalized = location ? normalizeDeviceLocation(location) : undefined
-    return {
-      countryCode: normalized?.countryCode ?? undefined,
-      regionCode: normalized?.regionCode ?? undefined,
-    }
-  } catch (e) {
-    logger.error('getDeviceGeolocation: failed', {
-      safeMessage: e,
-    })
-    return {
-      countryCode: undefined,
-      regionCode: undefined,
-    }
-  }
-}

src/state/queries/post-feed.ts

···
 import {FeedTuner, type FeedTunerFn} from '#/lib/api/feed-manip'
 import {DISCOVER_FEED_URI} from '#/lib/constants'
 import {logger} from '#/logger'
-import {useAgeAssuranceContext} from '#/state/ageAssurance'
 import {STALE} from '#/state/queries'
 import {DEFAULT_LOGGED_OUT_PREFERENCES} from '#/state/queries/preferences/const'
 import {useAgent} from '#/state/session'
···
    * available for the remainder of the session, so this delay only affects cold
    * loads. -esb
    */
-  const {isReady: isAgeAssuranceReady} = useAgeAssuranceContext()
   const enabled =
-    opts?.enabled !== false &&
-    Boolean(moderationOpts) &&
-    Boolean(preferences) &&
-    isAgeAssuranceReady
+    opts?.enabled !== false && Boolean(moderationOpts) && Boolean(preferences)
   const userInterests = aggregateUserInterests(preferences)
   const followingPinnedIndex =
     preferences?.savedFeeds?.findIndex(

src/state/queries/post.ts

···
         const res = await agent.resolveHandle({
           handle: urip.host,
         })
+        // @ts-expect-error TODO new-sdk-migration
         urip.host = res.data.did
       }
 
···
             const res = await agent.resolveHandle({
               handle: urip.host,
             })
+            // @ts-expect-error TODO new-sdk-migration
             urip.host = res.data.did
           }
 

src/state/queries/postgate/index.ts

···
     const res = await agent.resolveHandle({
       handle: urip.host,
     })
+    // @ts-expect-error TODO new-sdk-migration
     urip.host = res.data.did
   }
 

src/state/queries/preferences/index.ts

···
 import {replaceEqualDeep} from '#/lib/functions'
 import {getAge} from '#/lib/strings/time'
 import {logger} from '#/logger'
-import {useAgeAssuranceContext} from '#/state/ageAssurance'
-import {makeAgeRestrictedModerationPrefs} from '#/state/ageAssurance/const'
 import {STALE} from '#/state/queries'
 import {
   DEFAULT_HOME_FEED_PREFS,
···
 } from '#/state/queries/preferences/types'
 import {useAgent} from '#/state/session'
 import {saveLabelers} from '#/state/session/agent-config'
+import {useAgeAssurance} from '#/ageAssurance'
 
 export * from '#/state/queries/preferences/const'
 export * from '#/state/queries/preferences/moderation'
···
 
 export function usePreferencesQuery() {
   const agent = useAgent()
-  const {isAgeRestricted} = useAgeAssuranceContext()
+  const aa = useAgeAssurance()
 
   return useQuery({
     staleTime: STALE.SECONDS.FIFTEEN,
···
     },
     select: useCallback(
       (data: UsePreferencesQueryResponse) => {
-        const isUnderage = (data.userAge || 0) < 18
-        if (isUnderage || isAgeRestricted) {
+        /**
+         * Prefs are all downstream of age assurance now. For logged-out
+         * users, we override moderation prefs based on AA state.
+         */
+        if (aa.state.access !== aa.Access.Full) {
           data = {
             ...data,
-            moderationPrefs: makeAgeRestrictedModerationPrefs(
-              data.moderationPrefs,
-            ),
+            moderationPrefs: DEFAULT_LOGGED_OUT_PREFERENCES.moderationPrefs,
           }
         }
         return data
       },
-      [isAgeRestricted],
+      [aa],
     ),
   })
 }
···
   return useMutation<void, unknown, {enabled: boolean}>({
     mutationFn: async ({enabled}) => {
       await agent.setAdultContentEnabled(enabled)
-      // triggers a refetch
-      await queryClient.invalidateQueries({
-        queryKey: preferencesQueryKey,
-      })
-    },
-  })
-}
-
-export function usePreferencesSetBirthDateMutation() {
-  const queryClient = useQueryClient()
-  const agent = useAgent()
-
-  return useMutation<void, unknown, {birthDate: Date}>({
-    mutationFn: async ({birthDate}: {birthDate: Date}) => {
-      await agent.setPersonalDetails({birthDate: birthDate.toISOString()})
       // triggers a refetch
       await queryClient.invalidateQueries({
         queryKey: preferencesQueryKey,

src/state/queries/resolve-uri.ts

···
   const urip = new AtUri(uri || '')
   const res = useResolveDidQuery(urip.host)
   if (res.data) {
+    // @ts-expect-error TODO new-sdk-migration
     urip.host = res.data
     return {
       ...res,

src/state/queries/threadgate/index.ts

···
     const res = await agent.resolveHandle({
       handle: urip.host,
     })
+    // @ts-expect-error TODO new-sdk-migration
     urip.host = res.data.did
   }
 

src/state/session/__tests__/session-test.ts

···
   },
 }))
 
+jest.mock('../../birthdate')
+jest.mock('../../../ageAssurance/data')
+
 describe('session', () => {
   it('can log in and out', () => {
     let state = getInitialState([])

src/state/session/agent.ts

···
 import {
   Agent as BaseAgent,
+  type AppBskyActorProfile,
   type AtprotoServiceType,
   type AtpSessionData,
   type AtpSessionEvent,
   BskyAgent,
   type Did,
+  type Un$Typed,
 } from '@atproto/api'
 import {type FetchHandler} from '@atproto/api/dist/agent'
 import {type SessionManager} from '@atproto/api/dist/session-manager'
···
 import {tryFetchGates} from '#/lib/statsig/statsig'
 import {getAge} from '#/lib/strings/time'
 import {logger} from '#/logger'
+import {snoozeBirthdateUpdateAllowedForDid} from '#/state/birthdate'
 import {snoozeEmailConfirmationPrompt} from '#/state/shell/reminders'
+import {
+  prefetchAgeAssuranceData,
+  setBirthdateForDid,
+  setCreatedAtForDid,
+} from '#/ageAssurance/data'
 import {emitNetworkConfirmed, emitNetworkLost} from '../events'
 import {addSessionErrorLog} from './logging'
 import {
···
     }
   }
 
+  // after session is attached
+  const aa = prefetchAgeAssuranceData({agent})
+
   agent.configureProxy(BLUESKY_PROXY_HEADER.get())
 
-  return agent.prepare(gates, moderation, onSessionChange)
+  return agent.prepare({
+    resolvers: [gates, moderation, aa],
+    onSessionChange,
+  })
 }
 
 export async function createAgentAndLogin(
···
   const account = agentToSessionAccountOrThrow(agent)
   const gates = tryFetchGates(account.did, 'prefer-fresh-gates')
   const moderation = configureModerationForAccount(agent, account)
+  const aa = prefetchAgeAssuranceData({agent})
 
   agent.configureProxy(BLUESKY_PROXY_HEADER.get())
 
-  return agent.prepare(gates, moderation, onSessionChange)
+  return agent.prepare({
+    resolvers: [gates, moderation, aa],
+    onSessionChange,
+  })
 }
 
 export async function createAgentAndCreateAccount(
···
   const gates = tryFetchGates(account.did, 'prefer-fresh-gates')
   const moderation = configureModerationForAccount(agent, account)
 
+  const createdAt = new Date().toISOString()
+  const birthdate = birthDate.toISOString()
+
+  /*
+   * Since we have a race with account creation, profile creation, and AA
+   * state, set these values locally to ensure sync reads. Values are written
+   * to the server in the next step, so on subsequent reloads, the server will
+   * be the source of truth.
+   */
+  setCreatedAtForDid({did: account.did, createdAt})
+  setBirthdateForDid({did: account.did, birthdate})
+  snoozeBirthdateUpdateAllowedForDid(account.did)
+  // do this last
+  const aa = prefetchAgeAssuranceData({agent})
+
   // Not awaited so that we can still get into onboarding.
   // This is OK because we won't let you toggle adult stuff until you set the date.
   if (IS_PROD_SERVICE(service)) {
-    try {
-      networkRetry(1, async () => {
-        await agent.setPersonalDetails({birthDate: birthDate.toISOString()})
-        await agent.overwriteSavedFeeds([
-          {
-            ...DISCOVER_SAVED_FEED,
-            id: TID.nextStr(),
-          },
-          {
-            ...TIMELINE_SAVED_FEED,
-            id: TID.nextStr(),
-          },
-        ])
-
-        if (getAge(birthDate) < 18) {
-          await agent.api.com.atproto.repo.putRecord({
-            repo: account.did,
-            collection: 'chat.bsky.actor.declaration',
-            rkey: 'self',
-            record: {
-              $type: 'chat.bsky.actor.declaration',
-              allowIncoming: 'none',
+    Promise.allSettled(
+      [
+        networkRetry(3, () => {
+          return agent.setPersonalDetails({
+            birthDate: birthdate,
+          })
+        }).catch(e => {
+          logger.info(`createAgentAndCreateAccount: failed to set birthDate`)
+          throw e
+        }),
+        networkRetry(3, () => {
+          return agent.upsertProfile(prev => {
+            const next: Un$Typed<AppBskyActorProfile.Record> = prev || {}
+            next.displayName = handle
+            next.createdAt = createdAt
+            return next
+          })
+        }).catch(e => {
+          logger.info(
+            `createAgentAndCreateAccount: failed to set initial profile`,
+          )
+          throw e
+        }),
+        networkRetry(1, () => {
+          return agent.overwriteSavedFeeds([
+            {
+              ...DISCOVER_SAVED_FEED,
+              id: TID.nextStr(),
             },
+            {
+              ...TIMELINE_SAVED_FEED,
+              id: TID.nextStr(),
+            },
+          ])
+        }).catch(e => {
+          logger.info(
+            `createAgentAndCreateAccount: failed to set initial feeds`,
+          )
+          throw e
+        }),
+        getAge(birthDate) < 18 &&
+          networkRetry(3, () => {
+            return agent.com.atproto.repo.putRecord({
+              repo: account.did,
+              collection: 'chat.bsky.actor.declaration',
+              rkey: 'self',
+              record: {
+                $type: 'chat.bsky.actor.declaration',
+                allowIncoming: 'none',
+              },
+            })
+          }).catch(e => {
+            logger.info(
+              `createAgentAndCreateAccount: failed to set chat declaration`,
+            )
+            throw e
+          }),
+      ].filter(Boolean),
+    ).then(promises => {
+      const rejected = promises.filter(p => p.status === 'rejected')
+      if (rejected.length > 0) {
+        logger.error(
+          `session: createAgentAndCreateAccount failed to save personal details and feeds`,
+        )
+      }
+    })
+  } else {
+    Promise.allSettled(
+      [
+        networkRetry(3, () => {
+          return agent.setPersonalDetails({
+            birthDate: birthDate.toISOString(),
           })
-        }
-      })
-    } catch (e: any) {
-      logger.error(e, {
-        message: `session: createAgentAndCreateAccount failed to save personal details and feeds`,
-      })
-    }
-  } else {
-    agent.setPersonalDetails({birthDate: birthDate.toISOString()})
+        }).catch(e => {
+          logger.info(`createAgentAndCreateAccount: failed to set birthDate`)
+          throw e
+        }),
+        networkRetry(3, () => {
+          return agent.upsertProfile(prev => {
+            const next: Un$Typed<AppBskyActorProfile.Record> = prev || {}
+            next.createdAt = prev?.createdAt || new Date().toISOString()
+            return next
+          })
+        }).catch(e => {
+          logger.info(
+            `createAgentAndCreateAccount: failed to set initial profile`,
+          )
+          throw e
+        }),
+      ].filter(Boolean),
+    ).then(promises => {
+      const rejected = promises.filter(p => p.status === 'rejected')
+      if (rejected.length > 0) {
+        logger.error(
+          `session: createAgentAndCreateAccount failed to save personal details and feeds`,
+        )
+      }
+    })
   }
 
   try {
···
 
   agent.configureProxy(BLUESKY_PROXY_HEADER.get())
 
-  return agent.prepare(gates, moderation, onSessionChange)
+  return agent.prepare({
+    resolvers: [gates, moderation, aa],
+    onSessionChange,
+  })
 }
 
 export function agentToSessionAccountOrThrow(agent: BskyAgent): SessionAccount {
···
     })
   }
 
-  async prepare(
+  async prepare({
+    resolvers,
+    onSessionChange,
+  }: {
     // Not awaited in the calling code so we can delay blocking on them.
-    gates: Promise<void>,
-    moderation: Promise<void>,
+    resolvers: Promise<unknown>[]
     onSessionChange: (
       agent: BskyAgent,
       did: string,
       event: AtpSessionEvent,
-    ) => void,
-  ) {
+    ) => void
+  }) {
     // There's nothing else left to do, so block on them here.
-    await Promise.all([gates, moderation])
+    await Promise.all(resolvers)
 
     // Now the agent is ready.
     const account = agentToSessionAccountOrThrow(this)

src/state/session/index.tsx

···
   type SessionApiContext,
   type SessionStateContext,
 } from '#/state/session/types'
+import {useOnboardingDispatch} from '#/state/shell/onboarding'
+import {
+  clearAgeAssuranceData,
+  clearAgeAssuranceDataForDid,
+} from '#/ageAssurance/data'
 
 const StateContext = React.createContext<SessionStateContext>({
   accounts: [],
···
   const cancelPendingTask = useOneTaskAtATime()
   const [store] = React.useState(() => new SessionStore())
   const state = React.useSyncExternalStore(store.subscribe, store.getState)
+  const onboardingDispatch = useOnboardingDispatch()
 
   const onAgentSessionChange = React.useCallback(
     (agent: BskyAgent, accountDid: string, sessionEvent: AtpSessionEvent) => {
···
     logContext => {
       addSessionDebugLog({type: 'method:start', method: 'logout'})
       cancelPendingTask()
+      const prevState = store.getState()
       store.dispatch({
         type: 'logged-out-current-account',
       })
···
         {statsig: true},
       )
       addSessionDebugLog({type: 'method:end', method: 'logout'})
+      if (prevState.currentAgentState.did) {
+        clearAgeAssuranceDataForDid({did: prevState.currentAgentState.did})
+      }
+      // reset onboarding flow on logout
+      onboardingDispatch({type: 'skip'})
     },
-    [store, cancelPendingTask],
+    [store, cancelPendingTask, onboardingDispatch],
   )
 
   const logoutEveryAccount = React.useCallback<
···
         {statsig: true},
       )
       addSessionDebugLog({type: 'method:end', method: 'logout'})
+      clearAgeAssuranceData()
+      // reset onboarding flow on logout
+      onboardingDispatch({type: 'skip'})
     },
-    [store, cancelPendingTask],
+    [store, cancelPendingTask, onboardingDispatch],
   )
 
   const resumeSession = React.useCallback<SessionApiContext['resumeSession']>(
-    async storedAccount => {
+    async (storedAccount, isSwitchingAccounts = false) => {
       addSessionDebugLog({
         type: 'method:start',
         method: 'resumeSession',
···
         newAccount: account,
       })
       addSessionDebugLog({type: 'method:end', method: 'resumeSession', account})
+      if (isSwitchingAccounts) {
+        // reset onboarding flow on switch account
+        onboardingDispatch({type: 'skip'})
+      }
     },
-    [store, onAgentSessionChange, cancelPendingTask],
+    [store, onAgentSessionChange, cancelPendingTask, onboardingDispatch],
   )
 
   const partialRefreshSession = React.useCallback<
···
         accountDid: account.did,
       })
       addSessionDebugLog({type: 'method:end', method: 'removeAccount', account})
+      clearAgeAssuranceDataForDid({did: account.did})
     },
     [store, cancelPendingTask],
   )

src/state/session/types.ts

···
   logoutEveryAccount: (
     logContext: LogEvents['account:loggedOut']['logContext'],
   ) => void
-  resumeSession: (account: SessionAccount) => Promise<void>
+  resumeSession: (
+    account: SessionAccount,
+    isSwitchingAccounts?: boolean,
+  ) => Promise<void>
   removeAccount: (account: SessionAccount) => void
   /**
    * Calls `getSession` and updates select fields on the current account and

src/state/shell/index.tsx

···
 import {Provider as DrawerOpenProvider} from './drawer-open'
 import {Provider as DrawerSwipableProvider} from './drawer-swipe-disabled'
 import {Provider as MinimalModeProvider} from './minimal-mode'
-import {Provider as OnboardingProvider} from './onboarding'
 import {Provider as ShellLayoutProvder} from './shell-layout'
 import {Provider as TickEveryMinuteProvider} from './tick-every-minute'
 
···
         <DrawerSwipableProvider>
           <MinimalModeProvider>
             <ColorModeProvider>
-              <OnboardingProvider>
-                <TickEveryMinuteProvider>{children}</TickEveryMinuteProvider>
-              </OnboardingProvider>
+              <TickEveryMinuteProvider>{children}</TickEveryMinuteProvider>
             </ColorModeProvider>
           </MinimalModeProvider>
         </DrawerSwipableProvider>

src/state/unstable-post-source.tsx

···
  */
 export function buildPostSourceKey(key: string, handle: string) {
   const urip = new AtUri(key)
+  // @ts-expect-error TODO new-sdk-migration
   urip.host = handle
   return urip.toString()
 }

src/storage/schema.ts

···
 import {type ID as PolicyUpdate202508} from '#/components/PolicyUpdateOverlay/updates/202508/config'
+import {type Geolocation} from '#/geolocation/types'
 
 /**
  * Device data that's specific to the device and does not vary based account
···
       regionCode: string | undefined
     }[]
   }
+
+  /**
+   * The raw response from the geolocation service, if available. We
+   * cache this here and update it lazily on session start.
+   */
+  geolocationServiceResponse?: Geolocation
   /**
    * The GPS-based geolocation, if the user has granted permission.
    */
-  deviceGeolocation?: {
-    countryCode: string | undefined
-    regionCode: string | undefined
-  }
+  deviceGeolocation?: Geolocation
+  /**
+   * The merged geolocation, combining `geolocationServiceResponse` and
+   * `deviceGeolocation`, with preference to `deviceGeolocation`.
+   */
+  mergedGeolocation?: Geolocation
 
   trendingBetaEnabled: boolean
   devMode: boolean
···
 export type Account = {
   searchTermHistory?: string[]
   searchAccountHistory?: string[]
+
+  /**
+   * The ISO date string of when this account's birthdate was last updated on
+   * this device.
+   */
+  birthdateLastUpdatedAt?: string
 }

src/view/screens/Storybook/index.tsx

···
 import {useNavigation} from '@react-navigation/native'
 
 import {type NavigationProp} from '#/lib/routes/types'
-import {Sentry} from '#/logger/sentry/lib'
 import {useSetThemePrefs} from '#/state/shell'
 import {ListContained} from '#/view/screens/Storybook/ListContained'
 import {atoms as a, ThemeProvider} from '#/alf'
 import {Button, ButtonText} from '#/components/Button'
 import * as Layout from '#/components/Layout'
+import {
+  useDeviceGeolocationApi,
+  useRequestDeviceGeolocation,
+} from '#/geolocation'
 import {Admonitions} from './Admonitions'
 import {Breakpoints} from './Breakpoints'
 import {Buttons} from './Buttons'
···
   const {setColorMode, setDarkTheme} = useSetThemePrefs()
   const [showContainedList, setShowContainedList] = React.useState(false)
   const navigation = useNavigation<NavigationProp>()
+  const requestDeviceGeolocation = useRequestDeviceGeolocation()
+  const {setDeviceGeolocation} = useDeviceGeolocationApi()
 
   return (
     <>
···
               <ButtonText>Open Shared Prefs Tester</ButtonText>
             </Button>
             <Button
-              color="negative"
+              color="primary_subtle"
               size="large"
-              onPress={() => Sentry.nativeCrash()}
+              onPress={() =>
+                requestDeviceGeolocation().then(req => {
+                  if (req.granted && req.location) {
+                    setDeviceGeolocation(req.location)
+                  }
+                })
+              }
               label="crash">
-              <ButtonText>Sentry Crash</ButtonText>
+              <ButtonText>Get GPS Location</ButtonText>
             </Button>
 
             <ThemeProvider theme="light">

src/view/shell/index.tsx

···
 import {isStateAtTabRoot} from '#/lib/routes/helpers'
 import {isAndroid, isIOS} from '#/platform/detection'
 import {useDialogFullyExpandedCountContext} from '#/state/dialogs'
-import {useGeolocationStatus} from '#/state/geolocation'
 import {useSession} from '#/state/session'
 import {
   useIsDrawerOpen,
···
 import {atoms as a, select, useTheme} from '#/alf'
 import {setSystemUITheme} from '#/alf/util/systemUI'
 import {AgeAssuranceRedirectDialog} from '#/components/ageAssurance/AgeAssuranceRedirectDialog'
-import {BlockedGeoOverlay} from '#/components/BlockedGeoOverlay'
 import {EmailDialog} from '#/components/dialogs/EmailDialog'
 import {InAppBrowserConsentDialog} from '#/components/dialogs/InAppBrowserConsent'
 import {LinkWarningDialog} from '#/components/dialogs/LinkWarning'
···
   usePolicyUpdateContext,
 } from '#/components/PolicyUpdateOverlay'
 import {Outlet as PortalOutlet} from '#/components/Portal'
+import {useAgeAssurance} from '#/ageAssurance'
+import {NoAccessScreen} from '#/ageAssurance/components/NoAccessScreen'
+import {RedirectOverlay} from '#/ageAssurance/components/RedirectOverlay'
 import {RoutesContainer, TabsNavigator} from '#/Navigation'
 import {BottomSheetOutlet} from '../../../modules/bottom-sheet'
 import {updateActiveViewAsync} from '../../../modules/expo-bluesky-swiss-army/src/VisibilityView'
···
 
 export function Shell() {
   const t = useTheme()
-  const {status: geolocation} = useGeolocationStatus()
+  const aa = useAgeAssurance()
   const fullyExpandedCount = useDialogFullyExpandedCountContext()
 
   useIntentHandler()
···
           navigationBar: t.name !== 'light' ? 'light' : 'dark',
         }}
       />
-      {geolocation?.isAgeBlockedGeo ? (
-        <BlockedGeoOverlay />
+      {aa.state.access === aa.Access.None ? (
+        <NoAccessScreen />
       ) : (
         <RoutesContainer>
           <ShellInner />
         </RoutesContainer>
       )}
+
+      <RedirectOverlay />
     </View>
   )
 }

src/view/shell/index.web.tsx

···
 import {useIntentHandler} from '#/lib/hooks/useIntentHandler'
 import {useWebMediaQueries} from '#/lib/hooks/useWebMediaQueries'
 import {type NavigationProp} from '#/lib/routes/types'
-import {useGeolocationStatus} from '#/state/geolocation'
 import {useIsDrawerOpen, useSetDrawerOpen} from '#/state/shell'
 import {useComposerKeyboardShortcut} from '#/state/shell/composer/useComposerKeyboardShortcut'
 import {useCloseAllActiveElements} from '#/state/util'
···
 import {ErrorBoundary} from '#/view/com/util/ErrorBoundary'
 import {atoms as a, select, useTheme} from '#/alf'
 import {AgeAssuranceRedirectDialog} from '#/components/ageAssurance/AgeAssuranceRedirectDialog'
-import {BlockedGeoOverlay} from '#/components/BlockedGeoOverlay'
 import {EmailDialog} from '#/components/dialogs/EmailDialog'
 import {LinkWarningDialog} from '#/components/dialogs/LinkWarning'
 import {MutedWordsDialog} from '#/components/dialogs/MutedWords'
···
 } from '#/components/PolicyUpdateOverlay'
 import {Outlet as PortalOutlet} from '#/components/Portal'
 import {WelcomeModal} from '#/components/WelcomeModal'
+import {useAgeAssurance} from '#/ageAssurance'
+import {NoAccessScreen} from '#/ageAssurance/components/NoAccessScreen'
+import {RedirectOverlay} from '#/ageAssurance/components/RedirectOverlay'
 import {FlatNavigator, RoutesContainer} from '#/Navigation'
 import {Composer} from './Composer.web'
 import {DrawerContent} from './Drawer'
···
 
 export function Shell() {
   const t = useTheme()
-  const {status: geolocation} = useGeolocationStatus()
+  const aa = useAgeAssurance()
   return (
     <View style={[a.util_screen_outer, t.atoms.bg]}>
-      {geolocation?.isAgeBlockedGeo ? (
-        <BlockedGeoOverlay />
+      {aa.state.access === aa.Access.None ? (
+        <NoAccessScreen />
       ) : (
         <RoutesContainer>
           <ShellInner />
         </RoutesContainer>
       )}
+
+      <RedirectOverlay />
     </View>
   )
 }

web/index.html

···
         width: 100%;
       }
       #splash {
+        display: flex;
         position: fixed;
+        top: 0;
+        bottom: 0;
+        left: 0;
+        right: 0;
+        align-items: center;
+        justify-content: center;
+      }
+      #splash svg {
+        position: relative;
+        top: -50px;
         width: 100px;
-        left: 50%;
-        top: 50%;
-        transform: translateX(-50%) translateY(-50%) translateY(-50px);
       }
       /**
        * We need these styles to prevent shifting due to scrollbar show/hide on
···
     <div id="root">
       <div id="splash">
         <!-- Bluesky SVG -->
-        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 360 320"><path fill="#0085ff" d="M180 142c-16.3-31.7-60.7-90.8-102-120C38.5-5.9 23.4-1 13.5 3.4 2.1 8.6 0 26.2 0 36.5c0 10.4 5.7 84.8 9.4 97.2 12.2 41 55.7 55 95.7 50.5-58.7 8.6-110.8 30-42.4 106.1 75.1 77.9 103-16.7 117.3-64.6 14.3 48 30.8 139 116 64.6 64-64.6 17.6-97.5-41.1-106.1 40 4.4 83.5-9.5 95.7-50.5 3.7-12.4 9.4-86.8 9.4-97.2 0-10.3-2-27.9-13.5-33C336.5-1 321.5-6 282 22c-41.3 29.2-85.7 88.3-102 120Z"/></svg>
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 57"><path fill="#006AFF" d="M13.873 3.805C21.21 9.332 29.103 20.537 32 26.55v15.882c0-.338-.13.044-.41.867-1.512 4.456-7.418 21.847-20.923 7.944-7.111-7.32-3.819-14.64 9.125-16.85-7.405 1.264-15.73-.825-18.014-9.015C1.12 23.022 0 8.51 0 6.55 0-3.268 8.579-.182 13.873 3.805ZM50.127 3.805C42.79 9.332 34.897 20.537 32 26.55v15.882c0-.338.13.044.41.867 1.512 4.456 7.418 21.847 20.923 7.944 7.111-7.32 3.819-14.64-9.125-16.85 7.405 1.264 15.73-.825 18.014-9.015C62.88 23.022 64 8.51 64 6.55c0-9.818-8.578-6.732-13.873-2.745Z"/></svg>
       </div>
     </div>
   </body>

yarn.lock

···
     tlds "^1.234.0"
     zod "^3.23.8"
 
-"@atproto/api@^0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@atproto/api/-/api-0.18.0.tgz#d8c54ddc4521d915f0af238a4bfebd119e18197f"
-  integrity sha512-2GxKPhhvMocDjRU7VpNj+cvCdmCHVAmRwyfNgRLMrJtPZvrosFoi9VATX+7eKN0FZvYvy8KdLSkCcpP2owH3IA==
+"@atproto/api@^0.18.4":
+  version "0.18.4"
+  resolved "https://registry.yarnpkg.com/@atproto/api/-/api-0.18.4.tgz#e6742f3b81acec2bcf63dd3787304166eb2891cb"
+  integrity sha512-+kSxto/GRFXRFFlGwfERrwEKnC6OqTgK34BUToer/Fv08q4WMR+GYPRabbWlnDoJWu3owcQfeYdcblQ88vi16g==
   dependencies:
-    "@atproto/common-web" "^0.4.3"
-    "@atproto/lexicon" "^0.5.1"
-    "@atproto/syntax" "^0.4.1"
-    "@atproto/xrpc" "^0.7.5"
+    "@atproto/common-web" "^0.4.6"
+    "@atproto/lexicon" "^0.5.2"
+    "@atproto/syntax" "^0.4.2"
+    "@atproto/xrpc" "^0.7.6"
     await-lock "^2.2.2"
     multiformats "^9.9.0"
     tlds "^1.234.0"
···
     uint8arrays "3.0.0"
     zod "^3.23.8"
 
+"@atproto/common-web@^0.4.4", "@atproto/common-web@^0.4.6":
+  version "0.4.6"
+  resolved "https://registry.yarnpkg.com/@atproto/common-web/-/common-web-0.4.6.tgz#e32395d44d812610fd99f718b8644308b828d68b"
+  integrity sha512-+2mG/1oBcB/ZmYIU1ltrFMIiuy9aByKAkb2Fos/0eTdczcLBaH17k0KoxMGvhfsujN2r62XlanOAMzysa7lv1g==
+  dependencies:
+    "@atproto/lex-data" "0.0.2"
+    "@atproto/lex-json" "0.0.2"
+    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"
···
     multiformats "^9.9.0"
     zod "^3.23.8"
 
+"@atproto/lex-data@0.0.2":
+  version "0.0.2"
+  resolved "https://registry.yarnpkg.com/@atproto/lex-data/-/lex-data-0.0.2.tgz#f90e7ac52dd6056199a84efc7a3c5196de7ceb63"
+  integrity sha512-euV2rDGi+coH8qvZOU+ieUOEbwPwff9ca6IiXIqjZJ76AvlIpj7vtAyIRCxHUW2BoU6h9yqyJgn9MKD2a7oIwg==
+  dependencies:
+    "@atproto/syntax" "0.4.2"
+    multiformats "^9.9.0"
+    tslib "^2.8.1"
+    uint8arrays "3.0.0"
+    unicode-segmenter "^0.14.0"
+
+"@atproto/lex-json@0.0.2":
+  version "0.0.2"
+  resolved "https://registry.yarnpkg.com/@atproto/lex-json/-/lex-json-0.0.2.tgz#c4d3b6a8e965898cbc80478ecd461ddd8ac38493"
+  integrity sha512-Pd72lO+l2rhOTutnf11omh9ZkoB/elbzE3HSmn2wuZlyH1mRhTYvoH8BOGokWQwbZkCE8LL3nOqMT3gHCD2l7g==
+  dependencies:
+    "@atproto/lex-data" "0.0.2"
+    tslib "^2.8.1"
+
 "@atproto/lexicon-resolver@0.2.2", "@atproto/lexicon-resolver@^0.2.2":
   version "0.2.2"
   resolved "https://registry.yarnpkg.com/@atproto/lexicon-resolver/-/lexicon-resolver-0.2.2.tgz#2a91a1908f6b327c41cb5c290eb80aed5ef593c0"
···
   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"
+    zod "^3.23.8"
+
+"@atproto/lexicon@^0.5.2":
+  version "0.5.2"
+  resolved "https://registry.yarnpkg.com/@atproto/lexicon/-/lexicon-0.5.2.tgz#c2fb39b952644c9d88203850e0d61a26b39338ec"
+  integrity sha512-lRmJgMA8f5j7VB5Iu5cp188ald5FuI4FlmZ7nn6EBrk1dgOstWVrI5Ft6K3z2vjyLZRG6nzknlsw+tDP63p7bQ==
+  dependencies:
+    "@atproto/common-web" "^0.4.4"
     "@atproto/syntax" "^0.4.1"
     iso-datestring-validator "^2.2.2"
     multiformats "^9.9.0"
···
   resolved "https://registry.yarnpkg.com/@atproto/syntax/-/syntax-0.4.1.tgz#f77bc610ae0914449ff3f4731861e3da429915f5"
   integrity sha512-CJdImtLAiFO+0z3BWTtxwk6aY5w4t8orHTMVJgkf++QRJWTxPbIFko/0hrkADB7n2EruDxDSeAgfUGehpH6ngw==
 
+"@atproto/syntax@0.4.2", "@atproto/syntax@^0.4.2":
+  version "0.4.2"
+  resolved "https://registry.yarnpkg.com/@atproto/syntax/-/syntax-0.4.2.tgz#a83ff62b82bf84308d78ad836c802bad6a52174a"
+  integrity sha512-X9XSRPinBy/0VQ677j8VXlBsYSsUXaiqxWVpGGxJYsAhugdQRb0jqaVKJFtm6RskeNkV6y9xclSUi9UYG/COrA==
+
 "@atproto/xrpc-server@^0.9.5":
   version "0.9.5"
   resolved "https://registry.yarnpkg.com/@atproto/xrpc-server/-/xrpc-server-0.9.5.tgz#3a036ce2db85bcac40103fd160fef3ed7c364e2b"
···
   integrity sha512-MUYNn5d2hv8yVegRL0ccHvTHAVj5JSnW07bkbiaz96UH45lvYNRVwt44z+yYVnb0/mvBzyD3/ZQ55TRGt7fHkA==
   dependencies:
     "@atproto/lexicon" "^0.5.1"
+    zod "^3.23.8"
+
+"@atproto/xrpc@^0.7.6":
+  version "0.7.6"
+  resolved "https://registry.yarnpkg.com/@atproto/xrpc/-/xrpc-0.7.6.tgz#bc12b0e37f81fa76589691634d4fac9774fd0cb5"
+  integrity sha512-RvCf4j0JnKYWuz3QzsYCntJi3VuiAAybQsMIUw2wLWcHhchO9F7UaBZINLL2z0qc/cYWPv5NSwcVydMseoCZLA==
+  dependencies:
+    "@atproto/lexicon" "^0.5.2"
     zod "^3.23.8"
 
 "@aws-crypto/crc32@5.2.0":
···
   resolved "https://registry.yarnpkg.com/@tanstack/query-core/-/query-core-5.25.0.tgz#e08ed0a9fad34c8005d1a282e57280031ac50cdc"
   integrity sha512-vlobHP64HTuSE68lWF1mEhwSRC5Q7gaT+a/m9S+ItuN+ruSOxe1rFnR9j0ACWQ314BPhBEVKfBQ6mHL0OWfdbQ==
 
-"@tanstack/query-core@5.8.1":
-  version "5.8.1"
-  resolved "https://registry.yarnpkg.com/@tanstack/query-core/-/query-core-5.8.1.tgz#5215a028370d9b2f32e83787a0ea119e2f977996"
-  integrity sha512-Y0enatz2zQXBAsd7XmajlCs+WaitdR7dIFkqz9Xd7HL4KV04JOigWVreYseTmNH7YFSBSC/BJ9uuNp1MAf+GfA==
-
 "@tanstack/query-persist-client-core@5.25.0":
   version "5.25.0"
   resolved "https://registry.yarnpkg.com/@tanstack/query-persist-client-core/-/query-persist-client-core-5.25.0.tgz#52fa634a8067d7b965854a532a33077fd4df0eff"
···
   dependencies:
     "@tanstack/query-persist-client-core" "5.25.0"
 
-"@tanstack/react-query@^5.8.1":
-  version "5.8.1"
-  resolved "https://registry.yarnpkg.com/@tanstack/react-query/-/react-query-5.8.1.tgz#22a122016e23a39acd90341954a895980ec21ade"
-  integrity sha512-YMagxS8iNPOLg0pK6WOjdSDlAvWKOf69udLOwQrBVmkC2SRLNLko7elo5Ro3ptlJkXvTVHidxC/h5KGi5bH1XQ==
+"@tanstack/react-query@5.25.0":
+  version "5.25.0"
+  resolved "https://registry.yarnpkg.com/@tanstack/react-query/-/react-query-5.25.0.tgz#f4dac794cf10dd956aa56dbbdf67049a5ba2669d"
+  integrity sha512-u+n5R7mLO7RmeiIonpaCRVXNRWtZEef/aVZ/XGWRPa7trBIvGtzlfo0Ah7ZtnTYfrKEVwnZ/tzRCBcoiqJ/tFw==
   dependencies:
-    "@tanstack/query-core" "5.8.1"
+    "@tanstack/query-core" "5.25.0"
 
 "@testing-library/jest-native@^5.4.3":
   version "5.4.3"
···
     minimist "^1.2.6"
     strip-bom "^3.0.0"
 
-tslib@2, tslib@^2.6.2:
+tslib@2, tslib@^2.6.2, tslib@^2.8.1:
   version "2.8.1"
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.8.1.tgz#612efe4ed235d567e8aba5f2a5fab70280ade83f"
   integrity sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==
···
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.1.0.tgz#43d41e3be698bd493ef911077c9b131f827e8ccd"
   integrity sha512-6t3foTQI9qne+OZoVQB/8x8rk2k1eVy1gRXhV3oFQ5T6R1dqQ1xtin3XqSlx3+ATBkliTaR/hHyJBm+LVPNM8w==
+
+unicode-segmenter@^0.14.0:
+  version "0.14.0"
+  resolved "https://registry.yarnpkg.com/unicode-segmenter/-/unicode-segmenter-0.14.0.tgz#090128182bcc710327a1b7e4af4f5834444eaa61"
+  integrity sha512-AH4lhPCJANUnSLEKnM4byboctePJzltF4xj8b+NbNiYeAkAXGh7px2K/4NANFp7dnr6+zB3e6HLu8Jj8SKyvYg==
 
 unimodules-app-loader@~6.0.7:
   version "6.0.7"