Develop

app.config.ts

@@ -82,7 +82,13 @@ export default ({ config }: ConfigContext): ExpoConfig => ({
       foregroundImage: './assets/adaptive-icon.png',
       backgroundColor: '#2484c4',
     },
-    softwareKeyboardLayoutMode: 'pan',
+    // 'pan' makes Android scroll the window under the IME on its own, which fights
+    // react-native-keyboard-controller. Its hooks flip the activity to adjustResize on
+    // mount and call setDefaultMode() on unmount, restoring whatever this value is — so
+    // with 'pan' any closing sheet or modal drops the app back into pan mode and inputs
+    // end up under the keyboard. Edge-to-edge means the OS no longer resizes for us
+    // either, so 'resize' leaves keyboard avoidance entirely to the library.
+    softwareKeyboardLayoutMode: 'resize',
     package: Env.PACKAGE,
     googleServicesFile: 'google-services.json',
     // Register the ResgridUnit:// deep-link scheme so OIDC / SAML callbacks are routed back here
@@ -139,7 +145,10 @@ export default ({ config }: ConfigContext): ExpoConfig => ({
     [
       '@rnmapbox/maps',
       {
-        RNMapboxMapsVersion: '11.16.2',
+        // Keep in step with the `mapbox` field of the installed @rnmapbox/maps — the JS
+        // bindings are generated against a specific native SDK, and pinning an older one
+        // makes style props the bindings emit (symbolZOffset and friends) trap natively.
+        RNMapboxMapsVersion: '11.23.1',
       },
     ],
     [

package.json

@@ -71,7 +71,7 @@
     "@notifee/react-native": "9.1.8",
     "@novu/react-native": "3.11.0",
     "@react-native-community/netinfo": "12.0.1",
-    "@rnmapbox/maps": "10.2.10",
+    "@rnmapbox/maps": "10.3.5",
     "@semantic-release/git": "10.0.1",
     "@sentry/react-native": "~8.20.0",
     "@shopify/flash-list": "2.0.2",

patches/@rnmapbox+maps+10.3.5.patch

@@ -0,0 +1,60 @@
+diff --git a/node_modules/@rnmapbox/maps/android/src/main/mapbox-v11-compat/v11/com/rnmapbox/rnmbx/v11compat/Location.kt b/node_modules/@rnmapbox/maps/android/src/main/mapbox-v11-compat/v11/com/rnmapbox/rnmbx/v11compat/Location.kt
+index 8cda49e..05cbf87 100644
+--- a/node_modules/@rnmapbox/maps/android/src/main/mapbox-v11-compat/v11/com/rnmapbox/rnmbx/v11compat/Location.kt
++++ b/node_modules/@rnmapbox/maps/android/src/main/mapbox-v11-compat/v11/com/rnmapbox/rnmbx/v11compat/Location.kt
+@@ -73,17 +73,50 @@ fun LocationEngine.requestLocationUpdatesV11(callback: LocationEngineCallback, l
+     }
+   }
+   val observer = LocationObserverAdapter(callback)
++  // Publish into `observers` *before* registering with the provider, and pin the provider we
++  // register on. A concurrent `removeLocationUpdates` (same two threads described below) that
++  // lands between the two steps would otherwise never see this observer and would leave it
++  // registered — feeding location updates to a callback the caller already tore down, on a
++  // provider instance the request refresh above may have replaced. Registration itself stays
++  // outside the monitor: no Mapbox SDK call is ever made while holding it.
++  val provider = locationProvider
++  synchronized(observers) {
++    observers.add(observer)
++  }
+   if (looper != null) {
+-    locationProvider.addLocationObserver(observer, looper)
++    provider.addLocationObserver(observer, looper)
+   } else {
+-    locationProvider.addLocationObserver(observer)
++    provider.addLocationObserver(observer)
++  }
++  // Gone from the list means a removal ran while we were registering, and its
++  // `removeLocationObserver` hit a provider that did not know this observer yet. Undo here.
++  val canceled = synchronized(observers) { !observers.contains(observer) }
++  if (canceled) {
++    provider.removeLocationObserver(observer)
+   }
+-  observers.add(observer)
+ }
+
++// `observers` is reached from more than one thread: LocationManager.enable() runs on the
++// main thread when the activity resumes, and again on the React native-modules thread when
++// RNMBXLocationModule.start()/setMinDisplacement() land. Unsynchronized, the two overlap
++// inside Kotlin's `removeAll { }` (filterInPlace), whose trailing `removeAt(readIndex)`
++// walks indices captured before the other thread shrank the list — IndexOutOfBoundsException
++// "Index 0 out of bounds for length 0", crashing the app on foreground.
++//
++// Guard both mutations, and match on identity via a plain collection so `filterInPlace`
++// is not involved at all. `removeLocationObserver` runs outside the lock: it calls into the
++// Mapbox SDK and must not be holding our monitor while it does.
++//
++// Dropping an observer from the list is also the cancel signal for a registration still
++// in flight on the other thread — see `requestLocationUpdatesV11`, which re-checks
++// membership after registering and unregisters itself if it was pulled out meanwhile.
+ fun LocationEngine.removeLocationUpdates(callback: LocationEngineCallback) {
+-  observers.filter { it.callback == callback }.forEach { locationProvider.removeLocationObserver(it) }
+-  observers.removeAll { it.callback == callback }
++  val stale = synchronized(observers) {
++    val matched = observers.filter { it.callback == callback }
++    observers.removeAll(matched.toSet())
++    matched
++  }
++  stale.forEach { locationProvider.removeLocationObserver(it) }
+ }
+
+ fun LocationEngine.getLastLocation(callback: LocationEngineCallback) {

patches/react-native-webview+13.16.1.patch

@@ -0,0 +1,71 @@
+diff --git a/node_modules/react-native-webview/apple/RNCWebViewDecisionManager.m b/node_modules/react-native-webview/apple/RNCWebViewDecisionManager.m
+index aa90548..0c99c73 100644
+--- a/node_modules/react-native-webview/apple/RNCWebViewDecisionManager.m
++++ b/node_modules/react-native-webview/apple/RNCWebViewDecisionManager.m
+@@ -1,7 +1,15 @@
+ #import "RNCWebViewDecisionManager.h"
+
+-
+-
++/**
++ * Thread-safe singleton that manages navigation decision handlers for WKWebView.
++ *
++ * This class bridges async navigation decisions between:
++ * - WKWebView delegate (main thread) - stores decision handlers
++ * - React Native bridge (background thread) - resolves decisions from JS
++ *
++ * All public methods use @synchronized for thread safety since they access
++ * shared state (nextLockIdentifier and decisionHandlers) from different threads.
++ */
+ @implementation RNCWebViewDecisionManager
+
+ @synthesize nextLockIdentifier;
+@@ -16,22 +24,39 @@
+     return lockManager;
+ }
+
++/**
++ * Stores a decision handler and returns a unique identifier.
++ * Called from the main thread (WKNavigationDelegate).
++ * @synchronized ensures atomic increment + insertion.
++ */
+ - (int)setDecisionHandler:(DecisionBlock)decisionHandler {
+-    int lockIdentifier = self.nextLockIdentifier++;
+-
+-    [self.decisionHandlers setObject:decisionHandler forKey:@(lockIdentifier)];
+-    return lockIdentifier;
++    @synchronized (self) {
++        int lockIdentifier = self.nextLockIdentifier++;
++        [self.decisionHandlers setObject:decisionHandler forKey:@(lockIdentifier)];
++        return lockIdentifier;
++    }
+ }
+
++/**
++ * Resolves a pending navigation decision.
++ * Called from the RN bridge thread (background) when JS responds.
++ *
++ * The handler is invoked OUTSIDE the @synchronized block to prevent deadlocks,
++ * since the handler dispatches to the main queue and could potentially
++ * trigger another navigation that re-enters this class.
++ */
+ - (void) setResult:(BOOL)shouldStart
+  forLockIdentifier:(int)lockIdentifier {
+-    DecisionBlock handler = [self.decisionHandlers objectForKey:@(lockIdentifier)];
+-    if (handler == nil) {
+-        RCTLogWarn(@"Lock not found");
+-        return;
++    DecisionBlock handler;
++    @synchronized (self) {
++        handler = [self.decisionHandlers objectForKey:@(lockIdentifier)];
++        if (handler == nil) {
++            RCTLogWarn(@"Lock not found");
++            return;
++        }
++        [self.decisionHandlers removeObjectForKey:@(lockIdentifier)];
+     }
+     handler(shouldStart);
+-    [self.decisionHandlers removeObjectForKey:@(lockIdentifier)];
+ }
+
+ - (id)init {

src/components/__tests__/react-native-webview-patch.test.ts

@@ -0,0 +1,32 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Guards `patches/react-native-webview+13.16.1.patch`.
+ *
+ * `RNCWebViewDecisionManager` is a process-wide singleton whose `decisionHandlers`
+ * dictionary is written from the main thread (`WKNavigationDelegate` storing a handler)
+ * and read from a bridge worker thread (`shouldStartLoadWithLockIdentifier` resolving one
+ * from JS). Unsynchronized, a lookup could probe buckets while the dictionary rehashed and
+ * send `isEqual:` to a freed key — `EXC_BAD_ACCESS ... KERN_INVALID_ADDRESS`, which crashed
+ * the app when a WebView screen was torn down mid-navigation.
+ *
+ * Upstream fixed this in 14.0.1, but Expo SDK 56 pins react-native-webview to exactly
+ * 13.16.1, so the fix is backported verbatim rather than taken by upgrade.
+ * Losing the patch — to a `yarn install`, or to an Expo bump that lands a version still
+ * carrying the race — brings the crash straight back.
+ */
+describe('react-native-webview decision manager patch', () => {
+  const source = readFileSync(join(process.cwd(), 'node_modules/react-native-webview/apple/RNCWebViewDecisionManager.m'), 'utf8');
+
+  it('serialises access to the shared decision handler map', () => {
+    expect(source).toContain('@synchronized (self)');
+    // Both entry points must hold the lock, not just the reader.
+    expect(source.match(/@synchronized \(self\)/g)).toHaveLength(2);
+  });
+
+  it('invokes the handler outside the lock so a re-entrant navigation cannot deadlock', () => {
+    // The entry is removed inside the lock, then the closing brace, then the call.
+    expect(source).toMatch(/removeObjectForKey:@\(lockIdentifier\)\];\s*\}\s*handler\(shouldStart\);/);
+  });
+});

src/components/calls/dispatch-selection-modal.tsx

@@ -128,7 +128,7 @@ export const DispatchSelectionModal: React.FC<DispatchSelectionModalProps> = ({
             <TouchableOpacity onPress={toggleEveryone}>
               <HStack className="items-center space-x-3">
                 <Box className={`size-6 items-center justify-center rounded border-2 ${selection.everyone ? 'border-blue-500 bg-blue-500' : colorScheme === 'dark' ? 'border-neutral-600' : 'border-neutral-300'}`}>
-                  {selection.everyone && <CheckIcon size={16} className="text-white" />}
+                  {selection.everyone ? <CheckIcon size={16} className="text-white" /> : null}
                 </Box>
                 <VStack className="flex-1">
                   <Text className="pl-4 text-lg font-semibold">{t('calls.everyone')}</Text>
@@ -153,7 +153,7 @@ export const DispatchSelectionModal: React.FC<DispatchSelectionModalProps> = ({
                           selection.users.includes(user.Id) ? 'border-blue-500 bg-blue-500' : colorScheme === 'dark' ? 'border-neutral-600' : 'border-neutral-300'
                         }`}
                       >
-                        {selection.users.includes(user.Id) && <CheckIcon size={12} className="text-white" />}
+                        {selection.users.includes(user.Id) ? <CheckIcon size={12} className="text-white" /> : null}
                       </Box>
                       <VStack className="flex-1">
                         <Text className="pl-4 font-medium">{user.Name}</Text>
@@ -180,7 +180,7 @@ export const DispatchSelectionModal: React.FC<DispatchSelectionModalProps> = ({
                           selection.groups.includes(group.Id) ? 'border-blue-500 bg-blue-500' : colorScheme === 'dark' ? 'border-neutral-600' : 'border-neutral-300'
                         }`}
                       >
-                        {selection.groups.includes(group.Id) && <CheckIcon size={12} className="text-white" />}
+                        {selection.groups.includes(group.Id) ? <CheckIcon size={12} className="text-white" /> : null}
                       </Box>
                       <VStack className="flex-1">
                         <Text className="pl-4 font-medium">{group.Name}</Text>
@@ -207,7 +207,7 @@ export const DispatchSelectionModal: React.FC<DispatchSelectionModalProps> = ({
                           selection.roles.includes(role.Id) ? 'border-blue-500 bg-blue-500' : colorScheme === 'dark' ? 'border-neutral-600' : 'border-neutral-300'
                         }`}
                       >
-                        {selection.roles.includes(role.Id) && <CheckIcon size={12} className="text-white" />}
+                        {selection.roles.includes(role.Id) ? <CheckIcon size={12} className="text-white" /> : null}
                       </Box>
                       <VStack className="flex-1">
                         <Text className="pl-4 font-medium">{role.Name}</Text>
@@ -234,7 +234,7 @@ export const DispatchSelectionModal: React.FC<DispatchSelectionModalProps> = ({
                           selection.units.includes(unit.Id) ? 'border-blue-500 bg-blue-500' : colorScheme === 'dark' ? 'border-neutral-600' : 'border-neutral-300'
                         }`}
                       >
-                        {selection.units.includes(unit.Id) && <CheckIcon size={12} className="text-white" />}
+                        {selection.units.includes(unit.Id) ? <CheckIcon size={12} className="text-white" /> : null}
                       </Box>
                       <VStack className="flex-1">
                         <Text className="pl-4 font-medium">{unit.Name}</Text>

src/components/chat/new-conversation-sheet.tsx

@@ -19,6 +19,7 @@ import { VStack } from '@/components/ui/vstack';
 import { logger } from '@/lib/logging';
 import { getAvatarUrl } from '@/lib/utils';
 import { type RecipientsResultData } from '@/models/v4/messages/recipientsResultData';
+import useAuthStore from '@/stores/auth/store';
 import { useToastStore } from '@/stores/toast/store';
 
 interface NewConversationSheetProps {
@@ -38,8 +39,14 @@ function isPersonRecipient(recipient: RecipientsResultData): boolean {
   return type === 'personnel' || type === 'person' || type === 'user' || type === 'p' || type === '';
 }
 
+/** The server rejects self-DMs, so the current user never belongs in the picker. */
+function isSelfRecipient(recipient: RecipientsResultData, currentUserId: string | null): boolean {
+  return !!currentUserId && recipientUserId(recipient).toLowerCase() === currentUserId.toLowerCase();
+}
+
 export function NewConversationSheet({ isOpen, onClose, mode, onCreated }: NewConversationSheetProps) {
   const { t } = useTranslation();
+  const currentUserId = useAuthStore((s) => s.userId);
   const [recipients, setRecipients] = useState<RecipientsResultData[]>([]);
   const [loading, setLoading] = useState(false);
   const [loadError, setLoadError] = useState(false);
@@ -59,7 +66,7 @@ export function NewConversationSheet({ isOpen, onClose, mode, onCreated }: NewCo
     getRecipients(true, false)
       .then((result) => {
         if (cancelled) return;
-        setRecipients((result.Data ?? []).filter(isPersonRecipient));
+        setRecipients((result.Data ?? []).filter((r) => isPersonRecipient(r) && !isSelfRecipient(r, currentUserId)));
       })
       .catch((error) => {
         if (cancelled) return;
@@ -73,7 +80,7 @@ export function NewConversationSheet({ isOpen, onClose, mode, onCreated }: NewCo
     return () => {
       cancelled = true;
     };
-  }, [isOpen]);
+  }, [isOpen, currentUserId]);
 
   const filtered = useMemo(() => {
     const q = query.trim().toLowerCase();

src/components/maps/__tests__/rnmapbox-version-floor.test.ts

@@ -0,0 +1,51 @@
+import mapboxPackage from '@rnmapbox/maps/package.json';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+describe('@rnmapbox/maps version floor', () => {
+  /**
+   * 10.2.x `AnimatedPoint` assigned `this._listeners = {}` in its constructor. It extends
+   * React Native's `AnimatedWithChildren`, and `AnimatedNode` owns that field — on RN 0.85
+   * it is a `Map`, so the plain object broke `AnimatedNode.__callListeners`, which calls
+   * `this._listeners.forEach(...)`.
+   *
+   * `Mapbox.UserLocation` defaults to `animated`, so every location update on a screen with
+   * a map ran `AnimatedPoint.timing().start()` and the first frame threw
+   * `TypeError: undefined is not a function`, taking the app down (seen in Responder,
+   * reproduced on the call detail screen). 10.3.0 guards the assignment; dropping below that
+   * brings the crash straight back.
+   */
+  it('is at least 10.3.0, where the AnimatedPoint listener clobber was fixed', () => {
+    const [major, minor] = mapboxPackage.version.split('.').map(Number);
+
+    expect(major).toBeGreaterThanOrEqual(10);
+    expect(major > 10 || minor >= 3).toBe(true);
+  });
+
+  /**
+   * The JS bindings are generated against a specific native SDK. Pinning an older one in the
+   * Expo plugin leaves style props the bindings emit (`symbolZOffset`) unimplemented
+   * natively, which traps in `RNMBXStyle.symbolLayer` on iOS.
+   */
+  it('pins the same native Mapbox SDK the installed bindings target', () => {
+    const appConfig = readFileSync(join(process.cwd(), 'app.config.ts'), 'utf8');
+    const pinned = /RNMapboxMapsVersion:\s*'([^']+)'/.exec(appConfig)?.[1];
+
+    expect(pinned).toBe(mapboxPackage.mapbox.android);
+  });
+
+  /**
+   * Guards `patches/@rnmapbox+maps+10.3.5.patch`. Upstream's `LocationEngine.observers` is a
+   * plain list mutated from both the main thread (activity resume) and the React
+   * native-modules thread (`RNMBXLocationModule.start`). The overlap lands inside Kotlin's
+   * `removeAll { }` and throws `IndexOutOfBoundsException: Index 0 out of bounds for
+   * length 0`, killing the app as it foregrounds. A `yarn install`
+   * that drops the patch brings the crash back, so assert on the installed source.
+   */
+  it('keeps the LocationEngine observer list guarded against concurrent mutation', () => {
+    const locationKt = readFileSync(join(process.cwd(), 'node_modules/@rnmapbox/maps/android/src/main/mapbox-v11-compat/v11/com/rnmapbox/rnmbx/v11compat/Location.kt'), 'utf8');
+
+    expect(locationKt).toContain('synchronized(observers)');
+    expect(locationKt).not.toMatch(/observers\.removeAll\s*\{/);
+  });
+});