refactor: resolve multi-select strategy by file extension instead of a runtime check

Addresses the CONSISTENCY-1 review note: rather than branching on Platform.OS === 'ios'
inside the component, extract the concurrent/sequential strategy into a platform-resolved
processAssets helper (concurrent.ts default, sequential.ts on iOS via index.ios.ts). The
component just calls processAssets(assets, processAsset) and lets the bundler pick the
implementation. Adds unit tests covering both strategies.

Author: dilshodmackbook-sketch

src/components/AttachmentPicker/index.native.tsx

@@ -3,7 +3,7 @@ import {keepLocalCopy, pick, types} from '@react-native-documents/picker';
 import {Str} from 'expensify-common';
 import {ImageManipulator, SaveFormat} from 'expo-image-manipulator';
 import React, {useCallback, useMemo, useRef, useState} from 'react';
-import {Alert, Platform, View} from 'react-native';
+import {Alert, View} from 'react-native';
 import RNFetchBlob from 'react-native-blob-util';
 import {launchImageLibrary} from 'react-native-image-picker';
 import type {Asset, Callback, CameraOptions, ImageLibraryOptions, ImagePickerResponse} from 'react-native-image-picker';
@@ -26,6 +26,7 @@ import type {TranslationPaths} from '@src/languages/types';
 import type {FileObject, ImagePickerResponse as FileResponse} from '@src/types/utils/Attachment';
 import type IconAsset from '@src/types/utils/IconAsset';
 import launchCamera from './launchCamera/launchCamera';
+import processAssets from './processAssets';
 import type AttachmentPickerProps from './types';
 
 const EXTENSION_TO_NATIVE_TYPE: Record<string, string> = {
@@ -259,24 +260,11 @@ function AttachmentPicker({
                         }
                     };
 
-                    // Each HEIC asset is decoded to a full native bitmap during conversion. On iOS HybridApp the
-                    // process shares a single jetsam budget with OldDot, so converting the whole selection at once can
-                    // allocate N large bitmaps simultaneously and OOM. There we process assets one at a time to keep at
-                    // most one heavy decode alive; other platforms keep the original concurrent behavior (per #93846).
-                    const processAssets = async () => {
-                        if (Platform.OS === 'ios') {
-                            for (const asset of assets) {
-                                // eslint-disable-next-line no-await-in-loop
-                                await processAsset(asset);
-                            }
-                        } else {
-                            await Promise.all(assets.map(processAsset));
-                        }
-
-                        resolve(processedAssets.length > 0 ? processedAssets : undefined);
-                    };
-
-                    processAssets().catch(reject);
+                    // `processAssets` is resolved by file extension: sequential on iOS to avoid OOMing on
+                    // concurrent HEIC decodes (see processAssets/index.ios.ts), concurrent elsewhere (per #93846).
+                    processAssets(assets, processAsset)
+                        .then(() => resolve(processedAssets.length > 0 ? processedAssets : undefined))
+                        .catch(reject);
                 });
             }),
         [fileLimit, showGeneralAlert, translate, type],

src/components/AttachmentPicker/processAssets/concurrent.ts

@@ -0,0 +1,9 @@
+/**
+ * Processes the picked assets concurrently. This is the default strategy on every platform except iOS
+ * (see sequential.ts), where decoding the whole selection at once can exhaust the native memory budget.
+ */
+function processAssets<T>(assets: T[], processAsset: (asset: T) => Promise<void>): Promise<void> {
+    return Promise.all(assets.map(processAsset)).then(() => undefined);
+}
+
+export default processAssets;

src/components/AttachmentPicker/processAssets/index.ios.ts

@@ -0,0 +1,4 @@
+// iOS strategy: convert the multi-select sequentially so at most one heavy HEIC decode is alive at a time.
+import processAssets from './sequential';
+
+export default processAssets;

src/components/AttachmentPicker/processAssets/index.ts

@@ -0,0 +1,5 @@
+// Default (non-iOS) strategy: convert the whole multi-select concurrently. iOS overrides this with
+// sequential processing via index.ios.ts to avoid OOMing on simultaneous HEIC decodes.
+import processAssets from './concurrent';
+
+export default processAssets;

src/components/AttachmentPicker/processAssets/sequential.ts

@@ -0,0 +1,15 @@
+/**
+ * Processes the picked assets one at a time. Each HEIC asset decodes to a full native bitmap during
+ * conversion, and on iOS HybridApp the process shares a single jetsam memory budget with the resident OldDot,
+ * so converting the whole selection at once can allocate N large bitmaps simultaneously and OOM (Sentry
+ * APP-63S). Sequencing keeps at most one heavy decode alive at a time.
+ */
+async function processAssets<T>(assets: T[], processAsset: (asset: T) => Promise<void>): Promise<void> {
+    for (const asset of assets) {
+        // The sequencing is the whole point here: await each decode before starting the next.
+        // eslint-disable-next-line no-await-in-loop
+        await processAsset(asset);
+    }
+}
+
+export default processAssets;

tests/unit/AttachmentPickerProcessAssetsTest.ts

@@ -0,0 +1,85 @@
+import processAssetsConcurrent from '@components/AttachmentPicker/processAssets/concurrent';
+import processAssetsSequential from '@components/AttachmentPicker/processAssets/sequential';
+
+/** Lets every already-scheduled microtask run, so in-flight `processAsset` calls reach their parked state. */
+async function flushMicrotasks() {
+    for (let i = 0; i < 10; i++) {
+        await Promise.resolve();
+    }
+}
+
+function createDeferred() {
+    let resolve: () => void = () => {};
+    const promise = new Promise<void>((res) => {
+        resolve = res;
+    });
+    return {promise, resolve};
+}
+
+/**
+ * Tracks how many `processAsset` calls are in flight at once. Every call parks on a shared gate, so the peak
+ * concurrency is observable before the gate is released: a concurrent strategy reaches `items.length`, a
+ * sequential one never exceeds 1.
+ */
+function createConcurrencyTracker() {
+    const gate = createDeferred();
+    let running = 0;
+    let maxRunning = 0;
+    const processAsset = async (): Promise<void> => {
+        running += 1;
+        maxRunning = Math.max(maxRunning, running);
+        await gate.promise;
+        running -= 1;
+    };
+    return {processAsset, release: gate.resolve, getMaxRunning: () => maxRunning};
+}
+
+describe('AttachmentPicker processAssets', () => {
+    const items = ['a', 'b', 'c'];
+
+    describe('default (concurrent)', () => {
+        it('runs every asset at the same time', async () => {
+            const tracker = createConcurrencyTracker();
+
+            const done = processAssetsConcurrent(items, tracker.processAsset);
+            await flushMicrotasks();
+            expect(tracker.getMaxRunning()).toBe(items.length);
+
+            tracker.release();
+            await done;
+        });
+
+        it('processes every asset', async () => {
+            const processed: string[] = [];
+
+            await processAssetsConcurrent(items, async (item: string) => {
+                processed.push(item);
+            });
+
+            expect(processed).toEqual(items);
+        });
+    });
+
+    describe('iOS (sequential)', () => {
+        it('runs at most one asset at a time', async () => {
+            const tracker = createConcurrencyTracker();
+
+            const done = processAssetsSequential(items, tracker.processAsset);
+            await flushMicrotasks();
+            expect(tracker.getMaxRunning()).toBe(1);
+
+            tracker.release();
+            await done;
+        });
+
+        it('processes the assets in order', async () => {
+            const processed: string[] = [];
+
+            await processAssetsSequential(items, async (item: string) => {
+                processed.push(item);
+            });
+
+            expect(processed).toEqual(items);
+        });
+    });
+});