From be9b2b9bdb38a4884a776a63a253ba5161527de8 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Fri, 29 Aug 2025 11:02:05 +0200
Subject: [PATCH 01/31] refactor: migrate 'Add Attachment' flows to
 AttachmentModalScreen

---
 src/CONST/index.ts                            |  15 +-
 src/ROUTES.ts                                 |  26 +-
 src/SCREENS.ts                                |   1 +
 src/components/AttachmentComposerModal.tsx    | 304 ---------------
 src/components/Composer/types.ts              |   2 +-
 src/hooks/useFilesValidation.tsx              |  29 +-
 src/libs/AttachmentUtils.ts                   | 105 -----
 src/libs/AttachmentValidation.ts              | 172 ++++++++
 .../Navigation/AppNavigator/AuthScreens.tsx   |   6 +
 .../GetStateForActionHandlers.ts              |   1 +
 src/libs/Navigation/linkingConfig/config.ts   |   1 +
 src/libs/fileDownload/FileUtils.ts            |  30 +-
 .../AttachmentPickerWithMenuItems.tsx         |   8 +-
 .../ComposerWithSuggestions.tsx               |  10 +-
 .../ReportActionCompose.tsx                   | 223 +++++------
 .../AttachmentModalBaseContent/index.tsx      | 369 ++++++++++++++++++
 .../AttachmentModalBaseContent/types.ts       | 131 +++++++
 .../routes/hooks/useDownloadAttachment.ts     |  43 ++
 .../routes/hooks/useFileUploadValidation.ts   |  89 +++++
 .../hooks/useNavigateToReportOnRefresh.ts     |  30 ++
 .../hooks/useReportAttachmentModalType.ts     |  35 ++
 .../ReportAddAttachmentModalContent.tsx       | 254 ++++++++++++
 .../AttachmentModalScreen/routes/types.ts     |   8 +
 src/stories/Composer.stories.tsx              |   2 +-
 src/types/utils/Modify.ts                     |   6 +
 tests/unit/FileUtilsTest.ts                   |  10 +-
 26 files changed, 1333 insertions(+), 577 deletions(-)
 delete mode 100644 src/components/AttachmentComposerModal.tsx
 delete mode 100644 src/libs/AttachmentUtils.ts
 create mode 100644 src/libs/AttachmentValidation.ts
 create mode 100644 src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
 create mode 100644 src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts
 create mode 100644 src/pages/media/AttachmentModalScreen/routes/hooks/useDownloadAttachment.ts
 create mode 100644 src/pages/media/AttachmentModalScreen/routes/hooks/useFileUploadValidation.ts
 create mode 100644 src/pages/media/AttachmentModalScreen/routes/hooks/useNavigateToReportOnRefresh.ts
 create mode 100644 src/pages/media/AttachmentModalScreen/routes/hooks/useReportAttachmentModalType.ts
 create mode 100644 src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
 create mode 100644 src/pages/media/AttachmentModalScreen/routes/types.ts
 create mode 100644 src/types/utils/Modify.ts

diff --git a/src/CONST/index.ts b/src/CONST/index.ts
index 0ed5e3b21087..8976079f2912 100755
--- a/src/CONST/index.ts
+++ b/src/CONST/index.ts
@@ -1960,18 +1960,23 @@ const CONST = {
         VIDEO: /\.(mov|mp4)$/,
     },
 
-    FILE_VALIDATION_ERRORS: {
+    SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS: {
+        NO_FILE_PROVIDED: 'noFileProvided',
+        FILE_INVALID: 'fileInvalid',
         WRONG_FILE_TYPE: 'wrongFileType',
-        WRONG_FILE_TYPE_MULTIPLE: 'wrongFileTypeMultiple',
         FILE_TOO_LARGE: 'fileTooLarge',
-        FILE_TOO_LARGE_MULTIPLE: 'fileTooLargeMultiple',
         FILE_TOO_SMALL: 'fileTooSmall',
         FILE_CORRUPTED: 'fileCorrupted',
-        FOLDER_NOT_ALLOWED: 'folderNotAllowed',
-        MAX_FILE_LIMIT_EXCEEDED: 'fileLimitExceeded',
         PROTECTED_FILE: 'protectedFile',
     },
 
+    MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS: {
+        WRONG_FILE_TYPE: 'multipleAttachmentsWrongFileType',
+        FILE_TOO_LARGE: 'multipleAttachmentsFileTooLarge',
+        FOLDER_NOT_ALLOWED: 'multipleAttachmentsFolderNotAllowed',
+        MAX_FILE_LIMIT_EXCEEDED: 'multipleAttachmentsMaxFileLimitExceeded',
+    },
+
     IOS_CAMERA_ROLL_ACCESS_ERROR: 'Access to photo library was denied',
     ADD_PAYMENT_MENU_POSITION_Y: 226,
     ADD_PAYMENT_MENU_POSITION_X: 356,
diff --git a/src/ROUTES.ts b/src/ROUTES.ts
index 4a99f6e495a9..5b14d7ca518c 100644
--- a/src/ROUTES.ts
+++ b/src/ROUTES.ts
@@ -10,8 +10,8 @@ import type CONST from './CONST';
 import type {IOUAction, IOUType} from './CONST';
 import type {IOURequestType} from './libs/actions/IOU';
 import Log from './libs/Log';
+import type {RootNavigatorParamList} from './libs/Navigation/types';
 import type {ReimbursementAccountStepToOpen} from './libs/ReimbursementAccountUtils';
-import type {AttachmentModalScreenParams} from './pages/media/AttachmentModalScreen/types';
 import SCREENS from './SCREENS';
 import type {Screen} from './SCREENS';
 import type {ExitReason} from './types/form/ExitSurveyReasonForm';
@@ -450,6 +450,16 @@ const ROUTES = {
             return `r/${reportID}/avatar` as const;
         },
     },
+    ATTACHMENTS: {
+        route: 'attachment',
+        getRoute: (params?: ReportAttachmentsRouteParams) => getAttachmentModalScreenRoute('attachment', params),
+    },
+    REPORT_ADD_ATTACHMENT: {
+        route: 'r/:reportID/attachment/add',
+        getRoute: (reportID: string, params?: ReportAddAttachmentRouteParams) => {
+            return getAttachmentModalScreenRoute(`r/${reportID}/attachment/add`, params);
+        },
+    },
     EDIT_CURRENCY_REQUEST: {
         route: 'r/:threadReportID/edit/currency',
         getRoute: (threadReportID: string, currency: string, backTo: string) => `r/${threadReportID}/edit/currency?currency=${currency}&backTo=${backTo}` as const,
@@ -475,10 +485,6 @@ const ROUTES = {
             return getUrlWithBackToParam(`r/${reportID}/details/shareCode` as const, backTo);
         },
     },
-    ATTACHMENTS: {
-        route: 'attachment',
-        getRoute: (params?: AttachmentRouteParams) => getAttachmentModalScreenRoute('attachment', params),
-    },
     REPORT_PARTICIPANTS: {
         route: 'r/:reportID/participants',
         getRoute: (reportID: string, backTo?: string) => getUrlWithBackToParam(`r/${reportID}/participants` as const, backTo),
@@ -2781,12 +2787,14 @@ const SHARED_ROUTE_PARAMS: Partial<Record<Screen, string[]>> = {
 export {getUrlWithBackToParam, PUBLIC_SCREENS_ROUTES, SHARED_ROUTE_PARAMS};
 export default ROUTES;
 
-type AttachmentsRoute = typeof ROUTES.ATTACHMENTS.route;
+type ReportAttachmentsRoute = typeof ROUTES.ATTACHMENTS.route;
 type ReportAddAttachmentRoute = `r/${string}/attachment/add`;
-type AttachmentRoutes = AttachmentsRoute | ReportAddAttachmentRoute;
-type AttachmentRouteParams = AttachmentModalScreenParams;
+type AttachmentRoutes = ReportAttachmentsRoute | ReportAddAttachmentRoute;
+
+type ReportAttachmentsRouteParams = RootNavigatorParamList[typeof SCREENS.ATTACHMENTS];
+type ReportAddAttachmentRouteParams = RootNavigatorParamList[typeof SCREENS.REPORT_ADD_ATTACHMENT];
 
-function getAttachmentModalScreenRoute(url: AttachmentRoutes, params?: AttachmentRouteParams) {
+function getAttachmentModalScreenRoute(url: AttachmentRoutes, params?: ReportAttachmentsRouteParams | ReportAddAttachmentRouteParams) {
     if (!params?.source) {
         return url;
     }
diff --git a/src/SCREENS.ts b/src/SCREENS.ts
index 2ba5596eb591..d8648c4f7f47 100644
--- a/src/SCREENS.ts
+++ b/src/SCREENS.ts
@@ -8,6 +8,7 @@ const PROTECTED_SCREENS = {
     HOME: 'Home',
     CONCIERGE: 'Concierge',
     ATTACHMENTS: 'Attachments',
+    REPORT_ADD_ATTACHMENT: 'ReportAddAttachment',
     TRACK_EXPENSE: 'TrackExpense',
     SUBMIT_EXPENSE: 'SubmitExpense',
 } as const;
diff --git a/src/components/AttachmentComposerModal.tsx b/src/components/AttachmentComposerModal.tsx
deleted file mode 100644
index 8825746efdb7..000000000000
--- a/src/components/AttachmentComposerModal.tsx
+++ /dev/null
@@ -1,304 +0,0 @@
-import React, {memo, useCallback, useEffect, useRef, useState} from 'react';
-import type {View} from 'react-native';
-import {GestureHandlerRootView} from 'react-native-gesture-handler';
-import type {OnyxEntry} from 'react-native-onyx';
-import Animated, {FadeIn, LayoutAnimationConfig} from 'react-native-reanimated';
-import useFilesValidation from '@hooks/useFilesValidation';
-import useLocalize from '@hooks/useLocalize';
-import useResponsiveLayout from '@hooks/useResponsiveLayout';
-import useThemeStyles from '@hooks/useThemeStyles';
-import {cleanFileName} from '@libs/fileDownload/FileUtils';
-import CONST from '@src/CONST';
-import type * as OnyxTypes from '@src/types/onyx';
-import type ModalType from '@src/types/utils/ModalType';
-import viewRef from '@src/types/utils/viewRef';
-import AttachmentCarouselView from './Attachments/AttachmentCarousel/AttachmentCarouselView';
-import useCarouselArrows from './Attachments/AttachmentCarousel/useCarouselArrows';
-import useAttachmentErrors from './Attachments/AttachmentView/useAttachmentErrors';
-import type {Attachment} from './Attachments/types';
-import Button from './Button';
-import HeaderGap from './HeaderGap';
-import HeaderWithBackButton from './HeaderWithBackButton';
-import Modal from './Modal';
-import SafeAreaConsumer from './SafeAreaConsumer';
-
-type ImagePickerResponse = {
-    height?: number;
-    name: string;
-    size?: number | null;
-    type: string;
-    uri: string;
-    width?: number;
-};
-
-type FileObject = Partial<File | ImagePickerResponse>;
-
-type ChildrenProps = {
-    displayFilesInModal: (data: FileObject[], items?: DataTransferItem[]) => void;
-    show: () => void;
-};
-
-type AttachmentComposerModalProps = {
-    /** Optional callback to fire when we want to preview an image and approve it for use. */
-    onConfirm: ((file: FileObject | FileObject[]) => void) | null;
-
-    /** Title shown in the header of the modal */
-    headerTitle: string;
-
-    /** Optional callback to fire when we want to do something after modal show. */
-    onModalShow: () => void;
-
-    /** Optional callback to fire when we want to do something after modal hide. */
-    onModalHide: () => void;
-
-    /** A function as a child to pass modal launching methods to */
-    children: React.FC<ChildrenProps>;
-
-    /** Should disable send button */
-    shouldDisableSendButton: boolean;
-
-    /** The report currently being looked at */
-    report?: OnyxEntry<OnyxTypes.Report>;
-};
-
-function AttachmentComposerModal({onConfirm, onModalShow = () => {}, onModalHide = () => {}, headerTitle, children, shouldDisableSendButton = false, report}: AttachmentComposerModalProps) {
-    const styles = useThemeStyles();
-    const {translate} = useLocalize();
-    const {shouldUseNarrowLayout} = useResponsiveLayout();
-    const {setAttachmentError, clearAttachmentErrors} = useAttachmentErrors();
-    const {shouldShowArrows, setShouldShowArrows, autoHideArrows, cancelAutoHideArrows} = useCarouselArrows();
-
-    const [isModalOpen, setIsModalOpen] = useState(false);
-    const [modalType, setModalType] = useState<ModalType>(CONST.MODAL.MODAL_TYPE.CENTERED_UNSWIPEABLE);
-    const [validFilesToUpload, setValidFilesToUpload] = useState<FileObject[]>([]);
-    const [attachments, setAttachments] = useState<Attachment[]>([]);
-    const [page, setPage] = useState<number>(0);
-    const [currentAttachment, setCurrentAttachment] = useState<Attachment | null>(null);
-
-    /**
-     * If our attachment is a PDF, return the unswipeable Modal type.
-     */
-    const getModalType = useCallback(
-        (sourceURL: string, fileObject: FileObject) => {
-            const fileName = fileObject?.name ?? translate('attachmentView.unknownFilename');
-            return sourceURL && (sourceURL.includes('.pdf') || fileName.includes('.pdf')) ? CONST.MODAL.MODAL_TYPE.CENTERED_UNSWIPEABLE : CONST.MODAL.MODAL_TYPE.CENTERED;
-        },
-        [translate],
-    );
-
-    /**
-     * Execute the onConfirm callback and close the modal.
-     */
-    const submitAndClose = useCallback(() => {
-        // If the modal has already been closed
-        if (!isModalOpen) {
-            return;
-        }
-
-        if (onConfirm) {
-            if (validFilesToUpload.length) {
-                onConfirm(validFilesToUpload);
-            } else if (currentAttachment) {
-                onConfirm(currentAttachment.file ?? (currentAttachment as FileObject));
-            }
-        }
-
-        setIsModalOpen(false);
-    }, [isModalOpen, onConfirm, validFilesToUpload, currentAttachment]);
-
-    /**
-     * Sanitizes file names and ensures proper URI references for file system compatibility
-     */
-    const cleanFileObjectName = useCallback((fileObject: FileObject): FileObject => {
-        if (fileObject instanceof File) {
-            const cleanName = cleanFileName(fileObject.name);
-            if (fileObject.name !== cleanName) {
-                const updatedFile = new File([fileObject], cleanName, {type: fileObject.type});
-                const inputSource = URL.createObjectURL(updatedFile);
-                updatedFile.uri = inputSource;
-                return updatedFile;
-            }
-            if (!fileObject.uri) {
-                const inputSource = URL.createObjectURL(fileObject);
-                // eslint-disable-next-line no-param-reassign
-                fileObject.uri = inputSource;
-            }
-        }
-        return fileObject;
-    }, []);
-
-    const convertFileToAttachment = useCallback((fileObject: FileObject, source: string): Attachment => {
-        return {
-            source,
-            file: fileObject,
-        };
-    }, []);
-
-    useEffect(() => {
-        if (!validFilesToUpload.length) {
-            return;
-        }
-
-        if (validFilesToUpload.length > 0) {
-            // Convert all files to attachments
-            const newAttachments = validFilesToUpload.map((fileObject) => {
-                const source = fileObject.uri ?? '';
-                return convertFileToAttachment(fileObject, source);
-            });
-
-            const firstAttachment = newAttachments.at(0) ?? null;
-            setAttachments(newAttachments);
-            setCurrentAttachment(firstAttachment);
-            setPage(0);
-
-            if (firstAttachment?.file) {
-                const inputModalType = getModalType(firstAttachment.source as string, firstAttachment.file);
-                setModalType(inputModalType);
-            }
-
-            setIsModalOpen(true);
-        }
-    }, [validFilesToUpload, convertFileToAttachment, getModalType]);
-
-    const {ErrorModal, validateFiles, PDFValidationComponent} = useFilesValidation(setValidFilesToUpload, false);
-
-    const validateAndDisplayMultipleFilesToUpload = useCallback(
-        (data: FileObject[], items?: DataTransferItem[]) => {
-            if (!data?.length) {
-                return;
-            }
-
-            const validIndices: number[] = [];
-            const fileObjects = data
-                .map((item, index) => {
-                    let fileObject = item;
-                    if ('getAsFile' in item && typeof item.getAsFile === 'function') {
-                        fileObject = item.getAsFile() as FileObject;
-                    }
-                    const cleanedFileObject = cleanFileObjectName(fileObject);
-                    if (cleanedFileObject !== null) {
-                        validIndices.push(index);
-                    }
-                    return cleanedFileObject;
-                })
-                .filter((fileObject): fileObject is FileObject => fileObject !== null);
-
-            if (!fileObjects.length) {
-                return;
-            }
-
-            // Create a filtered items array that matches the fileObjects
-            const filteredItems = items && validIndices.length > 0 ? validIndices.map((index) => items.at(index) ?? ({} as DataTransferItem)) : undefined;
-
-            validateFiles(fileObjects, filteredItems);
-        },
-        [cleanFileObjectName, validateFiles],
-    );
-
-    const closeModal = useCallback(() => {
-        setIsModalOpen(false);
-    }, []);
-
-    const openModal = useCallback(() => {
-        setIsModalOpen(true);
-    }, []);
-
-    const headerTitleNew = headerTitle ?? translate('reportActionCompose.sendAttachment');
-
-    const submitRef = useRef<View | HTMLElement>(null);
-
-    return (
-        <>
-            {PDFValidationComponent}
-            <Modal
-                type={modalType}
-                onClose={closeModal}
-                isVisible={isModalOpen}
-                onModalShow={() => {
-                    onModalShow();
-                }}
-                onModalHide={() => {
-                    onModalHide();
-                    clearAttachmentErrors();
-                    setValidFilesToUpload([]);
-                    setAttachments([]);
-                    setCurrentAttachment(null);
-                    setPage(0);
-                }}
-                propagateSwipe
-                initialFocus={() => {
-                    if (!submitRef.current) {
-                        return false;
-                    }
-                    return submitRef.current;
-                }}
-                shouldHandleNavigationBack
-            >
-                <GestureHandlerRootView style={styles.flex1}>
-                    {shouldUseNarrowLayout && <HeaderGap />}
-                    <HeaderWithBackButton
-                        shouldMinimizeMenuButton
-                        title={headerTitleNew}
-                        shouldShowBorderBottom
-                        shouldShowCloseButton={!shouldUseNarrowLayout}
-                        shouldShowBackButton={shouldUseNarrowLayout}
-                        onBackButtonPress={closeModal}
-                        onCloseButtonPress={closeModal}
-                        shouldSetModalVisibility={false}
-                        shouldDisplayHelpButton={false}
-                    />
-                    {attachments.length > 0 && !!currentAttachment && (
-                        <AttachmentCarouselView
-                            attachments={attachments}
-                            source={currentAttachment.source}
-                            page={page}
-                            setPage={setPage}
-                            onClose={closeModal}
-                            autoHideArrows={autoHideArrows}
-                            cancelAutoHideArrow={cancelAutoHideArrows}
-                            setShouldShowArrows={setShouldShowArrows}
-                            onAttachmentError={setAttachmentError}
-                            shouldShowArrows={shouldShowArrows}
-                            report={report}
-                        />
-                    )}
-                    <LayoutAnimationConfig skipEntering>
-                        {(validFilesToUpload.length > 0 || !!currentAttachment) && (
-                            <SafeAreaConsumer>
-                                {({safeAreaPaddingBottomStyle}) => (
-                                    <Animated.View
-                                        style={safeAreaPaddingBottomStyle}
-                                        entering={FadeIn}
-                                    >
-                                        <Button
-                                            ref={viewRef(submitRef)}
-                                            success
-                                            large
-                                            style={[styles.buttonConfirm, shouldUseNarrowLayout ? {} : styles.attachmentButtonBigScreen]}
-                                            textStyles={[styles.buttonConfirmText]}
-                                            text={translate('common.send')}
-                                            onPress={submitAndClose}
-                                            isDisabled={shouldDisableSendButton}
-                                            pressOnEnter
-                                        />
-                                    </Animated.View>
-                                )}
-                            </SafeAreaConsumer>
-                        )}
-                    </LayoutAnimationConfig>
-                </GestureHandlerRootView>
-            </Modal>
-            {children?.({
-                displayFilesInModal: validateAndDisplayMultipleFilesToUpload,
-                show: openModal,
-            })}
-            {ErrorModal}
-        </>
-    );
-}
-
-AttachmentComposerModal.displayName = 'AttachmentComposerModal';
-
-export default memo(AttachmentComposerModal);
-
-export type {FileObject, ImagePickerResponse};
diff --git a/src/components/Composer/types.ts b/src/components/Composer/types.ts
index 7ecf77add492..74f4454d96c4 100644
--- a/src/components/Composer/types.ts
+++ b/src/components/Composer/types.ts
@@ -35,7 +35,7 @@ type ComposerProps = Omit<TextInputProps, 'onClear'> & {
     onChangeText?: (numberOfLines: string) => void;
 
     /** Callback method to handle pasting a file */
-    onPasteFile?: (file: FileObject) => void;
+    onPasteFile?: (files: FileObject | FileObject[]) => void;
 
     /** General styles to apply to the text input */
     // eslint-disable-next-line react/forbid-prop-types
diff --git a/src/hooks/useFilesValidation.tsx b/src/hooks/useFilesValidation.tsx
index d047edbb5031..7eeaab51944d 100644
--- a/src/hooks/useFilesValidation.tsx
+++ b/src/hooks/useFilesValidation.tsx
@@ -1,13 +1,12 @@
 import {Str} from 'expensify-common';
 import React, {useCallback, useRef, useState} from 'react';
 import {InteractionManager} from 'react-native';
-import type {ValueOf} from 'type-fest';
-import type {FileObject} from '@components/AttachmentModal';
 import ConfirmModal from '@components/ConfirmModal';
 import {useFullScreenLoader} from '@components/FullScreenLoaderContext';
 import PDFThumbnail from '@components/PDFThumbnail';
 import Text from '@components/Text';
 import TextLink from '@components/TextLink';
+import type {MultipleAttachmentsValidationError, SingleAttachmentValidationError} from '@libs/AttachmentValidation';
 import {
     getFileValidationErrorText,
     isHeicOrHeifImage,
@@ -18,12 +17,13 @@ import {
     validateImageForCorruption,
 } from '@libs/fileDownload/FileUtils';
 import convertHeicImage from '@libs/fileDownload/heicConverter';
+import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
 import CONST from '@src/CONST';
 import useLocalize from './useLocalize';
 import useThemeStyles from './useThemeStyles';
 
 type ErrorObject = {
-    error: ValueOf<typeof CONST.FILE_VALIDATION_ERRORS>;
+    error: SingleAttachmentValidationError | MultipleAttachmentsValidationError;
     fileExtension?: string;
 };
 
@@ -35,7 +35,7 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
     const styles = useThemeStyles();
     const {translate} = useLocalize();
     const [isErrorModalVisible, setIsErrorModalVisible] = useState(false);
-    const [fileError, setFileError] = useState<ValueOf<typeof CONST.FILE_VALIDATION_ERRORS> | null>(null);
+    const [fileError, setFileError] = useState<SingleAttachmentValidationError | MultipleAttachmentsValidationError>();
     const [pdfFilesToRender, setPdfFilesToRender] = useState<FileObject[]>([]);
     const [validFilesToUpload, setValidFilesToUpload] = useState([] as FileObject[]);
     const [isValidatingMultipleFiles, setIsValidatingMultipleFiles] = useState(false);
@@ -76,7 +76,7 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
         setIsLoaderVisible(false);
         setValidFilesToUpload([]);
         setIsValidatingMultipleFiles(false);
-        setFileError(null);
+        setFileError(undefined);
         setInvalidFileExtension('');
         setErrorQueue([]);
         setCurrentErrorIndex(0);
@@ -95,7 +95,7 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
         });
     }, [resetValidationState]);
 
-    const setErrorAndOpenModal = (error: ValueOf<typeof CONST.FILE_VALIDATION_ERRORS>) => {
+    const setErrorAndOpenModal = (error: SingleAttachmentValidationError | MultipleAttachmentsValidationError) => {
         setFileError(error);
         setIsErrorModalVisible(true);
     };
@@ -105,7 +105,7 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
             const entry = item.webkitGetAsEntry();
 
             if (entry?.isDirectory) {
-                collectedErrors.current.push({error: CONST.FILE_VALIDATION_ERRORS.FOLDER_NOT_ALLOWED});
+                collectedErrors.current.push({error: CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.FOLDER_NOT_ALLOWED});
                 return Promise.resolve(false);
             }
         }
@@ -117,7 +117,8 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
                     if (error) {
                         const errorData = {
                             error,
-                            fileExtension: error === CONST.FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE_MULTIPLE ? splitExtensionFromFileName(normalizedFile.name ?? '').fileExtension : undefined,
+                            fileExtension:
+                                error === CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.WRONG_FILE_TYPE ? splitExtensionFromFileName(normalizedFile.name ?? '').fileExtension : undefined,
                         };
                         collectedErrors.current.push(errorData);
                         return false;
@@ -126,7 +127,7 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
                 }),
             )
             .catch(() => {
-                collectedErrors.current.push({error: CONST.FILE_VALIDATION_ERRORS.FILE_CORRUPTED});
+                collectedErrors.current.push({error: CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_CORRUPTED});
                 return false;
             });
     };
@@ -273,14 +274,14 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
             if (items) {
                 dataTransferItemList.current = items.slice(0, CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT);
             }
-            setErrorAndOpenModal(CONST.FILE_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED);
+            setErrorAndOpenModal(CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED);
         } else {
             validateAndResizeFiles(files, items ?? []);
         }
     };
 
     const onConfirm = () => {
-        if (fileError === CONST.FILE_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED) {
+        if (fileError === CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED) {
             setIsErrorModalVisible(false);
             validateAndResizeFiles(filesToValidate.current, dataTransferItemList.current);
             return;
@@ -333,7 +334,7 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
                   onPassword={() => {
                       validatedPDFs.current.push(file);
                       if (isValidatingReceipts) {
-                          collectedErrors.current.push({error: CONST.FILE_VALIDATION_ERRORS.PROTECTED_FILE});
+                          collectedErrors.current.push({error: CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.PROTECTED_FILE});
                       } else {
                           validFiles.current.push(file);
                       }
@@ -341,7 +342,7 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
                   }}
                   onLoadError={() => {
                       validatedPDFs.current.push(file);
-                      collectedErrors.current.push({error: CONST.FILE_VALIDATION_ERRORS.FILE_CORRUPTED});
+                      collectedErrors.current.push({error: CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_CORRUPTED});
                       checkIfAllValidatedAndProceed();
                   }}
               />
@@ -353,7 +354,7 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
             return '';
         }
         const prompt = getFileValidationErrorText(fileError, {fileType: invalidFileExtension}, isValidatingReceipts).reason;
-        if (fileError === CONST.FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE_MULTIPLE || fileError === CONST.FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE) {
+        if (fileError === CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.WRONG_FILE_TYPE || fileError === CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE) {
             return (
                 <Text>
                     {prompt}
diff --git a/src/libs/AttachmentUtils.ts b/src/libs/AttachmentUtils.ts
deleted file mode 100644
index eea91499fa66..000000000000
--- a/src/libs/AttachmentUtils.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
-import CONST from '@src/CONST';
-import {cleanFileName, validateImageForCorruption} from './fileDownload/FileUtils';
-
-type AttachmentValidationError = CorruptionError | 'fileDoesNotExist' | 'fileInvalid';
-type ValidResult = {
-    isValid: true;
-    fileType: 'file' | 'uri';
-    source: string;
-    file: FileObject;
-};
-type InvalidResult = {
-    isValid: false;
-    error: AttachmentValidationError;
-};
-
-type AttachmentValidationResult = ValidResult | InvalidResult;
-
-function validateAttachmentFile(file: FileObject): Promise<AttachmentValidationResult> {
-    if (!file || !isDirectoryCheck(file)) {
-        return Promise.resolve({isValid: false, error: 'fileDoesNotExist'});
-    }
-
-    let fileObject = file;
-    if ('getAsFile' in file && typeof file.getAsFile === 'function') {
-        fileObject = file.getAsFile() as FileObject;
-    }
-    if (!fileObject) {
-        return Promise.resolve({isValid: false, error: 'fileInvalid'});
-    }
-
-    return isFileCorrupted(fileObject).then((corruptionResult) => {
-        if (!corruptionResult.isValid) {
-            return corruptionResult as InvalidResult;
-        }
-
-        if (fileObject instanceof File) {
-            /**
-             * Cleaning file name, done here so that it covers all cases:
-             * upload, drag and drop, copy-paste
-             */
-            let updatedFile = fileObject;
-            const cleanName = cleanFileName(updatedFile.name);
-            if (updatedFile.name !== cleanName) {
-                updatedFile = new File([updatedFile], cleanName, {type: updatedFile.type});
-            }
-            const inputSource = URL.createObjectURL(updatedFile);
-            updatedFile.uri = inputSource;
-
-            return {isValid: true, fileType: 'file', source: inputSource, file: updatedFile} as ValidResult;
-        }
-
-        return {isValid: true, fileType: 'uri', source: fileObject.uri, file: fileObject} as ValidResult;
-    });
-}
-
-type CorruptionError = 'tooLarge' | 'tooSmall' | 'error';
-type NoCorruptionResult = {
-    isValid: true;
-};
-type CorruptionResult = {
-    isValid: false;
-    error: CorruptionError;
-};
-type AttachmentCorruptionValidationResult = NoCorruptionResult | CorruptionResult;
-
-function isFileCorrupted(fileObject: FileObject): Promise<AttachmentCorruptionValidationResult> {
-    return validateImageForCorruption(fileObject)
-        .then(() => {
-            if (fileObject.size && fileObject.size > CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE) {
-                return {
-                    isValid: false,
-                    error: 'tooLarge',
-                } satisfies AttachmentCorruptionValidationResult;
-            }
-
-            if (fileObject.size && fileObject.size < CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE) {
-                return {
-                    isValid: false,
-                    error: 'tooSmall',
-                } satisfies AttachmentCorruptionValidationResult;
-            }
-
-            return {
-                isValid: true,
-            } satisfies AttachmentCorruptionValidationResult;
-        })
-        .catch(() => {
-            return {
-                isValid: false,
-                error: 'error',
-            };
-        });
-}
-
-function isDirectoryCheck(data: FileObject) {
-    if ('webkitGetAsEntry' in data && (data as DataTransferItem).webkitGetAsEntry()?.isDirectory) {
-        return false;
-    }
-
-    return true;
-}
-
-export default validateAttachmentFile;
-export type {AttachmentValidationResult};
diff --git a/src/libs/AttachmentValidation.ts b/src/libs/AttachmentValidation.ts
new file mode 100644
index 000000000000..d1aa53a384bd
--- /dev/null
+++ b/src/libs/AttachmentValidation.ts
@@ -0,0 +1,172 @@
+import type {ValueOf} from 'type-fest';
+import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
+import CONST from '@src/CONST';
+import {cleanFileName, normalizeFileObject, validateImageForCorruption} from './fileDownload/FileUtils';
+
+type ValidatedFile = {
+    fileType: 'file' | 'uri';
+    source: string;
+    file: FileObject;
+};
+
+type SingleAttachmentValidResult = {
+    isValid: true;
+    validatedFile: ValidatedFile;
+};
+
+type SingleAttachmentValidationError = ValueOf<typeof CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS>;
+type SingleAttachmentInvalidResult = {
+    isValid: false;
+    error: SingleAttachmentValidationError;
+};
+
+type SingleAttachmentValidationResult = SingleAttachmentValidResult | SingleAttachmentInvalidResult;
+
+function isSingleAttachmentValidationResult(result: unknown): result is SingleAttachmentValidationResult {
+    return typeof result === 'object' && result !== null && 'isValid' in result && typeof result.isValid === 'boolean' && ('validatedFile' in result || 'error' in result);
+}
+
+function validateAttachmentFile(file: FileObject): Promise<SingleAttachmentValidationResult> {
+    if (!file) {
+        return Promise.resolve({isValid: false, error: CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.NO_FILE_PROVIDED});
+    }
+
+    let fileObject = file;
+    if ('getAsFile' in file && typeof file.getAsFile === 'function') {
+        fileObject = file.getAsFile() as FileObject;
+    }
+    if (!fileObject) {
+        return Promise.resolve({isValid: false, error: CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_INVALID});
+    }
+
+    return isFileCorrupted(fileObject).then((corruptionResult) => {
+        if (!corruptionResult.isValid) {
+            return corruptionResult;
+        }
+
+        let validatedFile: ValidatedFile;
+
+        if (fileObject instanceof File) {
+            /**
+             * Cleaning file name, done here so that it covers all cases:
+             * upload, drag and drop, copy-paste
+             */
+            let updatedFile = fileObject;
+            const cleanName = cleanFileName(updatedFile.name);
+            if (updatedFile.name !== cleanName) {
+                updatedFile = new File([updatedFile], cleanName, {type: updatedFile.type});
+            }
+            const inputSource = URL.createObjectURL(updatedFile);
+            updatedFile.uri = inputSource;
+
+            validatedFile = {
+                fileType: 'file',
+                source: inputSource,
+                file: updatedFile,
+            };
+
+            return {isValid: true, validatedFile};
+        }
+
+        validatedFile = {
+            fileType: 'uri',
+            source: fileObject.uri ?? '',
+            file: fileObject,
+        };
+
+        return {isValid: true, validatedFile};
+    });
+}
+
+type MultipleAttachmentsValidResult = {
+    isValid: true;
+    validatedFiles: ValidatedFile[];
+};
+
+type MultipleAttachmentsValidationError = ValueOf<typeof CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS>;
+type MultipleAttachmentsInvalidResult = {
+    isValid: false;
+    error: MultipleAttachmentsValidationError;
+    fileResults: SingleAttachmentValidationResult[];
+};
+type MultipleAttachmentsValidationResult = MultipleAttachmentsValidResult | MultipleAttachmentsInvalidResult;
+
+function isMultipleAttachmentsValidationResult(result: unknown): result is MultipleAttachmentsValidationResult {
+    return typeof result === 'object' && result !== null && 'isValid' in result && typeof result.isValid === 'boolean' && ('validatedFiles' in result || 'fileResults' in result);
+}
+
+function validateMultipleAttachmentFiles(files: FileObject[]): Promise<MultipleAttachmentsValidationResult> {
+    if (!files?.length || files.some((f) => isDirectory(f))) {
+        return Promise.resolve({isValid: false, error: CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.FOLDER_NOT_ALLOWED, fileResults: []});
+    }
+
+    if (files.length > CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT) {
+        return Promise.resolve({isValid: false, error: CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED, fileResults: []});
+    }
+
+    return Promise.all(files.map((f) => validateAttachmentFile(f))).then((results) => {
+        if (results.every((result) => result.isValid)) {
+            return {
+                isValid: true,
+                validatedFiles: results.map((result) => result.validatedFile),
+            };
+        }
+
+        return {
+            isValid: false,
+            error: CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.WRONG_FILE_TYPE,
+            fileResults: results,
+        };
+    });
+}
+
+function isFileCorrupted(fileObject: FileObject): Promise<SingleAttachmentValidationResult> {
+    return normalizeFileObject(fileObject).then((normalizedFile) => {
+        return validateImageForCorruption(normalizedFile)
+            .then(() => {
+                if (normalizedFile.size && normalizedFile.size > CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE) {
+                    return {
+                        isValid: false,
+                        error: CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_LARGE,
+                    } as SingleAttachmentInvalidResult;
+                }
+
+                if (normalizedFile.size && normalizedFile.size < CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE) {
+                    return {
+                        isValid: false,
+                        error: CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_SMALL,
+                    } as SingleAttachmentInvalidResult;
+                }
+
+                return {
+                    isValid: true,
+                } as SingleAttachmentValidResult;
+            })
+            .catch(() => {
+                return {
+                    isValid: false,
+                    error: CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_INVALID,
+                } as SingleAttachmentInvalidResult;
+            });
+    });
+}
+
+function isDirectory(data: FileObject) {
+    if ('webkitGetAsEntry' in data && (data as DataTransferItem).webkitGetAsEntry()?.isDirectory) {
+        return true;
+    }
+
+    return false;
+}
+
+export {validateAttachmentFile, validateMultipleAttachmentFiles, isSingleAttachmentValidationResult, isMultipleAttachmentsValidationResult};
+export type {
+    SingleAttachmentValidationResult,
+    SingleAttachmentValidResult,
+    SingleAttachmentInvalidResult,
+    SingleAttachmentValidationError,
+    MultipleAttachmentsValidationResult,
+    MultipleAttachmentsValidResult,
+    MultipleAttachmentsInvalidResult,
+    MultipleAttachmentsValidationError,
+};
diff --git a/src/libs/Navigation/AppNavigator/AuthScreens.tsx b/src/libs/Navigation/AppNavigator/AuthScreens.tsx
index 13a6662c180d..21d4df1abf7d 100644
--- a/src/libs/Navigation/AppNavigator/AuthScreens.tsx
+++ b/src/libs/Navigation/AppNavigator/AuthScreens.tsx
@@ -555,6 +555,12 @@ function AuthScreens() {
                     getComponent={loadAttachmentModalScreen}
                     listeners={modalScreenListeners}
                 />
+                <RootStack.Screen
+                    name={SCREENS.REPORT_ADD_ATTACHMENT}
+                    options={attachmentModalScreenOptions}
+                    getComponent={loadAttachmentModalScreen}
+                    listeners={modalScreenListeners}
+                />
                 <RootStack.Screen
                     name={SCREENS.PROFILE_AVATAR}
                     options={{
diff --git a/src/libs/Navigation/AppNavigator/createRootStackNavigator/GetStateForActionHandlers.ts b/src/libs/Navigation/AppNavigator/createRootStackNavigator/GetStateForActionHandlers.ts
index a24f220e0328..a2a092d59c55 100644
--- a/src/libs/Navigation/AppNavigator/createRootStackNavigator/GetStateForActionHandlers.ts
+++ b/src/libs/Navigation/AppNavigator/createRootStackNavigator/GetStateForActionHandlers.ts
@@ -17,6 +17,7 @@ const MODAL_ROUTES_TO_DISMISS: string[] = [
     NAVIGATORS.TEST_DRIVE_MODAL_NAVIGATOR,
     SCREENS.NOT_FOUND,
     SCREENS.ATTACHMENTS,
+    SCREENS.REPORT_ADD_ATTACHMENT,
     SCREENS.TRANSACTION_RECEIPT,
     SCREENS.MONEY_REQUEST.RECEIPT_PREVIEW,
     SCREENS.PROFILE_AVATAR,
diff --git a/src/libs/Navigation/linkingConfig/config.ts b/src/libs/Navigation/linkingConfig/config.ts
index 18d5151393bb..6dd5e7308213 100644
--- a/src/libs/Navigation/linkingConfig/config.ts
+++ b/src/libs/Navigation/linkingConfig/config.ts
@@ -27,6 +27,7 @@ const config: LinkingOptions<RootNavigatorParamList>['config'] = {
         [SCREENS.SAML_SIGN_IN]: ROUTES.SAML_SIGN_IN,
         [SCREENS.DESKTOP_SIGN_IN_REDIRECT]: ROUTES.DESKTOP_SIGN_IN_REDIRECT,
         [SCREENS.ATTACHMENTS]: ROUTES.ATTACHMENTS.route,
+        [SCREENS.REPORT_ADD_ATTACHMENT]: ROUTES.REPORT_ADD_ATTACHMENT.route,
         [SCREENS.PROFILE_AVATAR]: ROUTES.PROFILE_AVATAR.route,
         [SCREENS.WORKSPACE_AVATAR]: ROUTES.WORKSPACE_AVATAR.route,
         [SCREENS.REPORT_AVATAR]: ROUTES.REPORT_AVATAR.route,
diff --git a/src/libs/fileDownload/FileUtils.ts b/src/libs/fileDownload/FileUtils.ts
index e0db610c6215..58625e279b7c 100644
--- a/src/libs/fileDownload/FileUtils.ts
+++ b/src/libs/fileDownload/FileUtils.ts
@@ -3,7 +3,8 @@ import {Alert, Linking, Platform} from 'react-native';
 import type {ReactNativeBlobUtilReadStream} from 'react-native-blob-util';
 import ReactNativeBlobUtil from 'react-native-blob-util';
 import ImageSize from 'react-native-image-size';
-import type {TupleToUnion, ValueOf} from 'type-fest';
+import type {TupleToUnion} from 'type-fest';
+import type {MultipleAttachmentsValidationError, SingleAttachmentValidationError} from '@libs/AttachmentValidation';
 import DateUtils from '@libs/DateUtils';
 import getPlatform from '@libs/getPlatform';
 import {translateLocal} from '@libs/Localize';
@@ -552,16 +553,17 @@ const normalizeFileObject = (file: FileObject): Promise<FileObject> => {
 
 const validateAttachment = (file: FileObject, isCheckingMultipleFiles?: boolean, isValidatingReceipt?: boolean) => {
     const maxFileSize = isValidatingReceipt ? CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE : CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE;
+
     if (!Str.isImage(file.name ?? '') && !isHeicOrHeifImage(file) && (file?.size ?? 0) > maxFileSize) {
-        return isCheckingMultipleFiles ? CONST.FILE_VALIDATION_ERRORS.FILE_TOO_LARGE_MULTIPLE : CONST.FILE_VALIDATION_ERRORS.FILE_TOO_LARGE;
+        return isCheckingMultipleFiles ? CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.FILE_TOO_LARGE : CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_LARGE;
     }
 
     if (isValidatingReceipt && (file?.size ?? 0) < CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE) {
-        return CONST.FILE_VALIDATION_ERRORS.FILE_TOO_SMALL;
+        return CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_SMALL;
     }
 
     if (isValidatingReceipt && !isValidReceiptExtension(file)) {
-        return isCheckingMultipleFiles ? CONST.FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE_MULTIPLE : CONST.FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE;
+        return isCheckingMultipleFiles ? CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.WRONG_FILE_TYPE : CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE;
     }
     return '';
 };
@@ -573,7 +575,7 @@ type TranslationAdditionalData = {
 };
 
 const getFileValidationErrorText = (
-    validationError: ValueOf<typeof CONST.FILE_VALIDATION_ERRORS> | null,
+    validationError: SingleAttachmentValidationError | MultipleAttachmentsValidationError | undefined,
     additionalData: TranslationAdditionalData = {},
     isValidatingReceipt = false,
 ): {
@@ -588,17 +590,17 @@ const getFileValidationErrorText = (
     }
     const maxSize = isValidatingReceipt ? CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE : CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE;
     switch (validationError) {
-        case CONST.FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE:
+        case CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE:
             return {
                 title: translateLocal('attachmentPicker.wrongFileType'),
                 reason: translateLocal('attachmentPicker.notAllowedExtension'),
             };
-        case CONST.FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE_MULTIPLE:
+        case CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.WRONG_FILE_TYPE:
             return {
                 title: translateLocal('attachmentPicker.someFilesCantBeUploaded'),
                 reason: translateLocal('attachmentPicker.unsupportedFileType', {fileType: additionalData.fileType ?? ''}),
             };
-        case CONST.FILE_VALIDATION_ERRORS.FILE_TOO_LARGE:
+        case CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_LARGE:
             return {
                 title: translateLocal('attachmentPicker.attachmentTooLarge'),
                 reason: isValidatingReceipt
@@ -607,34 +609,34 @@ const getFileValidationErrorText = (
                       })
                     : translateLocal('attachmentPicker.sizeExceeded'),
             };
-        case CONST.FILE_VALIDATION_ERRORS.FILE_TOO_LARGE_MULTIPLE:
+        case CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.FILE_TOO_LARGE:
             return {
                 title: translateLocal('attachmentPicker.someFilesCantBeUploaded'),
                 reason: translateLocal('attachmentPicker.sizeLimitExceeded', {
                     maxUploadSizeInMB: additionalData.maxUploadSizeInMB ?? maxSize / 1024 / 1024,
                 }),
             };
-        case CONST.FILE_VALIDATION_ERRORS.FILE_TOO_SMALL:
+        case CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_SMALL:
             return {
                 title: translateLocal('attachmentPicker.attachmentTooSmall'),
                 reason: translateLocal('attachmentPicker.sizeNotMet'),
             };
-        case CONST.FILE_VALIDATION_ERRORS.FOLDER_NOT_ALLOWED:
+        case CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.FOLDER_NOT_ALLOWED:
             return {
                 title: translateLocal('attachmentPicker.attachmentError'),
                 reason: translateLocal('attachmentPicker.folderNotAllowedMessage'),
             };
-        case CONST.FILE_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED:
+        case CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED:
             return {
                 title: translateLocal('attachmentPicker.someFilesCantBeUploaded'),
                 reason: translateLocal('attachmentPicker.maxFileLimitExceeded'),
             };
-        case CONST.FILE_VALIDATION_ERRORS.FILE_CORRUPTED:
+        case CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_CORRUPTED:
             return {
                 title: translateLocal('attachmentPicker.attachmentError'),
                 reason: translateLocal('attachmentPicker.errorWhileSelectingCorruptedAttachment'),
             };
-        case CONST.FILE_VALIDATION_ERRORS.PROTECTED_FILE:
+        case CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.PROTECTED_FILE:
             return {
                 title: translateLocal('attachmentPicker.attachmentError'),
                 reason: translateLocal('attachmentPicker.protectedPDFNotSupported'),
diff --git a/src/pages/home/report/ReportActionCompose/AttachmentPickerWithMenuItems.tsx b/src/pages/home/report/ReportActionCompose/AttachmentPickerWithMenuItems.tsx
index 31c558e60fb8..710b3a6611b8 100644
--- a/src/pages/home/report/ReportActionCompose/AttachmentPickerWithMenuItems.tsx
+++ b/src/pages/home/report/ReportActionCompose/AttachmentPickerWithMenuItems.tsx
@@ -49,8 +49,8 @@ type AttachmentPickerWithMenuItemsProps = {
     /** The personal details of the current user */
     currentUserPersonalDetails: OnyxTypes.PersonalDetails;
 
-    /** Callback to open the file in the modal */
-    displayFilesInModal: (files: FileObject[]) => void;
+    /** Callback when the attachment is picked */
+    onAttachmentPicked: (url: FileObject | FileObject[]) => void;
 
     /** Whether or not the full size composer is available */
     isFullComposerAvailable: boolean;
@@ -105,7 +105,7 @@ function AttachmentPickerWithMenuItems({
     report,
     currentUserPersonalDetails,
     reportParticipantIDs,
-    displayFilesInModal,
+    onAttachmentPicked,
     isFullComposerAvailable,
     isComposerFullSize,
     reportID,
@@ -335,7 +335,7 @@ function AttachmentPickerWithMenuItems({
                 const triggerAttachmentPicker = () => {
                     onTriggerAttachmentPicker();
                     openPicker({
-                        onPicked: (data) => displayFilesInModal(data),
+                        onPicked: onAttachmentPicked,
                         onCanceled: () => {
                             onCanceledAttachmentPicker?.();
                             setIsLoaderVisible(false);
diff --git a/src/pages/home/report/ReportActionCompose/ComposerWithSuggestions/ComposerWithSuggestions.tsx b/src/pages/home/report/ReportActionCompose/ComposerWithSuggestions/ComposerWithSuggestions.tsx
index d9c14cdeae53..6710431c39f5 100644
--- a/src/pages/home/report/ReportActionCompose/ComposerWithSuggestions/ComposerWithSuggestions.tsx
+++ b/src/pages/home/report/ReportActionCompose/ComposerWithSuggestions/ComposerWithSuggestions.tsx
@@ -100,8 +100,8 @@ type ComposerWithSuggestionsProps = Partial<ChildrenProps> & {
     /** The placeholder for the input */
     inputPlaceholder: string;
 
-    /** Function to display a file in a modal */
-    displayFilesInModal: (file: FileObject[]) => void;
+    /** Callback when a file is pasted */
+    onFilePasted: (file: FileObject | FileObject[]) => void;
 
     /** Whether the input is disabled, defaults to false */
     disabled?: boolean;
@@ -213,7 +213,7 @@ function ComposerWithSuggestions(
         setIsFullComposerAvailable,
         isMenuVisible,
         inputPlaceholder,
-        displayFilesInModal,
+        onFilePasted,
         disabled,
         setIsCommentEmpty,
         handleSendMessage,
@@ -808,9 +808,9 @@ function ComposerWithSuggestions(
                     }}
                     onBlur={onBlur}
                     onClick={setShouldBlockSuggestionCalcToFalse}
-                    onPasteFile={(file) => {
+                    onPasteFile={(files) => {
                         textInputRef.current?.blur();
-                        displayFilesInModal([file]);
+                        onFilePasted(files);
                     }}
                     onClear={onClear}
                     isDisabled={disabled}
diff --git a/src/pages/home/report/ReportActionCompose/ReportActionCompose.tsx b/src/pages/home/report/ReportActionCompose/ReportActionCompose.tsx
index 4fc424a5cbd7..5c097448dfca 100644
--- a/src/pages/home/report/ReportActionCompose/ReportActionCompose.tsx
+++ b/src/pages/home/report/ReportActionCompose/ReportActionCompose.tsx
@@ -7,7 +7,6 @@ import type {OnyxEntry} from 'react-native-onyx';
 import {runOnUI, useSharedValue} from 'react-native-reanimated';
 import type {Emoji} from '@assets/emojis/types';
 import * as ActionSheetAwareScrollView from '@components/ActionSheetAwareScrollView';
-import AttachmentComposerModal from '@components/AttachmentComposerModal';
 import DragAndDropConsumer from '@components/DragAndDrop/Consumer';
 import DropZoneUI from '@components/DropZone/DropZoneUI';
 import DualDropZone from '@components/DropZone/DualDropZone';
@@ -32,6 +31,7 @@ import useResponsiveLayout from '@hooks/useResponsiveLayout';
 import useTheme from '@hooks/useTheme';
 import useThemeStyles from '@hooks/useThemeStyles';
 import canFocusInputOnScreenFocus from '@libs/canFocusInputOnScreenFocus';
+import ComposerFocusManager from '@libs/ComposerFocusManager';
 import {canUseTouchScreen} from '@libs/DeviceCapabilities';
 import DomUtils from '@libs/DomUtils';
 import {getDraftComment} from '@libs/DraftCommentUtils';
@@ -58,6 +58,7 @@ import Navigation from '@navigation/Navigation';
 import AgentZeroProcessingRequestIndicator from '@pages/home/report/AgentZeroProcessingRequestIndicator';
 import ParticipantLocalTime from '@pages/home/report/ParticipantLocalTime';
 import ReportTypingIndicator from '@pages/home/report/ReportTypingIndicator';
+import AttachmentModalContext from '@pages/media/AttachmentModalScreen/AttachmentModalContext';
 import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
 import {hideEmojiPicker, isActive as isActiveEmojiPickerAction} from '@userActions/EmojiPickerAction';
 import {initMoneyRequest, replaceReceipt, setMoneyRequestParticipantsFromReport, setMoneyRequestReceipt} from '@userActions/IOU';
@@ -68,6 +69,7 @@ import {isBlockedFromConcierge as isBlockedFromConciergeUserAction} from '@userA
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
 import ROUTES from '@src/ROUTES';
+import type SCREENS from '@src/SCREENS';
 import type * as OnyxTypes from '@src/types/onyx';
 import type * as OnyxCommon from '@src/types/onyx/OnyxCommon';
 import {isEmptyObject} from '@src/types/utils/EmptyObject';
@@ -306,6 +308,8 @@ function ReportActionCompose({
     const onAttachmentPreviewClose = useCallback(() => {
         updateShouldShowSuggestionMenuToFalse();
         setIsAttachmentPreviewActive(false);
+        // This enables Composer refocus when the attachments modal is closed by the browser navigation
+        ComposerFocusManager.setReadyToFocus();
     }, [updateShouldShowSuggestionMenuToFalse]);
 
     /**
@@ -480,6 +484,41 @@ function ReportActionCompose({
         [isComposerFullSize, reportID, debouncedValidate],
     );
 
+    const reportAttachmentsContext = useContext(AttachmentModalContext);
+    const showAttachmentModalScreen = useCallback(
+        (file: FileObject | FileObject[]) => {
+            reportAttachmentsContext.setCurrentAttachment<typeof SCREENS.REPORT_ADD_ATTACHMENT>({
+                reportID,
+                file,
+                headerTitle: translate('reportActionCompose.sendAttachment'),
+                onConfirm: addAttachment,
+                onShow: () => setIsAttachmentPreviewActive(true),
+                onClose: onAttachmentPreviewClose,
+                shouldDisableSendButton: !!exceededMaxLength,
+            });
+            Navigation.navigate(ROUTES.REPORT_ADD_ATTACHMENT.getRoute(reportID));
+        },
+        [addAttachment, exceededMaxLength, onAttachmentPreviewClose, reportAttachmentsContext, reportID, translate],
+    );
+
+    const handleAttachmentDrop = (event: DragEvent) => {
+        if (isAttachmentPreviewActive) {
+            return;
+        }
+
+        const files = Array.from(event.dataTransfer?.files ?? []).map((file) => {
+            // eslint-disable-next-line no-param-reassign
+            file.uri = URL.createObjectURL(file);
+            return file;
+        });
+
+        if (files.length === 0) {
+            return;
+        }
+
+        showAttachmentModalScreen(files);
+    };
+
     const saveFileAndInitMoneyRequest = (files: FileObject[]) => {
         if (files.length === 0) {
             return;
@@ -575,117 +614,81 @@ function ReportActionCompose({
                         ]}
                     >
                         {PDFValidationComponent}
-                        <AttachmentComposerModal
-                            headerTitle={translate('reportActionCompose.sendAttachment')}
-                            onConfirm={addAttachment}
-                            onModalShow={() => setIsAttachmentPreviewActive(true)}
-                            onModalHide={onAttachmentPreviewClose}
-                            shouldDisableSendButton={!!exceededMaxLength}
+                        <AttachmentPickerWithMenuItems
+                            onAttachmentPicked={showAttachmentModalScreen}
+                            reportID={reportID}
                             report={report}
-                        >
-                            {({displayFilesInModal}) => {
-                                const handleAttachmentDrop = (event: DragEvent) => {
-                                    if (isAttachmentPreviewActive) {
-                                        return;
-                                    }
-                                    if (event.dataTransfer?.files.length && event.dataTransfer?.files.length > 1) {
-                                        const files = Array.from(event.dataTransfer?.files).map((file) => {
-                                            // eslint-disable-next-line no-param-reassign
-                                            file.uri = URL.createObjectURL(file);
-                                            return file;
-                                        });
-                                        displayFilesInModal(files, Array.from(event.dataTransfer?.items ?? []));
-                                        return;
-                                    }
-
-                                    const data = event.dataTransfer?.files[0];
-                                    if (data) {
-                                        data.uri = URL.createObjectURL(data);
-                                        displayFilesInModal([data], Array.from(event.dataTransfer?.items ?? []));
-                                    }
-                                };
-
-                                return (
-                                    <>
-                                        <AttachmentPickerWithMenuItems
-                                            displayFilesInModal={displayFilesInModal}
-                                            reportID={reportID}
-                                            report={report}
-                                            currentUserPersonalDetails={currentUserPersonalDetails}
-                                            reportParticipantIDs={reportParticipantIDs}
-                                            isFullComposerAvailable={isFullComposerAvailable}
-                                            isComposerFullSize={isComposerFullSize}
-                                            disabled={isBlockedFromConcierge}
-                                            setMenuVisibility={setMenuVisibility}
-                                            isMenuVisible={isMenuVisible}
-                                            onTriggerAttachmentPicker={onTriggerAttachmentPicker}
-                                            raiseIsScrollLikelyLayoutTriggered={raiseIsScrollLikelyLayoutTriggered}
-                                            onAddActionPressed={onAddActionPressed}
-                                            onItemSelected={onItemSelected}
-                                            onCanceledAttachmentPicker={() => {
-                                                if (!shouldFocusInputOnScreenFocus) {
-                                                    return;
-                                                }
-                                                focus();
-                                            }}
-                                            actionButtonRef={actionButtonRef}
-                                            shouldDisableAttachmentItem={!!exceededMaxLength}
-                                        />
-                                        <ComposerWithSuggestions
-                                            ref={(ref) => {
-                                                composerRef.current = ref ?? undefined;
-                                                composerRefShared.set({
-                                                    clear: ref?.clear,
-                                                });
-                                            }}
-                                            suggestionsRef={suggestionsRef}
-                                            isNextModalWillOpenRef={isNextModalWillOpenRef}
-                                            isScrollLikelyLayoutTriggered={isScrollLikelyLayoutTriggered}
-                                            raiseIsScrollLikelyLayoutTriggered={raiseIsScrollLikelyLayoutTriggered}
-                                            reportID={reportID}
-                                            policyID={report?.policyID}
-                                            includeChronos={chatIncludesChronos(report)}
-                                            isGroupPolicyReport={isGroupPolicyReport}
-                                            lastReportAction={lastReportAction}
-                                            isMenuVisible={isMenuVisible}
-                                            inputPlaceholder={inputPlaceholder}
-                                            isComposerFullSize={isComposerFullSize}
-                                            setIsFullComposerAvailable={setIsFullComposerAvailable}
-                                            displayFilesInModal={displayFilesInModal}
-                                            onCleared={submitForm}
-                                            disabled={isBlockedFromConcierge}
-                                            setIsCommentEmpty={setIsCommentEmpty}
-                                            handleSendMessage={handleSendMessage}
-                                            shouldShowComposeInput={shouldShowComposeInput}
-                                            onFocus={onFocus}
-                                            onBlur={onBlur}
-                                            measureParentContainer={measureContainer}
-                                            onValueChange={onValueChange}
-                                            didHideComposerInput={didHideComposerInput}
-                                        />
-                                        {shouldDisplayDualDropZone && (
-                                            <DualDropZone
-                                                isEditing={shouldAddOrReplaceReceipt && hasReceipt}
-                                                onAttachmentDrop={handleAttachmentDrop}
-                                                onReceiptDrop={handleAddingReceipt}
-                                                shouldAcceptSingleReceipt={shouldAddOrReplaceReceipt}
-                                            />
-                                        )}
-                                        {!shouldDisplayDualDropZone && (
-                                            <DragAndDropConsumer onDrop={handleAttachmentDrop}>
-                                                <DropZoneUI
-                                                    icon={Expensicons.MessageInABottle}
-                                                    dropTitle={translate('dropzone.addAttachments')}
-                                                    dropStyles={styles.attachmentDropOverlay(true)}
-                                                    dropTextStyles={styles.attachmentDropText}
-                                                    dashedBorderStyles={styles.activeDropzoneDashedBorder(theme.attachmentDropBorderColorActive, true)}
-                                                />
-                                            </DragAndDropConsumer>
-                                        )}
-                                    </>
-                                );
+                            currentUserPersonalDetails={currentUserPersonalDetails}
+                            reportParticipantIDs={reportParticipantIDs}
+                            isFullComposerAvailable={isFullComposerAvailable}
+                            isComposerFullSize={isComposerFullSize}
+                            disabled={isBlockedFromConcierge}
+                            setMenuVisibility={setMenuVisibility}
+                            isMenuVisible={isMenuVisible}
+                            onTriggerAttachmentPicker={onTriggerAttachmentPicker}
+                            raiseIsScrollLikelyLayoutTriggered={raiseIsScrollLikelyLayoutTriggered}
+                            onAddActionPressed={onAddActionPressed}
+                            onItemSelected={onItemSelected}
+                            onCanceledAttachmentPicker={() => {
+                                if (!shouldFocusInputOnScreenFocus) {
+                                    return;
+                                }
+                                focus();
                             }}
-                        </AttachmentComposerModal>
+                            actionButtonRef={actionButtonRef}
+                            shouldDisableAttachmentItem={!!exceededMaxLength}
+                        />
+                        <ComposerWithSuggestions
+                            ref={(ref) => {
+                                composerRef.current = ref ?? undefined;
+                                composerRefShared.set({
+                                    clear: ref?.clear,
+                                });
+                            }}
+                            suggestionsRef={suggestionsRef}
+                            isNextModalWillOpenRef={isNextModalWillOpenRef}
+                            isScrollLikelyLayoutTriggered={isScrollLikelyLayoutTriggered}
+                            raiseIsScrollLikelyLayoutTriggered={raiseIsScrollLikelyLayoutTriggered}
+                            reportID={reportID}
+                            policyID={report?.policyID}
+                            includeChronos={chatIncludesChronos(report)}
+                            isGroupPolicyReport={isGroupPolicyReport}
+                            lastReportAction={lastReportAction}
+                            isMenuVisible={isMenuVisible}
+                            inputPlaceholder={inputPlaceholder}
+                            isComposerFullSize={isComposerFullSize}
+                            setIsFullComposerAvailable={setIsFullComposerAvailable}
+                            onFilePasted={showAttachmentModalScreen}
+                            onCleared={submitForm}
+                            disabled={isBlockedFromConcierge}
+                            setIsCommentEmpty={setIsCommentEmpty}
+                            handleSendMessage={handleSendMessage}
+                            shouldShowComposeInput={shouldShowComposeInput}
+                            onFocus={onFocus}
+                            onBlur={onBlur}
+                            measureParentContainer={measureContainer}
+                            onValueChange={onValueChange}
+                            didHideComposerInput={didHideComposerInput}
+                        />
+                        {shouldDisplayDualDropZone && (
+                            <DualDropZone
+                                isEditing={shouldAddOrReplaceReceipt && hasReceipt}
+                                onAttachmentDrop={handleAttachmentDrop}
+                                onReceiptDrop={handleAddingReceipt}
+                                shouldAcceptSingleReceipt={shouldAddOrReplaceReceipt}
+                            />
+                        )}
+                        {!shouldDisplayDualDropZone && (
+                            <DragAndDropConsumer onDrop={handleAttachmentDrop}>
+                                <DropZoneUI
+                                    icon={Expensicons.MessageInABottle}
+                                    dropTitle={translate('dropzone.addAttachments')}
+                                    dropStyles={styles.attachmentDropOverlay(true)}
+                                    dropTextStyles={styles.attachmentDropText}
+                                    dashedBorderStyles={styles.activeDropzoneDashedBorder(theme.attachmentDropBorderColorActive, true)}
+                                />
+                            </DragAndDropConsumer>
+                        )}
                         {canUseTouchScreen() && isMediumScreenWidth ? null : (
                             <EmojiPickerButton
                                 isDisabled={isBlockedFromConcierge}
diff --git a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
new file mode 100644
index 000000000000..1423320dd3c2
--- /dev/null
+++ b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
@@ -0,0 +1,369 @@
+import React, {memo, useCallback, useEffect, useMemo, useState} from 'react';
+import {View} from 'react-native';
+import {GestureHandlerRootView} from 'react-native-gesture-handler';
+import Animated, {FadeIn, LayoutAnimationConfig, useSharedValue} from 'react-native-reanimated';
+import AttachmentCarousel from '@components/Attachments/AttachmentCarousel';
+import AttachmentCarouselPagerContext from '@components/Attachments/AttachmentCarousel/Pager/AttachmentCarouselPagerContext';
+import AttachmentView from '@components/Attachments/AttachmentView';
+import useAttachmentErrors from '@components/Attachments/AttachmentView/useAttachmentErrors';
+import type {Attachment} from '@components/Attachments/types';
+import BlockingView from '@components/BlockingViews/BlockingView';
+import Button from '@components/Button';
+import FullScreenLoadingIndicator from '@components/FullscreenLoadingIndicator';
+import HeaderGap from '@components/HeaderGap';
+import HeaderWithBackButton from '@components/HeaderWithBackButton';
+import * as Illustrations from '@components/Icon/Illustrations';
+import type {PopoverMenuItem} from '@components/PopoverMenu';
+import SafeAreaConsumer from '@components/SafeAreaConsumer';
+import useLocalize from '@hooks/useLocalize';
+import useNetwork from '@hooks/useNetwork';
+import useOnyx from '@hooks/useOnyx';
+import useResponsiveLayout from '@hooks/useResponsiveLayout';
+import useThemeStyles from '@hooks/useThemeStyles';
+import useWindowDimensions from '@hooks/useWindowDimensions';
+import KeyboardShortcut from '@libs/KeyboardShortcut';
+import {getOriginalMessage, getReportAction, isMoneyRequestAction} from '@libs/ReportActionsUtils';
+import type {AvatarSource} from '@libs/UserUtils';
+import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
+import variables from '@styles/variables';
+import CONST from '@src/CONST';
+import ONYXKEYS from '@src/ONYXKEYS';
+import {isEmptyObject} from '@src/types/utils/EmptyObject';
+import viewRef from '@src/types/utils/viewRef';
+import type {AttachmentModalBaseContentProps} from './types';
+
+function AttachmentModalBaseContent({
+    source: sourceProp = '',
+    fallbackSource,
+    file: filesProp,
+    fileToDisplayIndex = 0,
+    originalFileName = '',
+    attachmentID,
+    isAuthTokenRequired = false,
+    maybeIcon = false,
+    type,
+    accountID,
+    attachmentLink = '',
+    report,
+    reportID,
+    isWorkspaceAvatar = false,
+    headerTitle,
+    threeDotsMenuItems: threeDotsMenuItemsProp,
+    isLoading = false,
+    shouldShowNotFoundPage = false,
+    shouldShowCarousel = true,
+    shouldDisableSendButton = false,
+    shouldDisplayHelpButton = true,
+    submitRef,
+    onDownloadAttachment,
+    onClose,
+    onConfirm,
+    AttachmentContent,
+    ExtraModals,
+    onCarouselAttachmentChange = () => {},
+}: AttachmentModalBaseContentProps) {
+    const styles = useThemeStyles();
+    const {windowWidth} = useWindowDimensions();
+    const {shouldUseNarrowLayout} = useResponsiveLayout();
+    const {translate} = useLocalize();
+    const {isOffline} = useNetwork();
+
+    // This logic is used to ensure that the source is updated when the source changes and
+    // that the initially provided source is always used as a fallback.
+    const [source, setSource] = useState<AvatarSource>(() => sourceProp);
+    const isLocalSource = typeof source === 'string' && /^file:|^blob:/.test(source);
+    const sourceForAttachmentView = source || sourceProp;
+    useEffect(() => {
+        setSource(() => sourceProp);
+    }, [sourceProp]);
+
+    const [isAuthTokenRequiredState, setIsAuthTokenRequiredState] = useState(isAuthTokenRequired);
+    useEffect(() => {
+        setIsAuthTokenRequiredState(isAuthTokenRequired);
+    }, [isAuthTokenRequired]);
+
+    const [isConfirmButtonDisabled, setIsConfirmButtonDisabled] = useState(false);
+    const parentReportAction = getReportAction(report?.parentReportID, report?.parentReportActionID);
+    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+    const transactionID = (isMoneyRequestAction(parentReportAction) && getOriginalMessage(parentReportAction)?.IOUTransactionID) || CONST.DEFAULT_NUMBER_ID;
+    const [transaction] = useOnyx(`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, {canBeMissing: true});
+    const [currentAttachmentLink, setCurrentAttachmentLink] = useState(attachmentLink);
+
+    const fallbackFile = useMemo(() => (originalFileName ? {name: originalFileName} : undefined), [originalFileName]);
+    const [files, setFilesInternal] = useState<FileObject | FileObject[] | undefined>(() => filesProp ?? fallbackFile);
+    const [isMultipleFiles, setIsMultipleFiles] = useState<boolean>(() => Array.isArray(files));
+    const fileToDisplay = useMemo(() => {
+        if (isMultipleFiles) {
+            return (files as FileObject[])?.at(fileToDisplayIndex);
+        }
+        return files as FileObject;
+    }, [files, fileToDisplayIndex, isMultipleFiles]);
+
+    const setFile = useCallback((newFile: FileObject | FileObject[] | undefined) => {
+        if (Array.isArray(newFile)) {
+            setFilesInternal(newFile);
+            setIsMultipleFiles(true);
+        } else {
+            setFilesInternal(newFile);
+            setIsMultipleFiles(false);
+        }
+    }, []);
+
+    useEffect(() => {
+        setFile(filesProp ?? fallbackFile);
+    }, [filesProp, fallbackFile, setFile]);
+
+    /**
+     * Keeps the attachment source in sync with the attachment displayed currently in the carousel.
+     */
+    const onNavigate = useCallback(
+        (attachment: Attachment) => {
+            setSource(attachment.source);
+            setFile(attachment.file);
+            setIsAuthTokenRequiredState(attachment.isAuthTokenRequired ?? false);
+            onCarouselAttachmentChange(attachment);
+            setCurrentAttachmentLink(attachment?.attachmentLink ?? '');
+        },
+        [onCarouselAttachmentChange, setFile],
+    );
+
+    const threeDotsMenuItems = useMemo(() => {
+        const menuItems: PopoverMenuItem[] = [];
+
+        threeDotsMenuItemsProp?.forEach((menuItem) => {
+            if (typeof menuItem === 'function') {
+                const generatedMenuItem = menuItem({file: fileToDisplay, source, isLocalSource});
+                if (generatedMenuItem) {
+                    menuItems.push(generatedMenuItem);
+                }
+
+                return;
+            }
+
+            menuItems.push(menuItem);
+        });
+
+        return menuItems;
+    }, [fileToDisplay, isLocalSource, source, threeDotsMenuItemsProp]);
+
+    const [isDownloadButtonReadyToBeShown, setIsDownloadButtonReadyToBeShown] = useState(true);
+    const setDownloadButtonVisibility = useCallback(
+        (isButtonVisible: boolean) => {
+            if (isDownloadButtonReadyToBeShown === isButtonVisible) {
+                return;
+            }
+            setIsDownloadButtonReadyToBeShown(isButtonVisible);
+        },
+        [isDownloadButtonReadyToBeShown],
+    );
+
+    /**
+     * Execute the onConfirm callback and close the modal.
+     */
+    const submitAndClose = useCallback(() => {
+        // If the modal has already been closed or the confirm button is disabled
+        // do not submit.
+        if (isConfirmButtonDisabled) {
+            return;
+        }
+
+        if (onConfirm) {
+            onConfirm(Object.assign(files ?? {}, {source} as FileObject));
+        }
+
+        onClose?.();
+        // eslint-disable-next-line react-compiler/react-compiler, react-hooks/exhaustive-deps
+    }, [isConfirmButtonDisabled, onConfirm, files, source]);
+
+    // Close the modal when the escape key is pressed
+    useEffect(() => {
+        const shortcutConfig = CONST.KEYBOARD_SHORTCUTS.ESCAPE;
+        const unsubscribeEscapeKey = KeyboardShortcut.subscribe(
+            shortcutConfig.shortcutKey,
+            () => {
+                onClose?.();
+            },
+            shortcutConfig.descriptionKey,
+            shortcutConfig.modifiers,
+            true,
+            true,
+        );
+
+        return unsubscribeEscapeKey;
+    }, [onClose]);
+
+    const {setAttachmentError, isErrorInAttachment, clearAttachmentErrors} = useAttachmentErrors();
+    useEffect(() => {
+        return () => {
+            clearAttachmentErrors();
+        };
+    }, [clearAttachmentErrors]);
+    const shouldShowDownloadButton = useMemo(() => {
+        if ((isEmptyObject(report) && type !== CONST.ATTACHMENT_TYPE.SEARCH) || isErrorInAttachment(source)) {
+            return false;
+        }
+
+        return !!onDownloadAttachment && isDownloadButtonReadyToBeShown && !shouldShowNotFoundPage && !isOffline && !isLocalSource;
+    }, [isDownloadButtonReadyToBeShown, isErrorInAttachment, isLocalSource, isOffline, onDownloadAttachment, report, shouldShowNotFoundPage, source, type]);
+
+    // We need to pass a shared value of type boolean to the context, so `falseSV` acts as a default value.
+    const falseSV = useSharedValue(false);
+    const context = useMemo(
+        () => ({
+            pagerItems: [{source: sourceForAttachmentView, index: 0, isActive: true}],
+            activePage: 0,
+            pagerRef: undefined,
+            isPagerScrolling: falseSV,
+            isScrollEnabled: falseSV,
+            onTap: () => {},
+            onScaleChanged: () => {},
+            onSwipeDown: onClose,
+            onAttachmentError: setAttachmentError,
+        }),
+        [onClose, falseSV, sourceForAttachmentView, setAttachmentError],
+    );
+
+    const shouldDisplayContent = !shouldShowNotFoundPage && !isLoading;
+    const Content = useMemo(() => {
+        if (AttachmentContent) {
+            return (
+                <AttachmentContent
+                    fileToDisplay={fileToDisplay}
+                    files={files}
+                />
+            );
+        }
+
+        return !isEmptyObject(report) && shouldShowCarousel && type !== CONST.ATTACHMENT_TYPE.SEARCH ? (
+            <AttachmentCarousel
+                accountID={accountID}
+                type={type}
+                attachmentID={attachmentID}
+                report={report}
+                onNavigate={onNavigate}
+                onClose={onClose}
+                source={sourceProp}
+                setDownloadButtonVisibility={setDownloadButtonVisibility}
+                attachmentLink={currentAttachmentLink}
+                onAttachmentError={setAttachmentError}
+            />
+        ) : (
+            !!sourceForAttachmentView && (
+                <AttachmentCarouselPagerContext.Provider value={context}>
+                    <AttachmentView
+                        containerStyles={[styles.mh5]}
+                        source={sourceForAttachmentView}
+                        isAuthTokenRequired={isAuthTokenRequiredState}
+                        file={fileToDisplay}
+                        onToggleKeyboard={setIsConfirmButtonDisabled}
+                        isWorkspaceAvatar={isWorkspaceAvatar}
+                        maybeIcon={maybeIcon}
+                        fallbackSource={fallbackSource}
+                        isUsedInAttachmentModal
+                        transactionID={transaction?.transactionID}
+                        isUploaded={!isEmptyObject(report)}
+                        reportID={reportID ?? (!isEmptyObject(report) ? report.reportID : undefined)}
+                    />
+                </AttachmentCarouselPagerContext.Provider>
+            )
+        );
+    }, [
+        AttachmentContent,
+        accountID,
+        attachmentID,
+        context,
+        currentAttachmentLink,
+        fallbackSource,
+        fileToDisplay,
+        files,
+        isAuthTokenRequiredState,
+        isWorkspaceAvatar,
+        maybeIcon,
+        onClose,
+        onNavigate,
+        report,
+        reportID,
+        setAttachmentError,
+        setDownloadButtonVisibility,
+        shouldShowCarousel,
+        sourceForAttachmentView,
+        sourceProp,
+        styles.mh5,
+        transaction?.transactionID,
+        type,
+    ]);
+
+    return (
+        <GestureHandlerRootView style={styles.flex1}>
+            {shouldUseNarrowLayout && <HeaderGap />}
+            <HeaderWithBackButton
+                shouldMinimizeMenuButton
+                title={headerTitle ?? translate('common.attachment')}
+                shouldShowBorderBottom
+                shouldShowDownloadButton={shouldShowDownloadButton}
+                shouldDisplayHelpButton={shouldDisplayHelpButton}
+                onDownloadButtonPress={() => onDownloadAttachment?.({file: fileToDisplay, source})}
+                shouldShowCloseButton={!shouldUseNarrowLayout}
+                shouldShowBackButton={shouldUseNarrowLayout}
+                onBackButtonPress={onClose}
+                onCloseButtonPress={onClose}
+                shouldShowThreeDotsButton={threeDotsMenuItems.length > 0}
+                threeDotsMenuItems={threeDotsMenuItems}
+                threeDotsAnchorPosition={styles.threeDotsPopoverOffsetAttachmentModal(windowWidth)}
+                threeDotsAnchorAlignment={{
+                    horizontal: CONST.MODAL.ANCHOR_ORIGIN_HORIZONTAL.LEFT,
+                    vertical: CONST.MODAL.ANCHOR_ORIGIN_VERTICAL.TOP,
+                }}
+                shouldSetModalVisibility={false}
+                shouldOverlayDots
+                subTitleLink={currentAttachmentLink ?? ''}
+            />
+            <View style={styles.imageModalImageCenterContainer}>
+                {isLoading && <FullScreenLoadingIndicator testID="attachment-loading-spinner" />}
+                {shouldShowNotFoundPage && !isLoading && (
+                    <BlockingView
+                        icon={Illustrations.ToddBehindCloud}
+                        iconWidth={variables.modalTopIconWidth}
+                        iconHeight={variables.modalTopIconHeight}
+                        title={translate('notFound.notHere')}
+                        subtitle={translate('notFound.pageNotFound')}
+                        linkTranslationKey="notFound.goBackHome"
+                        onLinkPress={onClose}
+                    />
+                )}
+                {shouldDisplayContent && Content}
+            </View>
+            {/* If we have an onConfirm method show a confirmation button */}
+            {!!onConfirm && !isConfirmButtonDisabled && (
+                <LayoutAnimationConfig skipEntering>
+                    {!!onConfirm && !isConfirmButtonDisabled && (
+                        <SafeAreaConsumer>
+                            {({safeAreaPaddingBottomStyle}) => (
+                                <Animated.View
+                                    style={safeAreaPaddingBottomStyle}
+                                    entering={FadeIn}
+                                >
+                                    <Button
+                                        ref={submitRef ? viewRef(submitRef) : undefined}
+                                        success
+                                        large
+                                        style={[styles.buttonConfirm, shouldUseNarrowLayout ? {} : styles.attachmentButtonBigScreen]}
+                                        textStyles={[styles.buttonConfirmText]}
+                                        text={translate('common.send')}
+                                        onPress={submitAndClose}
+                                        isDisabled={isConfirmButtonDisabled || shouldDisableSendButton}
+                                        pressOnEnter
+                                    />
+                                </Animated.View>
+                            )}
+                        </SafeAreaConsumer>
+                    )}
+                </LayoutAnimationConfig>
+            )}
+            {ExtraModals}
+        </GestureHandlerRootView>
+    );
+}
+AttachmentModalBaseContent.displayName = 'AttachmentModalBaseContent';
+
+export default memo(AttachmentModalBaseContent);
diff --git a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts
new file mode 100644
index 000000000000..df02e71d60a9
--- /dev/null
+++ b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts
@@ -0,0 +1,131 @@
+import type {RefObject} from 'react';
+import type {View} from 'react-native';
+import type {OnyxEntry} from 'react-native-onyx';
+import type {ValueOf} from 'type-fest';
+import type {Attachment} from '@components/Attachments/types';
+import type {PopoverMenuItem} from '@components/PopoverMenu';
+import type {AvatarSource} from '@libs/UserUtils';
+import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
+import type CONST from '@src/CONST';
+import type * as OnyxTypes from '@src/types/onyx';
+
+type AttachmentModalOnCloseOptions = {
+    shouldCallDirectly?: boolean;
+    onAfterClose?: () => void;
+};
+
+type AttachmentModalContentData = {
+    source: AvatarSource;
+    file: FileObject | undefined;
+};
+
+type ThreeDotsMenuItemGeneratorProps = AttachmentModalContentData & {
+    isLocalSource: boolean;
+};
+type ThreeDotsMenuItemGenerator = (props: ThreeDotsMenuItemGeneratorProps) => PopoverMenuItem | undefined;
+
+type DownloadAttachmentCallback = (props: AttachmentModalContentData) => void;
+
+type AttachmentContentProps = {
+    fileToDisplay: FileObject | undefined;
+    files: FileObject | FileObject[] | undefined;
+};
+type AttachmentContent = React.FC<AttachmentContentProps>;
+
+type AttachmentModalBaseContentProps = {
+    /** Optional source (URL, SVG function) for the image shown. If not passed in via props must be specified when modal is opened. */
+    source?: AvatarSource;
+
+    /** The id of the attachment. */
+    attachmentID?: string;
+
+    /** Fallback source (URL, SVG function) for the image shown. */
+    fallbackSource?: AvatarSource;
+
+    /** Optional file object to be used for the attachment. If not passed in via props must be specified when modal is opened. */
+    file?: FileObject | FileObject[];
+
+    /** The index of the file to display in the carousel */
+    fileToDisplayIndex?: number;
+
+    /** Optional original filename when uploading */
+    originalFileName?: string;
+
+    /** Whether source url requires authentication */
+    isAuthTokenRequired?: boolean;
+
+    /** Title shown in the header of the modal */
+    headerTitle?: string;
+
+    /** The menu items for the three dots button */
+    threeDotsMenuItems?: Array<PopoverMenuItem | ThreeDotsMenuItemGenerator>;
+
+    /** The report that has this attachment */
+    report?: OnyxEntry<OnyxTypes.Report>;
+
+    /** The ID of the current report */
+    reportID?: string;
+
+    /** The type of the attachment */
+    type?: ValueOf<typeof CONST.ATTACHMENT_TYPE>;
+
+    /** If the attachment originates from a note, the accountID will represent the author of that note. */
+    accountID?: number;
+
+    /** The data is loading or not */
+    isLoading?: boolean;
+
+    /** Denotes whether it is a workspace avatar or not */
+    isWorkspaceAvatar?: boolean;
+
+    /** Denotes whether it can be an icon (ex: SVG) */
+    maybeIcon?: boolean;
+
+    /** Whether to display not found page */
+    shouldShowNotFoundPage?: boolean;
+
+    /** Whether to show an attachment carousel */
+    shouldShowCarousel?: boolean;
+
+    /** Whether to show download button */
+    shouldShowDownloadButton?: boolean;
+
+    /** Whether to disable send button */
+    shouldDisableSendButton?: boolean;
+
+    /** Whether to display help button */
+    shouldDisplayHelpButton?: boolean;
+
+    /** The link of the attachment */
+    attachmentLink?: string;
+
+    /** Ref to the submit button */
+    submitRef?: RefObject<View | HTMLElement | null>;
+
+    AttachmentContent?: AttachmentContent;
+
+    /** Extra modals to be displayed in the modal */
+    ExtraModals?: React.ReactNode;
+
+    /** Callback triggered when the download button is pressed */
+    onDownloadAttachment?: DownloadAttachmentCallback;
+
+    /** Optional callback to fire when we want to preview an image and approve it for use. */
+    onConfirm?: (file: FileObject | FileObject[]) => void;
+
+    /** Callback triggered when the modal is closed */
+    onClose?: (options?: AttachmentModalOnCloseOptions) => void;
+
+    /** Optional callback to fire when we want to do something after attachment carousel changes. */
+    onCarouselAttachmentChange?: (attachment: Attachment) => void;
+};
+
+export type {
+    AttachmentModalBaseContentProps,
+    AttachmentModalOnCloseOptions,
+    ThreeDotsMenuItemGeneratorProps,
+    ThreeDotsMenuItemGenerator,
+    DownloadAttachmentCallback,
+    AttachmentContent,
+    AttachmentContentProps,
+};
diff --git a/src/pages/media/AttachmentModalScreen/routes/hooks/useDownloadAttachment.ts b/src/pages/media/AttachmentModalScreen/routes/hooks/useDownloadAttachment.ts
new file mode 100644
index 000000000000..2ce970df91c2
--- /dev/null
+++ b/src/pages/media/AttachmentModalScreen/routes/hooks/useDownloadAttachment.ts
@@ -0,0 +1,43 @@
+import {useCallback} from 'react';
+import {Keyboard} from 'react-native';
+import addEncryptedAuthTokenToURL from '@libs/addEncryptedAuthTokenToURL';
+import fileDownload from '@libs/fileDownload';
+import {getFileName} from '@libs/fileDownload/FileUtils';
+import type {DownloadAttachmentCallback} from '@pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types';
+import CONST from '@src/CONST';
+
+type UseDownloadAttachmentProps = {
+    isAuthTokenRequired?: boolean;
+    type?: string;
+    draftTransactionID?: string;
+};
+
+function useDownloadAttachment({isAuthTokenRequired, type, draftTransactionID}: UseDownloadAttachmentProps = {}) {
+    /**
+     * Download the currently viewed attachment.
+     */
+    const downloadAttachment = useCallback<DownloadAttachmentCallback>(
+        ({source, file}) => {
+            let sourceURL = source;
+            if (isAuthTokenRequired && typeof sourceURL === 'string') {
+                sourceURL = addEncryptedAuthTokenToURL(sourceURL);
+            }
+
+            if (typeof sourceURL === 'string') {
+                const fileName = type === CONST.ATTACHMENT_TYPE.SEARCH ? getFileName(`${sourceURL}`) : file?.name;
+                const shouldUnlink = !draftTransactionID;
+                fileDownload(sourceURL, fileName ?? '', undefined, undefined, undefined, undefined, undefined, shouldUnlink);
+            }
+
+            // At ios, if the keyboard is open while opening the attachment, then after downloading
+            // the attachment keyboard will show up. So, to fix it we need to dismiss the keyboard.
+            Keyboard.dismiss();
+        },
+        [isAuthTokenRequired, type, draftTransactionID],
+    );
+
+    return downloadAttachment;
+}
+
+export default useDownloadAttachment;
+export type {UseDownloadAttachmentProps};
diff --git a/src/pages/media/AttachmentModalScreen/routes/hooks/useFileUploadValidation.ts b/src/pages/media/AttachmentModalScreen/routes/hooks/useFileUploadValidation.ts
new file mode 100644
index 000000000000..f638f12691da
--- /dev/null
+++ b/src/pages/media/AttachmentModalScreen/routes/hooks/useFileUploadValidation.ts
@@ -0,0 +1,89 @@
+import {useCallback, useEffect, useState} from 'react';
+import {InteractionManager} from 'react-native';
+import type {
+    MultipleAttachmentsInvalidResult,
+    MultipleAttachmentsValidationError,
+    MultipleAttachmentsValidResult,
+    SingleAttachmentInvalidResult,
+    SingleAttachmentValidationError,
+    SingleAttachmentValidResult,
+} from '@libs/AttachmentValidation';
+import {validateAttachmentFile, validateMultipleAttachmentFiles} from '@libs/AttachmentValidation';
+import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
+import CONST from '@src/CONST';
+
+type UseFileUploadValidationProps = {
+    files: FileObject | FileObject[] | undefined;
+    onValid?: (result: SingleAttachmentValidResult | MultipleAttachmentsValidResult) => void;
+    onInvalid?: (result: SingleAttachmentInvalidResult | MultipleAttachmentsInvalidResult) => void;
+};
+
+function useFileUploadValidation({files, onValid, onInvalid}: UseFileUploadValidationProps) {
+    const [validFilesToUpload, setValidFilesToUpload] = useState<FileObject | FileObject[]>();
+    const [fileError, setFileError] = useState<SingleAttachmentValidationError | MultipleAttachmentsValidationError>();
+    const [isFileErrorModalVisible, setIsFileErrorModalVisible] = useState(false);
+
+    // Validates the attachment file and renders the appropriate modal type or errors
+    const validateFile = useCallback(
+        (file: FileObject | FileObject[]) => {
+            if (!file) {
+                return;
+            }
+
+            if (Array.isArray(file)) {
+                validateMultipleAttachmentFiles(file).then((result) => {
+                    if (result.isValid) {
+                        const validFiles = result.validatedFiles.map((f) => f.file);
+                        setValidFilesToUpload(validFiles);
+                        onValid?.(result);
+                        return;
+                    }
+
+                    setFileError(result.error);
+                    setIsFileErrorModalVisible(true);
+
+                    if (result.error === CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED) {
+                        const validFiles = file.slice(0, CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT);
+                        setValidFilesToUpload(validFiles);
+                    }
+
+                    onInvalid?.(result);
+                });
+                return;
+            }
+
+            validateAttachmentFile(file).then((result) => {
+                if (result.isValid) {
+                    const {validatedFile} = result;
+                    setValidFilesToUpload(validatedFile.file);
+
+                    onValid?.(result);
+                    return;
+                }
+
+                const {error} = result;
+                setFileError(error);
+
+                onInvalid?.(result);
+            });
+        },
+        [onInvalid, onValid],
+    );
+
+    useEffect(() => {
+        if (!files) {
+            return;
+        }
+
+        setIsFileErrorModalVisible(false);
+        InteractionManager.runAfterInteractions(() => {
+            setFileError(undefined);
+        });
+
+        validateFile(files);
+    }, [files, validateFile]);
+
+    return {validFilesToUpload, fileError, isFileErrorModalVisible};
+}
+
+export default useFileUploadValidation;
diff --git a/src/pages/media/AttachmentModalScreen/routes/hooks/useNavigateToReportOnRefresh.ts b/src/pages/media/AttachmentModalScreen/routes/hooks/useNavigateToReportOnRefresh.ts
new file mode 100644
index 000000000000..ade1bdcf7489
--- /dev/null
+++ b/src/pages/media/AttachmentModalScreen/routes/hooks/useNavigateToReportOnRefresh.ts
@@ -0,0 +1,30 @@
+import {useEffect} from 'react';
+import Navigation from '@libs/Navigation/Navigation';
+import type {AvatarSource} from '@libs/UserUtils';
+import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
+import ROUTES from '@src/ROUTES';
+
+type UseReportNavigationFallbackProps = {
+    source?: AvatarSource;
+    file?: FileObject | FileObject[];
+    reportID?: string;
+};
+
+// If the user refreshes during the send attachment flow, we need to navigate back to the report or home
+function useNavigateToReportOnRefresh({source, file, reportID}: UseReportNavigationFallbackProps) {
+    useEffect(() => {
+        if (!!source || !!file) {
+            return;
+        }
+
+        Navigation.isNavigationReady().then(() => {
+            if (reportID) {
+                Navigation.goBack(ROUTES.REPORT_WITH_ID.getRoute(reportID));
+            } else {
+                Navigation.goBack(ROUTES.HOME);
+            }
+        });
+    }, [source, reportID, file]);
+}
+
+export default useNavigateToReportOnRefresh;
diff --git a/src/pages/media/AttachmentModalScreen/routes/hooks/useReportAttachmentModalType.ts b/src/pages/media/AttachmentModalScreen/routes/hooks/useReportAttachmentModalType.ts
new file mode 100644
index 000000000000..d7aaa54c441a
--- /dev/null
+++ b/src/pages/media/AttachmentModalScreen/routes/hooks/useReportAttachmentModalType.ts
@@ -0,0 +1,35 @@
+import {Str} from 'expensify-common';
+import {useEffect, useState} from 'react';
+import {translateLocal} from '@libs/Localize';
+import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
+import CONST from '@src/CONST';
+import type ModalType from '@src/types/utils/ModalType';
+
+function isPdfFile(sourceURL: string, fileObject: FileObject) {
+    return !!sourceURL && (Str.isPDF(sourceURL) || (fileObject && Str.isPDF(fileObject.name ?? translateLocal('attachmentView.unknownFilename'))));
+}
+
+function useReportAttachmentModalType(file?: FileObject | FileObject[]) {
+    const [modalType, setModalType] = useState<ModalType>(CONST.MODAL.MODAL_TYPE.CENTERED_UNSWIPEABLE);
+    useEffect(() => {
+        if (!file) {
+            setModalType(CONST.MODAL.MODAL_TYPE.CENTERED_UNSWIPEABLE);
+            return;
+        }
+
+        let isPdf = false;
+
+        if (Array.isArray(file)) {
+            isPdf = file.some((f) => isPdfFile(f.uri ?? '', f));
+        } else {
+            isPdf = isPdfFile(file?.uri ?? '', file ?? {});
+        }
+
+        // If our attachment is a PDF, return the unswipeable Modal type.
+        setModalType(isPdf ? CONST.MODAL.MODAL_TYPE.CENTERED_UNSWIPEABLE : CONST.MODAL.MODAL_TYPE.CENTERED);
+    }, [file]);
+
+    return modalType;
+}
+
+export default useReportAttachmentModalType;
diff --git a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
new file mode 100644
index 000000000000..82a5fa0617ad
--- /dev/null
+++ b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
@@ -0,0 +1,254 @@
+import React, {useCallback, useEffect, useMemo, useRef, useState} from 'react';
+import type {View} from 'react-native';
+import AttachmentCarouselView from '@components/Attachments/AttachmentCarousel/AttachmentCarouselView';
+import useCarouselArrows from '@components/Attachments/AttachmentCarousel/useCarouselArrows';
+import useAttachmentErrors from '@components/Attachments/AttachmentView/useAttachmentErrors';
+import type {Attachment} from '@components/Attachments/types';
+import ConfirmModal from '@components/ConfirmModal';
+import useLocalize from '@hooks/useLocalize';
+import useNetwork from '@hooks/useNetwork';
+import useOnyx from '@hooks/useOnyx';
+import {openReport} from '@libs/actions/Report';
+import {isMultipleAttachmentsValidationResult, isSingleAttachmentValidationResult} from '@libs/AttachmentValidation';
+import {getFileValidationErrorText} from '@libs/fileDownload/FileUtils';
+import {isReportNotFound} from '@libs/ReportUtils';
+import tryResolveUrlFromApiRoot from '@libs/tryResolveUrlFromApiRoot';
+import type {AttachmentContentProps, AttachmentModalBaseContentProps} from '@pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types';
+import AttachmentModalContainer from '@pages/media/AttachmentModalScreen/AttachmentModalContainer';
+import useDownloadAttachment from '@pages/media/AttachmentModalScreen/routes/hooks/useDownloadAttachment';
+import type {AttachmentModalScreenProps, FileObject} from '@pages/media/AttachmentModalScreen/types';
+import CONST from '@src/CONST';
+import ONYXKEYS from '@src/ONYXKEYS';
+import type SCREENS from '@src/SCREENS';
+import {isEmptyObject} from '@src/types/utils/EmptyObject';
+import useFileUploadValidation from '../hooks/useFileUploadValidation';
+import useNavigateToReportOnRefresh from '../hooks/useNavigateToReportOnRefresh';
+import useReportAttachmentModalType from '../hooks/useReportAttachmentModalType';
+
+const convertFileToAttachment = (file: FileObject | undefined): Attachment => {
+    if (!file) {
+        return {source: ''};
+    }
+
+    return {
+        file,
+        source: file.uri ?? '',
+    };
+};
+
+function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScreenProps<typeof SCREENS.REPORT_ADD_ATTACHMENT>) {
+    const {
+        attachmentID,
+        file,
+        source: sourceParam,
+        isAuthTokenRequired,
+        attachmentLink,
+        originalFileName,
+        accountID = CONST.DEFAULT_NUMBER_ID,
+        reportID,
+        shouldDisableSendButton,
+        headerTitle,
+        onConfirm: onConfirmParam,
+        onShow,
+        onClose,
+    } = route.params;
+
+    const [report] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT}${reportID}`, {canBeMissing: false});
+    const [reportActions] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`, {
+        canEvict: false,
+        canBeMissing: true,
+    });
+    const [reportMetadata] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT_METADATA}${reportID}`, {
+        canBeMissing: false,
+    });
+
+    useNavigateToReportOnRefresh({source: sourceParam, file, reportID});
+
+    const [isLoadingApp] = useOnyx(ONYXKEYS.IS_LOADING_APP, {canBeMissing: true});
+    const {isOffline} = useNetwork();
+    const {translate} = useLocalize();
+
+    const submitRef = useRef<View | HTMLElement>(null);
+
+    // Extract the reportActionID from the attachmentID (format: reportActionID_index)
+    const reportActionID = useMemo(() => attachmentID?.split('_')?.[0], [attachmentID]);
+
+    const shouldFetchReport = useMemo(() => {
+        return isEmptyObject(reportActions?.[reportActionID ?? CONST.DEFAULT_NUMBER_ID]);
+    }, [reportActions, reportActionID]);
+
+    const fetchReport = useCallback(() => {
+        openReport(reportID, reportActionID);
+    }, [reportID, reportActionID]);
+
+    useEffect(() => {
+        if (!reportID || !shouldFetchReport) {
+            return;
+        }
+
+        fetchReport();
+    }, [reportID, fetchReport, shouldFetchReport]);
+
+    const [source, setSource] = useState(() => Number(sourceParam) || (typeof sourceParam === 'string' ? tryResolveUrlFromApiRoot(decodeURIComponent(sourceParam)) : undefined));
+    const [filesToValidate, setFilesToValidate] = useState(() => file);
+    const {validFilesToUpload, fileError, isFileErrorModalVisible} = useFileUploadValidation({
+        files: filesToValidate,
+        onValid: (result) => {
+            if (isSingleAttachmentValidationResult(result)) {
+                setSource(result.validatedFile.source);
+            } else if (isMultipleAttachmentsValidationResult(result)) {
+                setSource(result.validatedFiles.at(0)?.source);
+            }
+        },
+    });
+    const isMultipleFiles = useMemo(() => Array.isArray(validFilesToUpload) && validFilesToUpload.length > 0, [validFilesToUpload]);
+
+    const modalType = useReportAttachmentModalType(validFilesToUpload ?? file);
+
+    const onConfirm = useCallback(
+        (f: FileObject | FileObject[]) => {
+            if (Array.isArray(validFilesToUpload) && validFilesToUpload.length > 0) {
+                onConfirmParam?.(validFilesToUpload);
+            } else {
+                onConfirmParam?.(f);
+            }
+        },
+        [onConfirmParam, validFilesToUpload],
+    );
+
+    const onDownloadAttachment = useDownloadAttachment({
+        isAuthTokenRequired,
+    });
+
+    const isLoading = useMemo(() => {
+        if (isOffline || isReportNotFound(report) || !reportID) {
+            return false;
+        }
+        const isEmptyReport = isEmptyObject(report);
+        return (
+            !!isLoadingApp ||
+            isEmptyReport ||
+            (reportMetadata?.isLoadingInitialReportActions !== false && shouldFetchReport) ||
+            (Array.isArray(validFilesToUpload) && validFilesToUpload.length === 0)
+        );
+    }, [isOffline, report, reportID, isLoadingApp, reportMetadata?.isLoadingInitialReportActions, shouldFetchReport, validFilesToUpload]);
+
+    const confirmAndContinue = useCallback(() => {
+        if (fileError !== CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED) {
+            return;
+        }
+
+        setFilesToValidate(file);
+    }, [fileError, file]);
+
+    const ExtraModals = useMemo(
+        () => (
+            <ConfirmModal
+                title={getFileValidationErrorText(fileError).title}
+                onConfirm={() => confirmAndContinue()}
+                onCancel={navigation.goBack}
+                isVisible={isFileErrorModalVisible}
+                prompt={getFileValidationErrorText(fileError).reason}
+                confirmText={translate(isMultipleFiles ? 'common.continue' : 'common.close')}
+                shouldShowCancelButton={isMultipleFiles}
+                cancelText={translate('common.cancel')}
+            />
+        ),
+        [confirmAndContinue, fileError, isFileErrorModalVisible, isMultipleFiles, navigation.goBack, translate],
+    );
+
+    const contentProps = useMemo<AttachmentModalBaseContentProps>(() => {
+        if (validFilesToUpload === undefined) {
+            return {
+                isLoading: true,
+            };
+        }
+
+        return {
+            file: validFilesToUpload,
+            fileToDisplayIndex: 0,
+            source,
+            isLoading,
+            isAuthTokenRequired,
+            attachmentLink,
+            originalFileName,
+            attachmentID,
+            accountID,
+            headerTitle,
+            shouldDisableSendButton,
+            submitRef,
+            onConfirm,
+            onDownloadAttachment,
+            AttachmentContent: AddAttachmentModalCarouselView,
+            ExtraModals,
+        };
+    }, [
+        ExtraModals,
+        accountID,
+        attachmentID,
+        attachmentLink,
+        headerTitle,
+        isAuthTokenRequired,
+        isLoading,
+        onConfirm,
+        onDownloadAttachment,
+        originalFileName,
+        shouldDisableSendButton,
+        source,
+        validFilesToUpload,
+    ]);
+
+    return (
+        <AttachmentModalContainer
+            navigation={navigation}
+            contentProps={contentProps}
+            modalType={modalType}
+            onShow={onShow}
+            onClose={onClose}
+        />
+    );
+}
+ReportAddAttachmentModalContent.displayName = 'ReportAddAttachmentModalContent';
+
+function AddAttachmentModalCarouselView({fileToDisplay, files}: AttachmentContentProps) {
+    const {setAttachmentError, clearAttachmentErrors} = useAttachmentErrors();
+    const {shouldShowArrows, setShouldShowArrows, autoHideArrows, cancelAutoHideArrows} = useCarouselArrows();
+
+    const [page, setPage] = useState<number>(0);
+    const attachments = useMemo(() => {
+        if (Array.isArray(files)) {
+            return files?.map((file) => convertFileToAttachment(file)) ?? [];
+        }
+
+        if (!files) {
+            return [];
+        }
+
+        return [convertFileToAttachment(files)];
+    }, [files]);
+    const currentAttachment = useMemo(() => convertFileToAttachment(fileToDisplay), [fileToDisplay]);
+
+    useEffect(() => {
+        clearAttachmentErrors();
+    }, [clearAttachmentErrors]);
+
+    if (attachments.length === 0 || !currentAttachment) {
+        return null;
+    }
+
+    return (
+        <AttachmentCarouselView
+            attachments={attachments}
+            source={currentAttachment.source}
+            page={page}
+            setPage={setPage}
+            autoHideArrows={autoHideArrows}
+            cancelAutoHideArrow={cancelAutoHideArrows}
+            setShouldShowArrows={setShouldShowArrows}
+            onAttachmentError={setAttachmentError}
+            shouldShowArrows={shouldShowArrows}
+        />
+    );
+}
+
+export default ReportAddAttachmentModalContent;
diff --git a/src/pages/media/AttachmentModalScreen/routes/types.ts b/src/pages/media/AttachmentModalScreen/routes/types.ts
new file mode 100644
index 000000000000..55b96b469529
--- /dev/null
+++ b/src/pages/media/AttachmentModalScreen/routes/types.ts
@@ -0,0 +1,8 @@
+import type {AttachmentModalScreensParamList} from '@libs/Navigation/types';
+import type {AttachmentModalScreenBaseParams} from '@pages/media/AttachmentModalScreen/types';
+import type Modify from '@src/types/utils/Modify';
+import type {AttachmentModalScreenType} from '..';
+
+type AttachmentModalScreenParams<Screen extends AttachmentModalScreenType> = Modify<AttachmentModalScreenBaseParams, AttachmentModalScreensParamList[Screen]>;
+
+export default AttachmentModalScreenParams;
diff --git a/src/stories/Composer.stories.tsx b/src/stories/Composer.stories.tsx
index cdf70313d87d..986d2f173497 100644
--- a/src/stories/Composer.stories.tsx
+++ b/src/stories/Composer.stories.tsx
@@ -35,7 +35,7 @@ const DEFAULT_VALUE = `Composer can do the following:
 
 function Default(props: ComposerProps) {
     const StyleUtils = useStyleUtils();
-    const [pastedFile, setPastedFile] = useState<FileObject | null>(null);
+    const [pastedFile, setPastedFile] = useState<FileObject | FileObject[]>();
     const [comment, setComment] = useState(DEFAULT_VALUE);
     const renderedHTML = parser.replace(comment ?? '');
     const [selection, setSelection] = useState<TextSelection>(() => ({start: DEFAULT_VALUE.length, end: DEFAULT_VALUE.length, positionX: 0, positionY: 0}));
diff --git a/src/types/utils/Modify.ts b/src/types/utils/Modify.ts
new file mode 100644
index 000000000000..d1a30faab616
--- /dev/null
+++ b/src/types/utils/Modify.ts
@@ -0,0 +1,6 @@
+/**
+ * Merges A with B, while properties from B override ones from A.
+ */
+type Modify<A, B> = Omit<A, keyof B> & B;
+
+export default Modify;
diff --git a/tests/unit/FileUtilsTest.ts b/tests/unit/FileUtilsTest.ts
index 344d0c705a6b..cc918ea520f4 100644
--- a/tests/unit/FileUtilsTest.ts
+++ b/tests/unit/FileUtilsTest.ts
@@ -48,31 +48,31 @@ describe('FileUtils', () => {
         it('should not return FILE_TOO_SMALL when validating small attachment', () => {
             const file = createMockFile('file.csv', CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE - 1);
             const error = FileUtils.validateAttachment(file, false, false);
-            expect(error).not.toBe(CONST.FILE_VALIDATION_ERRORS.FILE_TOO_SMALL);
+            expect(error).not.toBe(CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_SMALL);
         });
 
         it('should return FILE_TOO_SMALL when validating small receipt', () => {
             const file = createMockFile('receipt.jpg', CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE - 1);
             const error = FileUtils.validateAttachment(file, false, true);
-            expect(error).toBe(CONST.FILE_VALIDATION_ERRORS.FILE_TOO_SMALL);
+            expect(error).toBe(CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_SMALL);
         });
 
         it('should return FILE_TOO_LARGE for large non-image file', () => {
             const file = createMockFile('file.pdf', CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE + 1);
             const error = FileUtils.validateAttachment(file);
-            expect(error).toBe(CONST.FILE_VALIDATION_ERRORS.FILE_TOO_LARGE);
+            expect(error).toBe(CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_LARGE);
         });
 
         it('should return FILE_TOO_LARGE_MULTIPLE when checking multiple files', () => {
             const file = createMockFile('file.pdf', CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE + 1);
             const error = FileUtils.validateAttachment(file, true);
-            expect(error).toBe(CONST.FILE_VALIDATION_ERRORS.FILE_TOO_LARGE_MULTIPLE);
+            expect(error).toBe(CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.FILE_TOO_LARGE);
         });
 
         it('should return WRONG_FILE_TYPE for invalid receipt extension', () => {
             const file = createMockFile('receipt.exe', CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE - 1);
             const error = FileUtils.validateAttachment(file, false, true);
-            expect(error).toBe(CONST.FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE);
+            expect(error).toBe(CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE);
         });
 
         it('should return empty string for valid image receipt', () => {

From 96d4dd578aa3d77dfcdb78add893937860e96219 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Thu, 4 Sep 2025 13:11:05 +0200
Subject: [PATCH 02/31] fix: add ReportAddAttachmentModal route

---
 src/pages/media/AttachmentModalScreen/index.tsx | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/pages/media/AttachmentModalScreen/index.tsx b/src/pages/media/AttachmentModalScreen/index.tsx
index f4ce3b373481..749260326f9a 100644
--- a/src/pages/media/AttachmentModalScreen/index.tsx
+++ b/src/pages/media/AttachmentModalScreen/index.tsx
@@ -2,6 +2,7 @@ import React, {useContext, useMemo} from 'react';
 import SCREENS from '@src/SCREENS';
 import AttachmentModalContext from './AttachmentModalContext';
 import ProfileAvatarModalContent from './routes/ProfileAvatarModalContent';
+import ReportAddAttachmentModalContent from './routes/report/ReportAddAttachmentModalContent';
 import ReportAttachmentModalContent from './routes/ReportAttachmentModalContent';
 import ReportAvatarModalContent from './routes/ReportAvatarModalContent';
 import TransactionReceiptModalContent from './routes/TransactionReceiptModalContent';
@@ -35,6 +36,15 @@ function AttachmentModalScreen<Screen extends AttachmentModalScreenType>({route,
         );
     }
 
+    if (route.name === SCREENS.REPORT_ADD_ATTACHMENT) {
+        return (
+            <ReportAddAttachmentModalContent
+                route={routeWithContext as RouteType<typeof SCREENS.REPORT_ADD_ATTACHMENT>}
+                navigation={navigation as NavigationType<typeof SCREENS.REPORT_ADD_ATTACHMENT>}
+            />
+        );
+    }
+
     if (route.name === SCREENS.TRANSACTION_RECEIPT || route.name === SCREENS.MONEY_REQUEST.RECEIPT_PREVIEW) {
         return (
             <TransactionReceiptModalContent

From 2cfac05ced8204791746162712150e4713bfd3ff Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Thu, 4 Sep 2025 13:24:57 +0200
Subject: [PATCH 03/31] fix: remove validation logic in
 ReportAttachmentModalContent

---
 .../routes/ReportAttachmentModalContent.tsx   | 145 ++++--------------
 1 file changed, 27 insertions(+), 118 deletions(-)

diff --git a/src/pages/media/AttachmentModalScreen/routes/ReportAttachmentModalContent.tsx b/src/pages/media/AttachmentModalScreen/routes/ReportAttachmentModalContent.tsx
index 9b49c044395b..2d6655e3fcf9 100644
--- a/src/pages/media/AttachmentModalScreen/routes/ReportAttachmentModalContent.tsx
+++ b/src/pages/media/AttachmentModalScreen/routes/ReportAttachmentModalContent.tsx
@@ -1,33 +1,29 @@
-import {Str} from 'expensify-common';
-import React, {useCallback, useEffect, useMemo, useRef, useState} from 'react';
+import React, {useCallback, useEffect, useMemo, useRef} from 'react';
 import type {View} from 'react-native';
 import type {Attachment} from '@components/Attachments/types';
 import useNetwork from '@hooks/useNetwork';
 import useOnyx from '@hooks/useOnyx';
 import {openReport} from '@libs/actions/Report';
-import validateAttachmentFile from '@libs/AttachmentUtils';
 import ComposerFocusManager from '@libs/ComposerFocusManager';
-import {translateLocal} from '@libs/Localize';
 import Navigation from '@libs/Navigation/Navigation';
 import {isReportNotFound} from '@libs/ReportUtils';
-import tryResolveUrlFromApiRoot from '@libs/tryResolveUrlFromApiRoot';
-import type {AttachmentModalBaseContentProps, OnValidateFileCallback} from '@pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types';
+import type {AttachmentModalBaseContentProps} from '@pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types';
 import AttachmentModalContainer from '@pages/media/AttachmentModalScreen/AttachmentModalContainer';
-import type {AttachmentModalScreenProps, FileObject} from '@pages/media/AttachmentModalScreen/types';
+import type {AttachmentModalScreenProps} from '@pages/media/AttachmentModalScreen/types';
 import CONST from '@src/CONST';
-import type {TranslationPaths} from '@src/languages/types';
 import ONYXKEYS from '@src/ONYXKEYS';
 import ROUTES from '@src/ROUTES';
 import type SCREENS from '@src/SCREENS';
 import {isEmptyObject} from '@src/types/utils/EmptyObject';
-import type ModalType from '@src/types/utils/ModalType';
+import useNavigateToReportOnRefresh from './hooks/useNavigateToReportOnRefresh';
+import useReportAttachmentModalType from './hooks/useReportAttachmentModalType';
 
 function ReportAttachmentModalContent({route, navigation}: AttachmentModalScreenProps<typeof SCREENS.ATTACHMENTS>) {
     const {
         attachmentID,
         type,
-        file: fileParam,
-        source: sourceParam,
+        file,
+        source,
         isAuthTokenRequired,
         attachmentLink,
         originalFileName,
@@ -36,7 +32,6 @@ function ReportAttachmentModalContent({route, navigation}: AttachmentModalScreen
         hashKey,
         shouldDisableSendButton,
         headerTitle,
-        onConfirm,
         onShow,
     } = route.params;
 
@@ -49,12 +44,11 @@ function ReportAttachmentModalContent({route, navigation}: AttachmentModalScreen
         canBeMissing: false,
     });
 
+    useNavigateToReportOnRefresh({source, file, reportID});
+
     const [isLoadingApp] = useOnyx(ONYXKEYS.IS_LOADING_APP, {canBeMissing: true});
     const {isOffline} = useNetwork();
 
-    const [isAttachmentInvalid, setIsAttachmentInvalid] = useState(false);
-    const [attachmentInvalidReason, setAttachmentInvalidReason] = useState<TranslationPaths | null>(null);
-    const [attachmentInvalidReasonTitle, setAttachmentInvalidReasonTitle] = useState<TranslationPaths | null>(null);
     const submitRef = useRef<View | HTMLElement>(null);
 
     // Extract the reportActionID from the attachmentID (format: reportActionID_index)
@@ -72,9 +66,6 @@ function ReportAttachmentModalContent({route, navigation}: AttachmentModalScreen
         return !!isLoadingApp || isEmptyReport || (reportMetadata?.isLoadingInitialReportActions !== false && shouldFetchReport);
     }, [isOffline, reportID, isLoadingApp, report, reportMetadata, shouldFetchReport]);
 
-    const [modalType, setModalType] = useState<ModalType>(CONST.MODAL.MODAL_TYPE.CENTERED_UNSWIPEABLE);
-    const [source, setSource] = useState(() => Number(sourceParam) || (typeof sourceParam === 'string' ? tryResolveUrlFromApiRoot(decodeURIComponent(sourceParam)) : undefined));
-
     const fetchReport = useCallback(() => {
         openReport(reportID, reportActionID);
     }, [reportID, reportActionID]);
@@ -110,93 +101,24 @@ function ReportAttachmentModalContent({route, navigation}: AttachmentModalScreen
         ComposerFocusManager.setReadyToFocus();
     }, []);
 
-    /**
-     * If our attachment is a PDF, return the unswipeable Modal type.
-     */
-    const getModalType = useCallback(
-        (sourceURL: string, fileObject: FileObject) =>
-            sourceURL && (Str.isPDF(sourceURL) || (fileObject && Str.isPDF(fileObject.name ?? translateLocal('attachmentView.unknownFilename'))))
-                ? CONST.MODAL.MODAL_TYPE.CENTERED_UNSWIPEABLE
-                : CONST.MODAL.MODAL_TYPE.CENTERED,
-        [],
-    );
-
-    // Validates the attachment file and renders the appropriate modal type or errors
-    const validateFile: OnValidateFileCallback = useCallback(
-        (file, setFile) => {
-            if (!file) {
-                return;
-            }
-
-            validateAttachmentFile(file).then((result) => {
-                if (!result.isValid) {
-                    const {error} = result;
-
-                    setIsAttachmentInvalid?.(true);
-                    switch (error) {
-                        case 'tooLarge':
-                            setAttachmentInvalidReasonTitle?.('attachmentPicker.attachmentTooLarge');
-                            setAttachmentInvalidReason?.('attachmentPicker.sizeExceeded');
-                            break;
-                        case 'tooSmall':
-                            setAttachmentInvalidReasonTitle?.('attachmentPicker.attachmentTooSmall');
-                            setAttachmentInvalidReason?.('attachmentPicker.sizeNotMet');
-                            break;
-                        case 'fileDoesNotExist':
-                            setAttachmentInvalidReasonTitle?.('attachmentPicker.attachmentError');
-                            setAttachmentInvalidReason?.('attachmentPicker.folderNotAllowedMessage');
-                            break;
-                        case 'fileInvalid':
-                        default:
-                            setAttachmentInvalidReasonTitle?.('attachmentPicker.attachmentError');
-                            setAttachmentInvalidReason?.('attachmentPicker.errorWhileSelectingCorruptedAttachment');
-                    }
-
-                    return;
-                }
-
-                const {source: fileSource} = result;
-                const inputModalType = getModalType(fileSource, file);
-                setModalType(inputModalType);
-                setSource(fileSource);
-                setFile(file);
-            });
-        },
-        [getModalType],
-    );
-
-    const contentTypeProps = useMemo<AttachmentModalBaseContentProps>(
-        () =>
-            fileParam
-                ? {
-                      file: fileParam,
-                      onValidateFile: validateFile,
-                  }
-                : {
-                      // In native the imported images sources are of type number. Ref: https://reactnative.dev/docs/image#imagesource
-                      type,
-                      report,
-                      shouldShowNotFoundPage: !isLoading && type !== CONST.ATTACHMENT_TYPE.SEARCH && !report?.reportID,
-                      allowDownload: true,
-                      isAuthTokenRequired: !!isAuthTokenRequired,
-                      attachmentLink: attachmentLink ?? '',
-                      originalFileName: originalFileName ?? '',
-                      isLoading,
-                  },
-        [attachmentLink, fileParam, isAuthTokenRequired, isLoading, originalFileName, report, type, validateFile],
-    );
+    const modalType = useReportAttachmentModalType(file);
 
     const contentProps = useMemo<AttachmentModalBaseContentProps>(
         () => ({
-            ...contentTypeProps,
+            // In native the imported images sources are of type number. Ref: https://reactnative.dev/docs/image#imagesource
+            type,
+            file,
+            report,
+            shouldShowNotFoundPage: !isLoading && type !== CONST.ATTACHMENT_TYPE.SEARCH && !report?.reportID,
+            allowDownload: true,
+            isAuthTokenRequired: !!isAuthTokenRequired,
+            attachmentLink: attachmentLink ?? '',
+            originalFileName: originalFileName ?? '',
+            isLoading,
             source,
             attachmentID,
             accountID,
-            onConfirm,
             headerTitle,
-            isAttachmentInvalid,
-            attachmentInvalidReasonTitle,
-            attachmentInvalidReason,
             shouldDisableSendButton,
             submitRef,
             onCarouselAttachmentChange,
@@ -204,33 +126,20 @@ function ReportAttachmentModalContent({route, navigation}: AttachmentModalScreen
         [
             accountID,
             attachmentID,
-            attachmentInvalidReason,
-            attachmentInvalidReasonTitle,
-            contentTypeProps,
+            attachmentLink,
+            file,
             headerTitle,
-            isAttachmentInvalid,
+            isAuthTokenRequired,
+            isLoading,
             onCarouselAttachmentChange,
-            onConfirm,
+            originalFileName,
+            report,
             shouldDisableSendButton,
             source,
+            type,
         ],
     );
 
-    // If the user refreshes during the send attachment flow, we need to navigate back to the report or home
-    useEffect(() => {
-        if (!!sourceParam || !!fileParam) {
-            return;
-        }
-
-        Navigation.isNavigationReady().then(() => {
-            if (reportID) {
-                Navigation.goBack(ROUTES.REPORT_WITH_ID.getRoute(reportID));
-            } else {
-                Navigation.goBack(ROUTES.HOME);
-            }
-        });
-    }, [sourceParam, reportID, route.name, fileParam]);
-
     return (
         <AttachmentModalContainer
             navigation={navigation}

From 000fd327c31b735651d6370363b5fabd27c455bd Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Thu, 4 Sep 2025 13:31:30 +0200
Subject: [PATCH 04/31] fix: remove onConfirm callback from
 ReportAttachmentModalContent

---
 src/libs/Navigation/types.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/libs/Navigation/types.ts b/src/libs/Navigation/types.ts
index 15683cdd528f..65a81cdb75e3 100644
--- a/src/libs/Navigation/types.ts
+++ b/src/libs/Navigation/types.ts
@@ -2139,7 +2139,6 @@ type AttachmentModalScreensParamList = {
         maybeIcon?: boolean;
         file?: FileObject;
         shouldDisableSendButton?: boolean;
-        onConfirm?: (file: FileObject) => void;
     };
     [SCREENS.REPORT_ADD_ATTACHMENT]: AttachmentModalContainerModalProps & {
         reportID?: string;

From 667ef398cf4000f8f90b6f50f2e08d01254560f8 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Thu, 4 Sep 2025 13:39:49 +0200
Subject: [PATCH 05/31] fix: ReportAttachmentModalContent

---
 .../routes/ReportAttachmentModalContent.tsx   | 57 +++++--------------
 1 file changed, 14 insertions(+), 43 deletions(-)

diff --git a/src/pages/media/AttachmentModalScreen/routes/ReportAttachmentModalContent.tsx b/src/pages/media/AttachmentModalScreen/routes/ReportAttachmentModalContent.tsx
index 2d6655e3fcf9..067bbdf110e1 100644
--- a/src/pages/media/AttachmentModalScreen/routes/ReportAttachmentModalContent.tsx
+++ b/src/pages/media/AttachmentModalScreen/routes/ReportAttachmentModalContent.tsx
@@ -4,11 +4,12 @@ import type {Attachment} from '@components/Attachments/types';
 import useNetwork from '@hooks/useNetwork';
 import useOnyx from '@hooks/useOnyx';
 import {openReport} from '@libs/actions/Report';
-import ComposerFocusManager from '@libs/ComposerFocusManager';
 import Navigation from '@libs/Navigation/Navigation';
 import {isReportNotFound} from '@libs/ReportUtils';
+import tryResolveUrlFromApiRoot from '@libs/tryResolveUrlFromApiRoot';
 import type {AttachmentModalBaseContentProps} from '@pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types';
 import AttachmentModalContainer from '@pages/media/AttachmentModalScreen/AttachmentModalContainer';
+import useDownloadAttachment from '@pages/media/AttachmentModalScreen/routes/hooks/useDownloadAttachment';
 import type {AttachmentModalScreenProps} from '@pages/media/AttachmentModalScreen/types';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
@@ -18,22 +19,8 @@ import {isEmptyObject} from '@src/types/utils/EmptyObject';
 import useNavigateToReportOnRefresh from './hooks/useNavigateToReportOnRefresh';
 import useReportAttachmentModalType from './hooks/useReportAttachmentModalType';
 
-function ReportAttachmentModalContent({route, navigation}: AttachmentModalScreenProps<typeof SCREENS.ATTACHMENTS>) {
-    const {
-        attachmentID,
-        type,
-        file,
-        source,
-        isAuthTokenRequired,
-        attachmentLink,
-        originalFileName,
-        accountID = CONST.DEFAULT_NUMBER_ID,
-        reportID,
-        hashKey,
-        shouldDisableSendButton,
-        headerTitle,
-        onShow,
-    } = route.params;
+function ReportAttachmentModalContent({route, navigation}: AttachmentModalScreenProps<typeof SCREENS.REPORT_ATTACHMENTS>) {
+    const {attachmentID, type, source: sourceParam, isAuthTokenRequired, attachmentLink, originalFileName, accountID, reportID, hashKey, headerTitle, onShow, onClose} = route.params;
 
     const [report] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT}${reportID}`, {canBeMissing: false});
     const [reportActions] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`, {
@@ -44,7 +31,7 @@ function ReportAttachmentModalContent({route, navigation}: AttachmentModalScreen
         canBeMissing: false,
     });
 
-    useNavigateToReportOnRefresh({source, file, reportID});
+    useNavigateToReportOnRefresh({source: sourceParam, reportID});
 
     const [isLoadingApp] = useOnyx(ONYXKEYS.IS_LOADING_APP, {canBeMissing: true});
     const {isOffline} = useNetwork();
@@ -80,7 +67,7 @@ function ReportAttachmentModalContent({route, navigation}: AttachmentModalScreen
 
     const onCarouselAttachmentChange = useCallback(
         (attachment: Attachment) => {
-            const routeToNavigate = ROUTES.ATTACHMENTS.getRoute({
+            const routeToNavigate = ROUTES.REPORT_ATTACHMENTS.getRoute({
                 reportID,
                 attachmentID: attachment.attachmentID,
                 type,
@@ -96,21 +83,19 @@ function ReportAttachmentModalContent({route, navigation}: AttachmentModalScreen
         [reportID, type, accountID, hashKey],
     );
 
-    const onClose = useCallback(() => {
-        // This enables Composer refocus when the attachments modal is closed by the browser navigation
-        ComposerFocusManager.setReadyToFocus();
-    }, []);
+    const onDownloadAttachment = useDownloadAttachment({
+        isAuthTokenRequired,
+    });
 
-    const modalType = useReportAttachmentModalType(file);
+    const source = useMemo(() => Number(sourceParam) || (typeof sourceParam === 'string' ? tryResolveUrlFromApiRoot(decodeURIComponent(sourceParam)) : undefined), [sourceParam]);
+    const modalType = useReportAttachmentModalType();
 
     const contentProps = useMemo<AttachmentModalBaseContentProps>(
         () => ({
             // In native the imported images sources are of type number. Ref: https://reactnative.dev/docs/image#imagesource
             type,
-            file,
             report,
             shouldShowNotFoundPage: !isLoading && type !== CONST.ATTACHMENT_TYPE.SEARCH && !report?.reportID,
-            allowDownload: true,
             isAuthTokenRequired: !!isAuthTokenRequired,
             attachmentLink: attachmentLink ?? '',
             originalFileName: originalFileName ?? '',
@@ -119,29 +104,15 @@ function ReportAttachmentModalContent({route, navigation}: AttachmentModalScreen
             attachmentID,
             accountID,
             headerTitle,
-            shouldDisableSendButton,
             submitRef,
+            onDownloadAttachment,
             onCarouselAttachmentChange,
         }),
-        [
-            accountID,
-            attachmentID,
-            attachmentLink,
-            file,
-            headerTitle,
-            isAuthTokenRequired,
-            isLoading,
-            onCarouselAttachmentChange,
-            originalFileName,
-            report,
-            shouldDisableSendButton,
-            source,
-            type,
-        ],
+        [accountID, attachmentID, attachmentLink, headerTitle, isAuthTokenRequired, isLoading, onCarouselAttachmentChange, onDownloadAttachment, originalFileName, report, source, type],
     );
 
     return (
-        <AttachmentModalContainer
+        <AttachmentModalContainer<typeof SCREENS.REPORT_ATTACHMENTS>
             navigation={navigation}
             contentProps={contentProps}
             modalType={modalType}

From d8b1bb99b5a65e54b8738e4293235e79383c1262 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Thu, 4 Sep 2025 13:54:10 +0200
Subject: [PATCH 06/31] fix: wrong screen name

---
 .../routes/ReportAttachmentModalContent.tsx               | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/pages/media/AttachmentModalScreen/routes/ReportAttachmentModalContent.tsx b/src/pages/media/AttachmentModalScreen/routes/ReportAttachmentModalContent.tsx
index 067bbdf110e1..d7c900d7f5cd 100644
--- a/src/pages/media/AttachmentModalScreen/routes/ReportAttachmentModalContent.tsx
+++ b/src/pages/media/AttachmentModalScreen/routes/ReportAttachmentModalContent.tsx
@@ -9,17 +9,17 @@ import {isReportNotFound} from '@libs/ReportUtils';
 import tryResolveUrlFromApiRoot from '@libs/tryResolveUrlFromApiRoot';
 import type {AttachmentModalBaseContentProps} from '@pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types';
 import AttachmentModalContainer from '@pages/media/AttachmentModalScreen/AttachmentModalContainer';
-import useDownloadAttachment from '@pages/media/AttachmentModalScreen/routes/hooks/useDownloadAttachment';
 import type {AttachmentModalScreenProps} from '@pages/media/AttachmentModalScreen/types';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
 import ROUTES from '@src/ROUTES';
 import type SCREENS from '@src/SCREENS';
 import {isEmptyObject} from '@src/types/utils/EmptyObject';
+import useDownloadAttachment from './hooks/useDownloadAttachment';
 import useNavigateToReportOnRefresh from './hooks/useNavigateToReportOnRefresh';
 import useReportAttachmentModalType from './hooks/useReportAttachmentModalType';
 
-function ReportAttachmentModalContent({route, navigation}: AttachmentModalScreenProps<typeof SCREENS.REPORT_ATTACHMENTS>) {
+function ReportAttachmentModalContent({route, navigation}: AttachmentModalScreenProps<typeof SCREENS.ATTACHMENTS>) {
     const {attachmentID, type, source: sourceParam, isAuthTokenRequired, attachmentLink, originalFileName, accountID, reportID, hashKey, headerTitle, onShow, onClose} = route.params;
 
     const [report] = useOnyx(`${ONYXKEYS.COLLECTION.REPORT}${reportID}`, {canBeMissing: false});
@@ -67,7 +67,7 @@ function ReportAttachmentModalContent({route, navigation}: AttachmentModalScreen
 
     const onCarouselAttachmentChange = useCallback(
         (attachment: Attachment) => {
-            const routeToNavigate = ROUTES.REPORT_ATTACHMENTS.getRoute({
+            const routeToNavigate = ROUTES.ATTACHMENTS.getRoute({
                 reportID,
                 attachmentID: attachment.attachmentID,
                 type,
@@ -112,7 +112,7 @@ function ReportAttachmentModalContent({route, navigation}: AttachmentModalScreen
     );
 
     return (
-        <AttachmentModalContainer<typeof SCREENS.REPORT_ATTACHMENTS>
+        <AttachmentModalContainer<typeof SCREENS.ATTACHMENTS>
             navigation={navigation}
             contentProps={contentProps}
             modalType={modalType}

From 89b9b1ac3940fd2f657e584b0cf73aab097c2147 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Mon, 8 Sep 2025 13:39:55 +0200
Subject: [PATCH 07/31] refactor: simplify threeDotsMenuItems prop
 implementation

---
 .../AttachmentModalBaseContent/index.tsx      | 23 ++++---------------
 .../AttachmentModalBaseContent/types.ts       | 14 ++---------
 2 files changed, 6 insertions(+), 31 deletions(-)

diff --git a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
index 8132599b4451..fa5e24d77fe8 100644
--- a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
+++ b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
@@ -13,7 +13,6 @@ import FullScreenLoadingIndicator from '@components/FullscreenLoadingIndicator';
 import HeaderGap from '@components/HeaderGap';
 import HeaderWithBackButton from '@components/HeaderWithBackButton';
 import * as Illustrations from '@components/Icon/Illustrations';
-import type {PopoverMenuItem} from '@components/PopoverMenu';
 import SafeAreaConsumer from '@components/SafeAreaConsumer';
 import useLocalize from '@hooks/useLocalize';
 import useNetwork from '@hooks/useNetwork';
@@ -125,24 +124,10 @@ function AttachmentModalBaseContent({
         [onCarouselAttachmentChange, setFile],
     );
 
-    const threeDotsMenuItems = useMemo(() => {
-        const menuItems: PopoverMenuItem[] = [];
-
-        threeDotsMenuItemsProp?.forEach((menuItem) => {
-            if (typeof menuItem === 'function') {
-                const generatedMenuItem = menuItem({file: fileToDisplay, source, isLocalSource});
-                if (generatedMenuItem) {
-                    menuItems.push(generatedMenuItem);
-                }
-
-                return;
-            }
-
-            menuItems.push(menuItem);
-        });
-
-        return menuItems;
-    }, [fileToDisplay, isLocalSource, source, threeDotsMenuItemsProp]);
+    const threeDotsMenuItems = useMemo(
+        () => (typeof threeDotsMenuItemsProp === 'function' ? threeDotsMenuItemsProp({file: fileToDisplay, source, isLocalSource}) : (threeDotsMenuItemsProp ?? [])),
+        [fileToDisplay, isLocalSource, source, threeDotsMenuItemsProp],
+    );
 
     const [isDownloadButtonReadyToBeShown, setIsDownloadButtonReadyToBeShown] = useState(true);
     const setDownloadButtonVisibility = useCallback(
diff --git a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts
index df02e71d60a9..7d7b9996d1ed 100644
--- a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts
+++ b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts
@@ -22,8 +22,6 @@ type AttachmentModalContentData = {
 type ThreeDotsMenuItemGeneratorProps = AttachmentModalContentData & {
     isLocalSource: boolean;
 };
-type ThreeDotsMenuItemGenerator = (props: ThreeDotsMenuItemGeneratorProps) => PopoverMenuItem | undefined;
-
 type DownloadAttachmentCallback = (props: AttachmentModalContentData) => void;
 
 type AttachmentContentProps = {
@@ -58,7 +56,7 @@ type AttachmentModalBaseContentProps = {
     headerTitle?: string;
 
     /** The menu items for the three dots button */
-    threeDotsMenuItems?: Array<PopoverMenuItem | ThreeDotsMenuItemGenerator>;
+    threeDotsMenuItems?: PopoverMenuItem[] | ((props: ThreeDotsMenuItemGeneratorProps) => PopoverMenuItem[]);
 
     /** The report that has this attachment */
     report?: OnyxEntry<OnyxTypes.Report>;
@@ -120,12 +118,4 @@ type AttachmentModalBaseContentProps = {
     onCarouselAttachmentChange?: (attachment: Attachment) => void;
 };
 
-export type {
-    AttachmentModalBaseContentProps,
-    AttachmentModalOnCloseOptions,
-    ThreeDotsMenuItemGeneratorProps,
-    ThreeDotsMenuItemGenerator,
-    DownloadAttachmentCallback,
-    AttachmentContent,
-    AttachmentContentProps,
-};
+export type {AttachmentModalBaseContentProps, AttachmentModalOnCloseOptions, DownloadAttachmentCallback, AttachmentContent, AttachmentContentProps};

From 248939d533f9eeeecb0370b6bca0637149b52d95 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Sat, 13 Sep 2025 14:11:08 +0200
Subject: [PATCH 08/31] fix: integrate file upload validation into
 useFilesValidation

---
 src/hooks/useFilesValidation.tsx              |  58 +++++---
 src/libs/Navigation/types.ts                  |   1 +
 .../ReportActionCompose.tsx                   |   5 +-
 .../routes/hooks/useFileUploadValidation.ts   |  89 -----------
 .../ReportAddAttachmentModalContent.tsx       | 140 ++++++++++++------
 5 files changed, 136 insertions(+), 157 deletions(-)
 delete mode 100644 src/pages/media/AttachmentModalScreen/routes/hooks/useFileUploadValidation.ts

diff --git a/src/hooks/useFilesValidation.tsx b/src/hooks/useFilesValidation.tsx
index 7eeaab51944d..6b5fd7fdafee 100644
--- a/src/hooks/useFilesValidation.tsx
+++ b/src/hooks/useFilesValidation.tsx
@@ -6,6 +6,7 @@ import {useFullScreenLoader} from '@components/FullScreenLoaderContext';
 import PDFThumbnail from '@components/PDFThumbnail';
 import Text from '@components/Text';
 import TextLink from '@components/TextLink';
+import {validateAttachmentFile, validateMultipleAttachmentFiles} from '@libs/AttachmentValidation';
 import type {MultipleAttachmentsValidationError, SingleAttachmentValidationError} from '@libs/AttachmentValidation';
 import {
     getFileValidationErrorText,
@@ -31,13 +32,13 @@ const sortFilesByOriginalOrder = (files: FileObject[], orderMap: Map<string, num
     return files.sort((a, b) => (orderMap.get(a.uri ?? '') ?? 0) - (orderMap.get(b.uri ?? '') ?? 0));
 };
 
-function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => void, isValidatingReceipts = true) {
+function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isValidatingReceipts = true) {
     const styles = useThemeStyles();
     const {translate} = useLocalize();
     const [isErrorModalVisible, setIsErrorModalVisible] = useState(false);
     const [fileError, setFileError] = useState<SingleAttachmentValidationError | MultipleAttachmentsValidationError>();
     const [pdfFilesToRender, setPdfFilesToRender] = useState<FileObject[]>([]);
-    const [validFilesToUpload, setValidFilesToUpload] = useState([] as FileObject[]);
+    const [validFilesToUpload, setValidFilesToUpload] = useState<FileObject[]>([]);
     const [isValidatingMultipleFiles, setIsValidatingMultipleFiles] = useState(false);
     const [invalidFileExtension, setInvalidFileExtension] = useState('');
     const [errorQueue, setErrorQueue] = useState<ErrorObject[]>([]);
@@ -170,10 +171,10 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
             }
         } else if (validFiles.current.length > 0) {
             const sortedFiles = sortFilesByOriginalOrder(validFiles.current, originalFileOrder.current);
-            proceedWithFilesAction(sortedFiles);
+            onFilesValidated(sortedFiles);
             resetValidationState();
         }
-    }, [deduplicateErrors, pdfFilesToRender.length, proceedWithFilesAction, resetValidationState]);
+    }, [deduplicateErrors, pdfFilesToRender.length, onFilesValidated, resetValidationState]);
 
     const validateAndResizeFiles = (files: FileObject[], items: DataTransferItem[]) => {
         // Early return for empty files
@@ -258,26 +259,47 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
                         }
                     } else if (processedFiles.length > 0) {
                         const sortedFiles = sortFilesByOriginalOrder(processedFiles, originalFileOrder.current);
-                        proceedWithFilesAction(sortedFiles);
+                        onFilesValidated(sortedFiles);
                         resetValidationState();
                     }
                 }
             });
     };
 
-    const validateFiles = (files: FileObject[], items?: DataTransferItem[]) => {
-        if (files.length > 1) {
+    const validateFiles = (files: File | FileObject[], items?: DataTransferItem[]) => {
+        if (!files) {
+            return;
+        }
+
+        if (Array.isArray(files)) {
             setIsValidatingMultipleFiles(true);
+
+            validateMultipleAttachmentFiles(files).then((result) => {
+                if (result.isValid) {
+                    validateAndResizeFiles(result.validatedFiles, items ?? []);
+                    return;
+                }
+
+                if (result.error === CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED) {
+                    filesToValidate.current = files.slice(0, CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT);
+                    if (items) {
+                        dataTransferItemList.current = items.slice(0, CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT);
+                    }
+                }
+
+                setErrorAndOpenModal(result.error);
+            });
+            return;
         }
-        if (files.length > CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT) {
-            filesToValidate.current = files.slice(0, CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT);
-            if (items) {
-                dataTransferItemList.current = items.slice(0, CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT);
+
+        validateAttachmentFile(files).then((result) => {
+            if (result.isValid) {
+                validateAndResizeFiles([result.validatedFile.file], items ?? []);
+                return;
             }
-            setErrorAndOpenModal(CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED);
-        } else {
-            validateAndResizeFiles(files, items ?? []);
-        }
+
+            setErrorAndOpenModal(result.error);
+        });
     };
 
     const onConfirm = () => {
@@ -308,13 +330,13 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
             setIsErrorModalVisible(false);
             InteractionManager.runAfterInteractions(() => {
                 if (sortedFiles.length !== 0) {
-                    proceedWithFilesAction(sortedFiles);
+                    onFilesValidated(sortedFiles);
                 }
                 resetValidationState();
             });
         } else {
             if (sortedFiles.length !== 0) {
-                proceedWithFilesAction(sortedFiles);
+                onFilesValidated(sortedFiles);
             }
             hideModalAndReset();
         }
@@ -379,8 +401,8 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
     );
 
     return {
-        PDFValidationComponent,
         validateFiles,
+        PDFValidationComponent,
         ErrorModal,
     };
 }
diff --git a/src/libs/Navigation/types.ts b/src/libs/Navigation/types.ts
index 8ab472fc3e43..198572a85254 100644
--- a/src/libs/Navigation/types.ts
+++ b/src/libs/Navigation/types.ts
@@ -2156,6 +2156,7 @@ type AttachmentModalScreensParamList = {
         attachmentID?: string;
         source?: AvatarSource;
         file?: FileObject | FileObject[];
+        dataTransferItems?: DataTransferItem[];
         type?: ValueOf<typeof CONST.ATTACHMENT_TYPE>;
         isAuthTokenRequired?: boolean;
         originalFileName?: string;
diff --git a/src/pages/home/report/ReportActionCompose/ReportActionCompose.tsx b/src/pages/home/report/ReportActionCompose/ReportActionCompose.tsx
index e260e0112bd6..a7f29af75fd4 100644
--- a/src/pages/home/report/ReportActionCompose/ReportActionCompose.tsx
+++ b/src/pages/home/report/ReportActionCompose/ReportActionCompose.tsx
@@ -492,10 +492,11 @@ function ReportActionCompose({
 
     const reportAttachmentsContext = useContext(AttachmentModalContext);
     const showAttachmentModalScreen = useCallback(
-        (file: FileObject | FileObject[]) => {
+        (file: FileObject | FileObject[], dataTransferItems?: DataTransferItem[]) => {
             reportAttachmentsContext.setCurrentAttachment<typeof SCREENS.REPORT_ADD_ATTACHMENT>({
                 reportID,
                 file,
+                dataTransferItems,
                 headerTitle: translate('reportActionCompose.sendAttachment'),
                 onConfirm: addAttachment,
                 onShow: () => setIsAttachmentPreviewActive(true),
@@ -522,7 +523,7 @@ function ReportActionCompose({
             return;
         }
 
-        showAttachmentModalScreen(files);
+        showAttachmentModalScreen(files, Array.from(event.dataTransfer?.items ?? []));
     };
 
     const saveFileAndInitMoneyRequest = (files: FileObject[]) => {
diff --git a/src/pages/media/AttachmentModalScreen/routes/hooks/useFileUploadValidation.ts b/src/pages/media/AttachmentModalScreen/routes/hooks/useFileUploadValidation.ts
deleted file mode 100644
index f638f12691da..000000000000
--- a/src/pages/media/AttachmentModalScreen/routes/hooks/useFileUploadValidation.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-import {useCallback, useEffect, useState} from 'react';
-import {InteractionManager} from 'react-native';
-import type {
-    MultipleAttachmentsInvalidResult,
-    MultipleAttachmentsValidationError,
-    MultipleAttachmentsValidResult,
-    SingleAttachmentInvalidResult,
-    SingleAttachmentValidationError,
-    SingleAttachmentValidResult,
-} from '@libs/AttachmentValidation';
-import {validateAttachmentFile, validateMultipleAttachmentFiles} from '@libs/AttachmentValidation';
-import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
-import CONST from '@src/CONST';
-
-type UseFileUploadValidationProps = {
-    files: FileObject | FileObject[] | undefined;
-    onValid?: (result: SingleAttachmentValidResult | MultipleAttachmentsValidResult) => void;
-    onInvalid?: (result: SingleAttachmentInvalidResult | MultipleAttachmentsInvalidResult) => void;
-};
-
-function useFileUploadValidation({files, onValid, onInvalid}: UseFileUploadValidationProps) {
-    const [validFilesToUpload, setValidFilesToUpload] = useState<FileObject | FileObject[]>();
-    const [fileError, setFileError] = useState<SingleAttachmentValidationError | MultipleAttachmentsValidationError>();
-    const [isFileErrorModalVisible, setIsFileErrorModalVisible] = useState(false);
-
-    // Validates the attachment file and renders the appropriate modal type or errors
-    const validateFile = useCallback(
-        (file: FileObject | FileObject[]) => {
-            if (!file) {
-                return;
-            }
-
-            if (Array.isArray(file)) {
-                validateMultipleAttachmentFiles(file).then((result) => {
-                    if (result.isValid) {
-                        const validFiles = result.validatedFiles.map((f) => f.file);
-                        setValidFilesToUpload(validFiles);
-                        onValid?.(result);
-                        return;
-                    }
-
-                    setFileError(result.error);
-                    setIsFileErrorModalVisible(true);
-
-                    if (result.error === CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED) {
-                        const validFiles = file.slice(0, CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT);
-                        setValidFilesToUpload(validFiles);
-                    }
-
-                    onInvalid?.(result);
-                });
-                return;
-            }
-
-            validateAttachmentFile(file).then((result) => {
-                if (result.isValid) {
-                    const {validatedFile} = result;
-                    setValidFilesToUpload(validatedFile.file);
-
-                    onValid?.(result);
-                    return;
-                }
-
-                const {error} = result;
-                setFileError(error);
-
-                onInvalid?.(result);
-            });
-        },
-        [onInvalid, onValid],
-    );
-
-    useEffect(() => {
-        if (!files) {
-            return;
-        }
-
-        setIsFileErrorModalVisible(false);
-        InteractionManager.runAfterInteractions(() => {
-            setFileError(undefined);
-        });
-
-        validateFile(files);
-    }, [files, validateFile]);
-
-    return {validFilesToUpload, fileError, isFileErrorModalVisible};
-}
-
-export default useFileUploadValidation;
diff --git a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
index 9bd2534ebf99..248c92ac9f46 100644
--- a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
+++ b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
@@ -4,19 +4,17 @@ import AttachmentCarouselView from '@components/Attachments/AttachmentCarousel/A
 import useCarouselArrows from '@components/Attachments/AttachmentCarousel/useCarouselArrows';
 import useAttachmentErrors from '@components/Attachments/AttachmentView/useAttachmentErrors';
 import type {Attachment} from '@components/Attachments/types';
-import ConfirmModal from '@components/ConfirmModal';
-import useLocalize from '@hooks/useLocalize';
+import useFilesValidation from '@hooks/useFilesValidation';
 import useNetwork from '@hooks/useNetwork';
 import useOnyx from '@hooks/useOnyx';
 import {openReport} from '@libs/actions/Report';
 import {isMultipleAttachmentsValidationResult, isSingleAttachmentValidationResult} from '@libs/AttachmentValidation';
-import {getFileValidationErrorText} from '@libs/fileDownload/FileUtils';
+import {cleanFileName} from '@libs/fileDownload/FileUtils';
 import {isReportNotFound} from '@libs/ReportUtils';
 import tryResolveUrlFromApiRoot from '@libs/tryResolveUrlFromApiRoot';
 import type {AttachmentContentProps, AttachmentModalBaseContentProps} from '@pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types';
 import AttachmentModalContainer from '@pages/media/AttachmentModalScreen/AttachmentModalContainer';
 import useDownloadAttachment from '@pages/media/AttachmentModalScreen/routes/hooks/useDownloadAttachment';
-import useFileUploadValidation from '@pages/media/AttachmentModalScreen/routes/hooks/useFileUploadValidation';
 import useNavigateToReportOnRefresh from '@pages/media/AttachmentModalScreen/routes/hooks/useNavigateToReportOnRefresh';
 import useReportAttachmentModalType from '@pages/media/AttachmentModalScreen/routes/hooks/useReportAttachmentModalType';
 import type {AttachmentModalScreenProps, FileObject} from '@pages/media/AttachmentModalScreen/types';
@@ -25,6 +23,32 @@ import ONYXKEYS from '@src/ONYXKEYS';
 import type SCREENS from '@src/SCREENS';
 import {isEmptyObject} from '@src/types/utils/EmptyObject';
 
+function cleanFileObject(fileObject: FileObject): FileObject {
+    if ('getAsFile' in fileObject && typeof fileObject.getAsFile === 'function') {
+        return fileObject.getAsFile() as FileObject;
+    }
+
+    return fileObject;
+}
+
+function cleanFileObjectName(fileObject: FileObject): FileObject {
+    if (fileObject instanceof File) {
+        const cleanName = cleanFileName(fileObject.name);
+        if (fileObject.name !== cleanName) {
+            const updatedFile = new File([fileObject], cleanName, {type: fileObject.type});
+            const inputSource = URL.createObjectURL(updatedFile);
+            updatedFile.uri = inputSource;
+            return updatedFile;
+        }
+        if (!fileObject.uri) {
+            const inputSource = URL.createObjectURL(fileObject);
+            // eslint-disable-next-line no-param-reassign
+            fileObject.uri = inputSource;
+        }
+    }
+    return fileObject;
+}
+
 const convertFileToAttachment = (file: FileObject | undefined): Attachment => {
     if (!file) {
         return {source: ''};
@@ -40,6 +64,7 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
     const {
         attachmentID,
         file,
+        dataTransferItems,
         source: sourceParam,
         isAuthTokenRequired,
         attachmentLink,
@@ -66,7 +91,6 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
 
     const [isLoadingApp] = useOnyx(ONYXKEYS.IS_LOADING_APP, {canBeMissing: true});
     const {isOffline} = useNetwork();
-    const {translate} = useLocalize();
 
     const submitRef = useRef<View | HTMLElement>(null);
 
@@ -90,18 +114,51 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
     }, [reportID, fetchReport, shouldFetchReport]);
 
     const [source, setSource] = useState(() => Number(sourceParam) || (typeof sourceParam === 'string' ? tryResolveUrlFromApiRoot(decodeURIComponent(sourceParam)) : undefined));
-    const [filesToValidate, setFilesToValidate] = useState(() => file);
-    const {validFilesToUpload, fileError, isFileErrorModalVisible} = useFileUploadValidation({
-        files: filesToValidate,
-        onValid: (result) => {
-            if (isSingleAttachmentValidationResult(result)) {
-                setSource(result.validatedFile.source);
-            } else if (isMultipleAttachmentsValidationResult(result)) {
-                setSource(result.validatedFiles.at(0)?.source);
-            }
-        },
-    });
-    const isMultipleFiles = useMemo(() => Array.isArray(validFilesToUpload) && validFilesToUpload.length > 0, [validFilesToUpload]);
+    const [validFilesToUpload, setValidFilesToUpload] = useState<FileObject[]>([]);
+
+    const onFilesValidated = useCallback((files: FileObject[]) => {
+        setValidFilesToUpload(files);
+
+        if (isSingleAttachmentValidationResult(result)) {
+            setSource(result.validatedFile.source);
+        } else if (isMultipleAttachmentsValidationResult(result)) {
+            setSource(result.validatedFiles.at(0)?.source);
+        }
+    }, []);
+
+    const {ErrorModal, validateFiles, PDFValidationComponent} = useFilesValidation(onFilesValidated, false);
+
+    useEffect(() => {
+        if (!file) {
+            return;
+        }
+
+        const files = Array.isArray(file) ? file : [file];
+        if (files.length === 0) {
+            return;
+        }
+
+        const validIndices: number[] = [];
+        const fileObjects = files
+            .map((item, index) => {
+                const fileObject = cleanFileObject(item);
+                const cleanedFileObject = cleanFileObjectName(fileObject);
+                if (cleanedFileObject !== null) {
+                    validIndices.push(index);
+                }
+                return cleanedFileObject;
+            })
+            .filter((fileObject) => fileObject !== null);
+
+        if (!fileObjects.length) {
+            return;
+        }
+
+        // Create a filtered items array that matches the fileObjects
+        const filteredItems = dataTransferItems && validIndices.length > 0 ? validIndices.map((index) => dataTransferItems.at(index) ?? ({} as DataTransferItem)) : undefined;
+
+        validateFiles(fileObjects, filteredItems);
+    }, [dataTransferItems, file, validateFiles]);
 
     const modalType = useReportAttachmentModalType(validFilesToUpload ?? file);
 
@@ -133,29 +190,13 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
         );
     }, [isOffline, report, reportID, isLoadingApp, reportMetadata?.isLoadingInitialReportActions, shouldFetchReport, validFilesToUpload]);
 
-    const confirmAndContinue = useCallback(() => {
-        if (fileError !== CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED) {
-            return;
-        }
+    // const confirmAndContinue = useCallback(() => {
+    //     if (fileError !== CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED) {
+    //         return;
+    //     }
 
-        setFilesToValidate(file);
-    }, [fileError, file]);
-
-    const ExtraModals = useMemo(
-        () => (
-            <ConfirmModal
-                title={getFileValidationErrorText(fileError).title}
-                onConfirm={() => confirmAndContinue()}
-                onCancel={navigation.goBack}
-                isVisible={isFileErrorModalVisible}
-                prompt={getFileValidationErrorText(fileError).reason}
-                confirmText={translate(isMultipleFiles ? 'common.continue' : 'common.close')}
-                shouldShowCancelButton={isMultipleFiles}
-                cancelText={translate('common.cancel')}
-            />
-        ),
-        [confirmAndContinue, fileError, isFileErrorModalVisible, isMultipleFiles, navigation.goBack, translate],
-    );
+    //     setFilesToValidate(file);
+    // }, [fileError, file]);
 
     const contentProps = useMemo<AttachmentModalBaseContentProps>(() => {
         if (validFilesToUpload === undefined) {
@@ -180,10 +221,10 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
             onConfirm,
             onDownloadAttachment,
             AttachmentContent: AddAttachmentModalCarouselView,
-            ExtraModals,
+            ExtraModals: ErrorModal,
         };
     }, [
-        ExtraModals,
+        ErrorModal,
         accountID,
         attachmentID,
         attachmentLink,
@@ -199,13 +240,16 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
     ]);
 
     return (
-        <AttachmentModalContainer
-            navigation={navigation}
-            contentProps={contentProps}
-            modalType={modalType}
-            onShow={onShow}
-            onClose={onClose}
-        />
+        <>
+            {PDFValidationComponent}
+            <AttachmentModalContainer
+                navigation={navigation}
+                contentProps={contentProps}
+                modalType={modalType}
+                onShow={onShow}
+                onClose={onClose}
+            />
+        </>
     );
 }
 ReportAddAttachmentModalContent.displayName = 'ReportAddAttachmentModalContent';

From c9351f24ff47940f16c2083042db70d95961b66e Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Mon, 15 Sep 2025 10:37:05 +0100
Subject: [PATCH 09/31] refactor: rename CONST keys for AttachmentModal
 validation errors

---
 src/CONST/index.ts                            | 31 ++++++++++---------
 src/hooks/useFilesValidation.tsx              | 16 +++++-----
 src/libs/AttachmentValidation.ts              | 20 ++++++------
 src/libs/fileDownload/FileUtils.ts            | 24 +++++++-------
 .../ReportAddAttachmentModalContent.tsx       |  2 +-
 tests/unit/FileUtilsTest.ts                   | 10 +++---
 6 files changed, 52 insertions(+), 51 deletions(-)

diff --git a/src/CONST/index.ts b/src/CONST/index.ts
index 15e229a2f37e..2222159262da 100755
--- a/src/CONST/index.ts
+++ b/src/CONST/index.ts
@@ -1992,21 +1992,22 @@ const CONST = {
         VIDEO: /\.(mov|mp4)$/,
     },
 
-    SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS: {
-        NO_FILE_PROVIDED: 'noFileProvided',
-        FILE_INVALID: 'fileInvalid',
-        WRONG_FILE_TYPE: 'wrongFileType',
-        FILE_TOO_LARGE: 'fileTooLarge',
-        FILE_TOO_SMALL: 'fileTooSmall',
-        FILE_CORRUPTED: 'fileCorrupted',
-        PROTECTED_FILE: 'protectedFile',
-    },
-
-    MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS: {
-        WRONG_FILE_TYPE: 'multipleAttachmentsWrongFileType',
-        FILE_TOO_LARGE: 'multipleAttachmentsFileTooLarge',
-        FOLDER_NOT_ALLOWED: 'multipleAttachmentsFolderNotAllowed',
-        MAX_FILE_LIMIT_EXCEEDED: 'multipleAttachmentsMaxFileLimitExceeded',
+    ATTACHMENT_VALIDATION_ERRORS: {
+        SINGLE_FILE: {
+            NO_FILE_PROVIDED: 'noFileProvided',
+            FILE_INVALID: 'fileInvalid',
+            WRONG_FILE_TYPE: 'wrongFileType',
+            FILE_TOO_LARGE: 'fileTooLarge',
+            FILE_TOO_SMALL: 'fileTooSmall',
+            FILE_CORRUPTED: 'fileCorrupted',
+            PROTECTED_FILE: 'protectedFile',
+        },
+        MULTIPLE_FILES: {
+            WRONG_FILE_TYPE: 'multipleAttachmentsWrongFileType',
+            FILE_TOO_LARGE: 'multipleAttachmentsFileTooLarge',
+            FOLDER_NOT_ALLOWED: 'multipleAttachmentsFolderNotAllowed',
+            MAX_FILE_LIMIT_EXCEEDED: 'multipleAttachmentsMaxFileLimitExceeded',
+        },
     },
 
     IOS_CAMERA_ROLL_ACCESS_ERROR: 'Access to photo library was denied',
diff --git a/src/hooks/useFilesValidation.tsx b/src/hooks/useFilesValidation.tsx
index 6b5fd7fdafee..939c7be3842b 100644
--- a/src/hooks/useFilesValidation.tsx
+++ b/src/hooks/useFilesValidation.tsx
@@ -106,7 +106,7 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
             const entry = item.webkitGetAsEntry();
 
             if (entry?.isDirectory) {
-                collectedErrors.current.push({error: CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.FOLDER_NOT_ALLOWED});
+                collectedErrors.current.push({error: CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FOLDER_NOT_ALLOWED});
                 return Promise.resolve(false);
             }
         }
@@ -119,7 +119,7 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
                         const errorData = {
                             error,
                             fileExtension:
-                                error === CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.WRONG_FILE_TYPE ? splitExtensionFromFileName(normalizedFile.name ?? '').fileExtension : undefined,
+                                error === CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.WRONG_FILE_TYPE ? splitExtensionFromFileName(normalizedFile.name ?? '').fileExtension : undefined,
                         };
                         collectedErrors.current.push(errorData);
                         return false;
@@ -128,7 +128,7 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
                 }),
             )
             .catch(() => {
-                collectedErrors.current.push({error: CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_CORRUPTED});
+                collectedErrors.current.push({error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_CORRUPTED});
                 return false;
             });
     };
@@ -280,7 +280,7 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
                     return;
                 }
 
-                if (result.error === CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED) {
+                if (result.error === CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.MAX_FILE_LIMIT_EXCEEDED) {
                     filesToValidate.current = files.slice(0, CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT);
                     if (items) {
                         dataTransferItemList.current = items.slice(0, CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT);
@@ -303,7 +303,7 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
     };
 
     const onConfirm = () => {
-        if (fileError === CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED) {
+        if (fileError === CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.MAX_FILE_LIMIT_EXCEEDED) {
             setIsErrorModalVisible(false);
             validateAndResizeFiles(filesToValidate.current, dataTransferItemList.current);
             return;
@@ -356,7 +356,7 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
                   onPassword={() => {
                       validatedPDFs.current.push(file);
                       if (isValidatingReceipts) {
-                          collectedErrors.current.push({error: CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.PROTECTED_FILE});
+                          collectedErrors.current.push({error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.PROTECTED_FILE});
                       } else {
                           validFiles.current.push(file);
                       }
@@ -364,7 +364,7 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
                   }}
                   onLoadError={() => {
                       validatedPDFs.current.push(file);
-                      collectedErrors.current.push({error: CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_CORRUPTED});
+                      collectedErrors.current.push({error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_CORRUPTED});
                       checkIfAllValidatedAndProceed();
                   }}
               />
@@ -376,7 +376,7 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
             return '';
         }
         const prompt = getFileValidationErrorText(fileError, {fileType: invalidFileExtension}, isValidatingReceipts).reason;
-        if (fileError === CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.WRONG_FILE_TYPE || fileError === CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE) {
+        if (fileError === CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.WRONG_FILE_TYPE || fileError === CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.WRONG_FILE_TYPE) {
             return (
                 <Text>
                     {prompt}
diff --git a/src/libs/AttachmentValidation.ts b/src/libs/AttachmentValidation.ts
index d1aa53a384bd..dbc86ac38904 100644
--- a/src/libs/AttachmentValidation.ts
+++ b/src/libs/AttachmentValidation.ts
@@ -14,7 +14,7 @@ type SingleAttachmentValidResult = {
     validatedFile: ValidatedFile;
 };
 
-type SingleAttachmentValidationError = ValueOf<typeof CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS>;
+type SingleAttachmentValidationError = ValueOf<typeof CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE>;
 type SingleAttachmentInvalidResult = {
     isValid: false;
     error: SingleAttachmentValidationError;
@@ -28,7 +28,7 @@ function isSingleAttachmentValidationResult(result: unknown): result is SingleAt
 
 function validateAttachmentFile(file: FileObject): Promise<SingleAttachmentValidationResult> {
     if (!file) {
-        return Promise.resolve({isValid: false, error: CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.NO_FILE_PROVIDED});
+        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.NO_FILE_PROVIDED});
     }
 
     let fileObject = file;
@@ -36,7 +36,7 @@ function validateAttachmentFile(file: FileObject): Promise<SingleAttachmentValid
         fileObject = file.getAsFile() as FileObject;
     }
     if (!fileObject) {
-        return Promise.resolve({isValid: false, error: CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_INVALID});
+        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_INVALID});
     }
 
     return isFileCorrupted(fileObject).then((corruptionResult) => {
@@ -83,7 +83,7 @@ type MultipleAttachmentsValidResult = {
     validatedFiles: ValidatedFile[];
 };
 
-type MultipleAttachmentsValidationError = ValueOf<typeof CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS>;
+type MultipleAttachmentsValidationError = ValueOf<typeof CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES>;
 type MultipleAttachmentsInvalidResult = {
     isValid: false;
     error: MultipleAttachmentsValidationError;
@@ -97,11 +97,11 @@ function isMultipleAttachmentsValidationResult(result: unknown): result is Multi
 
 function validateMultipleAttachmentFiles(files: FileObject[]): Promise<MultipleAttachmentsValidationResult> {
     if (!files?.length || files.some((f) => isDirectory(f))) {
-        return Promise.resolve({isValid: false, error: CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.FOLDER_NOT_ALLOWED, fileResults: []});
+        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FOLDER_NOT_ALLOWED, fileResults: []});
     }
 
     if (files.length > CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT) {
-        return Promise.resolve({isValid: false, error: CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED, fileResults: []});
+        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.MAX_FILE_LIMIT_EXCEEDED, fileResults: []});
     }
 
     return Promise.all(files.map((f) => validateAttachmentFile(f))).then((results) => {
@@ -114,7 +114,7 @@ function validateMultipleAttachmentFiles(files: FileObject[]): Promise<MultipleA
 
         return {
             isValid: false,
-            error: CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.WRONG_FILE_TYPE,
+            error: CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.WRONG_FILE_TYPE,
             fileResults: results,
         };
     });
@@ -127,14 +127,14 @@ function isFileCorrupted(fileObject: FileObject): Promise<SingleAttachmentValida
                 if (normalizedFile.size && normalizedFile.size > CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE) {
                     return {
                         isValid: false,
-                        error: CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_LARGE,
+                        error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE,
                     } as SingleAttachmentInvalidResult;
                 }
 
                 if (normalizedFile.size && normalizedFile.size < CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE) {
                     return {
                         isValid: false,
-                        error: CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_SMALL,
+                        error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL,
                     } as SingleAttachmentInvalidResult;
                 }
 
@@ -145,7 +145,7 @@ function isFileCorrupted(fileObject: FileObject): Promise<SingleAttachmentValida
             .catch(() => {
                 return {
                     isValid: false,
-                    error: CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_INVALID,
+                    error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_INVALID,
                 } as SingleAttachmentInvalidResult;
             });
     });
diff --git a/src/libs/fileDownload/FileUtils.ts b/src/libs/fileDownload/FileUtils.ts
index 58625e279b7c..7b1eae8feb81 100644
--- a/src/libs/fileDownload/FileUtils.ts
+++ b/src/libs/fileDownload/FileUtils.ts
@@ -555,15 +555,15 @@ const validateAttachment = (file: FileObject, isCheckingMultipleFiles?: boolean,
     const maxFileSize = isValidatingReceipt ? CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE : CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE;
 
     if (!Str.isImage(file.name ?? '') && !isHeicOrHeifImage(file) && (file?.size ?? 0) > maxFileSize) {
-        return isCheckingMultipleFiles ? CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.FILE_TOO_LARGE : CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_LARGE;
+        return isCheckingMultipleFiles ? CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FILE_TOO_LARGE : CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE;
     }
 
     if (isValidatingReceipt && (file?.size ?? 0) < CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE) {
-        return CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_SMALL;
+        return CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL;
     }
 
     if (isValidatingReceipt && !isValidReceiptExtension(file)) {
-        return isCheckingMultipleFiles ? CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.WRONG_FILE_TYPE : CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE;
+        return isCheckingMultipleFiles ? CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.WRONG_FILE_TYPE : CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.WRONG_FILE_TYPE;
     }
     return '';
 };
@@ -590,17 +590,17 @@ const getFileValidationErrorText = (
     }
     const maxSize = isValidatingReceipt ? CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE : CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE;
     switch (validationError) {
-        case CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE:
+        case CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.WRONG_FILE_TYPE:
             return {
                 title: translateLocal('attachmentPicker.wrongFileType'),
                 reason: translateLocal('attachmentPicker.notAllowedExtension'),
             };
-        case CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.WRONG_FILE_TYPE:
+        case CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.WRONG_FILE_TYPE:
             return {
                 title: translateLocal('attachmentPicker.someFilesCantBeUploaded'),
                 reason: translateLocal('attachmentPicker.unsupportedFileType', {fileType: additionalData.fileType ?? ''}),
             };
-        case CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_LARGE:
+        case CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE:
             return {
                 title: translateLocal('attachmentPicker.attachmentTooLarge'),
                 reason: isValidatingReceipt
@@ -609,34 +609,34 @@ const getFileValidationErrorText = (
                       })
                     : translateLocal('attachmentPicker.sizeExceeded'),
             };
-        case CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.FILE_TOO_LARGE:
+        case CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FILE_TOO_LARGE:
             return {
                 title: translateLocal('attachmentPicker.someFilesCantBeUploaded'),
                 reason: translateLocal('attachmentPicker.sizeLimitExceeded', {
                     maxUploadSizeInMB: additionalData.maxUploadSizeInMB ?? maxSize / 1024 / 1024,
                 }),
             };
-        case CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_SMALL:
+        case CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL:
             return {
                 title: translateLocal('attachmentPicker.attachmentTooSmall'),
                 reason: translateLocal('attachmentPicker.sizeNotMet'),
             };
-        case CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.FOLDER_NOT_ALLOWED:
+        case CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FOLDER_NOT_ALLOWED:
             return {
                 title: translateLocal('attachmentPicker.attachmentError'),
                 reason: translateLocal('attachmentPicker.folderNotAllowedMessage'),
             };
-        case CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED:
+        case CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.MAX_FILE_LIMIT_EXCEEDED:
             return {
                 title: translateLocal('attachmentPicker.someFilesCantBeUploaded'),
                 reason: translateLocal('attachmentPicker.maxFileLimitExceeded'),
             };
-        case CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_CORRUPTED:
+        case CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_CORRUPTED:
             return {
                 title: translateLocal('attachmentPicker.attachmentError'),
                 reason: translateLocal('attachmentPicker.errorWhileSelectingCorruptedAttachment'),
             };
-        case CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.PROTECTED_FILE:
+        case CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.PROTECTED_FILE:
             return {
                 title: translateLocal('attachmentPicker.attachmentError'),
                 reason: translateLocal('attachmentPicker.protectedPDFNotSupported'),
diff --git a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
index 248c92ac9f46..8e870519a8be 100644
--- a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
+++ b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
@@ -191,7 +191,7 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
     }, [isOffline, report, reportID, isLoadingApp, reportMetadata?.isLoadingInitialReportActions, shouldFetchReport, validFilesToUpload]);
 
     // const confirmAndContinue = useCallback(() => {
-    //     if (fileError !== CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED) {
+    //     if (fileError !== CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.MAX_FILE_LIMIT_EXCEEDED) {
     //         return;
     //     }
 
diff --git a/tests/unit/FileUtilsTest.ts b/tests/unit/FileUtilsTest.ts
index cc918ea520f4..cdf43a53beca 100644
--- a/tests/unit/FileUtilsTest.ts
+++ b/tests/unit/FileUtilsTest.ts
@@ -48,31 +48,31 @@ describe('FileUtils', () => {
         it('should not return FILE_TOO_SMALL when validating small attachment', () => {
             const file = createMockFile('file.csv', CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE - 1);
             const error = FileUtils.validateAttachment(file, false, false);
-            expect(error).not.toBe(CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_SMALL);
+            expect(error).not.toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL);
         });
 
         it('should return FILE_TOO_SMALL when validating small receipt', () => {
             const file = createMockFile('receipt.jpg', CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE - 1);
             const error = FileUtils.validateAttachment(file, false, true);
-            expect(error).toBe(CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_SMALL);
+            expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL);
         });
 
         it('should return FILE_TOO_LARGE for large non-image file', () => {
             const file = createMockFile('file.pdf', CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE + 1);
             const error = FileUtils.validateAttachment(file);
-            expect(error).toBe(CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.FILE_TOO_LARGE);
+            expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE);
         });
 
         it('should return FILE_TOO_LARGE_MULTIPLE when checking multiple files', () => {
             const file = createMockFile('file.pdf', CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE + 1);
             const error = FileUtils.validateAttachment(file, true);
-            expect(error).toBe(CONST.MULTIPLE_ATTACHMENT_FILES_VALIDATION_ERRORS.FILE_TOO_LARGE);
+            expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FILE_TOO_LARGE);
         });
 
         it('should return WRONG_FILE_TYPE for invalid receipt extension', () => {
             const file = createMockFile('receipt.exe', CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE - 1);
             const error = FileUtils.validateAttachment(file, false, true);
-            expect(error).toBe(CONST.SINGLE_ATTACHMENT_FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE);
+            expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.WRONG_FILE_TYPE);
         });
 
         it('should return empty string for valid image receipt', () => {

From c55551b86389ad8d4db7e00c1132ea380b810f54 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Mon, 15 Sep 2025 10:37:16 +0100
Subject: [PATCH 10/31] fix: error modal not shown

---
 src/hooks/useFilesValidation.tsx                   |  4 +++-
 .../report/ReportAddAttachmentModalContent.tsx     | 14 +-------------
 2 files changed, 4 insertions(+), 14 deletions(-)

diff --git a/src/hooks/useFilesValidation.tsx b/src/hooks/useFilesValidation.tsx
index 939c7be3842b..38383f1366fc 100644
--- a/src/hooks/useFilesValidation.tsx
+++ b/src/hooks/useFilesValidation.tsx
@@ -32,7 +32,7 @@ const sortFilesByOriginalOrder = (files: FileObject[], orderMap: Map<string, num
     return files.sort((a, b) => (orderMap.get(a.uri ?? '') ?? 0) - (orderMap.get(b.uri ?? '') ?? 0));
 };
 
-function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isValidatingReceipts = true) {
+function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isValidatingReceipts = true, onSourceChanged?: (source: string | undefined) => void) {
     const styles = useThemeStyles();
     const {translate} = useLocalize();
     const [isErrorModalVisible, setIsErrorModalVisible] = useState(false);
@@ -277,6 +277,7 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
             validateMultipleAttachmentFiles(files).then((result) => {
                 if (result.isValid) {
                     validateAndResizeFiles(result.validatedFiles, items ?? []);
+                    onSourceChanged?.(result.validatedFiles.at(0)?.source);
                     return;
                 }
 
@@ -295,6 +296,7 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
         validateAttachmentFile(files).then((result) => {
             if (result.isValid) {
                 validateAndResizeFiles([result.validatedFile.file], items ?? []);
+                onSourceChanged?.(result.validatedFile.source);
                 return;
             }
 
diff --git a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
index 8e870519a8be..36541d4376b9 100644
--- a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
+++ b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
@@ -8,7 +8,6 @@ import useFilesValidation from '@hooks/useFilesValidation';
 import useNetwork from '@hooks/useNetwork';
 import useOnyx from '@hooks/useOnyx';
 import {openReport} from '@libs/actions/Report';
-import {isMultipleAttachmentsValidationResult, isSingleAttachmentValidationResult} from '@libs/AttachmentValidation';
 import {cleanFileName} from '@libs/fileDownload/FileUtils';
 import {isReportNotFound} from '@libs/ReportUtils';
 import tryResolveUrlFromApiRoot from '@libs/tryResolveUrlFromApiRoot';
@@ -115,18 +114,7 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
 
     const [source, setSource] = useState(() => Number(sourceParam) || (typeof sourceParam === 'string' ? tryResolveUrlFromApiRoot(decodeURIComponent(sourceParam)) : undefined));
     const [validFilesToUpload, setValidFilesToUpload] = useState<FileObject[]>([]);
-
-    const onFilesValidated = useCallback((files: FileObject[]) => {
-        setValidFilesToUpload(files);
-
-        if (isSingleAttachmentValidationResult(result)) {
-            setSource(result.validatedFile.source);
-        } else if (isMultipleAttachmentsValidationResult(result)) {
-            setSource(result.validatedFiles.at(0)?.source);
-        }
-    }, []);
-
-    const {ErrorModal, validateFiles, PDFValidationComponent} = useFilesValidation(onFilesValidated, false);
+    const {ErrorModal, validateFiles, PDFValidationComponent} = useFilesValidation(setValidFilesToUpload, false, setSource);
 
     useEffect(() => {
         if (!file) {

From 6c0205750750bcc4cb618d566f38d7988ca2e9dd Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Tue, 16 Sep 2025 18:52:30 +0100
Subject: [PATCH 11/31] rename test names

---
 tests/unit/FileUtilsTest.ts | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/tests/unit/FileUtilsTest.ts b/tests/unit/FileUtilsTest.ts
index cdf43a53beca..3fd533f28080 100644
--- a/tests/unit/FileUtilsTest.ts
+++ b/tests/unit/FileUtilsTest.ts
@@ -45,31 +45,31 @@ describe('FileUtils', () => {
     });
 
     describe('validateAttachment', () => {
-        it('should not return FILE_TOO_SMALL when validating small attachment', () => {
+        it('should not return SINGLE_FILE.FILE_TOO_SMALL when validating small attachment', () => {
             const file = createMockFile('file.csv', CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE - 1);
             const error = FileUtils.validateAttachment(file, false, false);
             expect(error).not.toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL);
         });
 
-        it('should return FILE_TOO_SMALL when validating small receipt', () => {
+        it('should return SINGLE_FILE.FILE_TOO_SMALL when validating small receipt', () => {
             const file = createMockFile('receipt.jpg', CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE - 1);
             const error = FileUtils.validateAttachment(file, false, true);
             expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL);
         });
 
-        it('should return FILE_TOO_LARGE for large non-image file', () => {
+        it('should return SINGLE_FILE.FILE_TOO_LARGE for large non-image file', () => {
             const file = createMockFile('file.pdf', CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE + 1);
             const error = FileUtils.validateAttachment(file);
             expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE);
         });
 
-        it('should return FILE_TOO_LARGE_MULTIPLE when checking multiple files', () => {
+        it('should return MULTIPLE_FILES.FILE_TOO_LARGE when checking multiple files', () => {
             const file = createMockFile('file.pdf', CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE + 1);
             const error = FileUtils.validateAttachment(file, true);
             expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FILE_TOO_LARGE);
         });
 
-        it('should return WRONG_FILE_TYPE for invalid receipt extension', () => {
+        it('should return SINGLE_FILE.WRONG_FILE_TYPE for invalid receipt extension', () => {
             const file = createMockFile('receipt.exe', CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE - 1);
             const error = FileUtils.validateAttachment(file, false, true);
             expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.WRONG_FILE_TYPE);

From 2afa42054cafd0a62db1b36f9a6476d1180a9687 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Tue, 16 Sep 2025 19:52:46 +0100
Subject: [PATCH 12/31] refactor: move `validateAttachment` logic to
 `AttachmentValidation` lib

---
 src/libs/AttachmentValidation.ts   | 28 ++++++++++++++++++++++++++--
 src/libs/fileDownload/FileUtils.ts | 18 ------------------
 2 files changed, 26 insertions(+), 20 deletions(-)

diff --git a/src/libs/AttachmentValidation.ts b/src/libs/AttachmentValidation.ts
index dbc86ac38904..acde7ef59c9c 100644
--- a/src/libs/AttachmentValidation.ts
+++ b/src/libs/AttachmentValidation.ts
@@ -1,7 +1,8 @@
+import {Str} from 'expensify-common';
 import type {ValueOf} from 'type-fest';
 import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
 import CONST from '@src/CONST';
-import {cleanFileName, normalizeFileObject, validateImageForCorruption} from './fileDownload/FileUtils';
+import {cleanFileName, isHeicOrHeifImage, isValidReceiptExtension, normalizeFileObject, validateImageForCorruption} from './fileDownload/FileUtils';
 
 type ValidatedFile = {
     fileType: 'file' | 'uri';
@@ -26,19 +27,42 @@ function isSingleAttachmentValidationResult(result: unknown): result is SingleAt
     return typeof result === 'object' && result !== null && 'isValid' in result && typeof result.isValid === 'boolean' && ('validatedFile' in result || 'error' in result);
 }
 
-function validateAttachmentFile(file: FileObject): Promise<SingleAttachmentValidationResult> {
+function validateAttachmentFile(file: FileObject, item?: DataTransferItem, isValidatingReceipt?: boolean): Promise<SingleAttachmentValidationResult> {
     if (!file) {
         return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.NO_FILE_PROVIDED});
     }
 
+    const maxFileSize = isValidatingReceipt ? CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE : CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE;
+
+    if (!Str.isImage(file.name ?? '') && !isHeicOrHeifImage(file) && (file?.size ?? 0) > maxFileSize) {
+        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE});
+    }
+
+    if (isValidatingReceipt && (file?.size ?? 0) < CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE) {
+        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL});
+    }
+
+    if (isValidatingReceipt && !isValidReceiptExtension(file)) {
+        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.WRONG_FILE_TYPE});
+    }
+
     let fileObject = file;
     if ('getAsFile' in file && typeof file.getAsFile === 'function') {
         fileObject = file.getAsFile() as FileObject;
     }
+
     if (!fileObject) {
         return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_INVALID});
     }
 
+    if (item && item.kind === 'file' && 'webkitGetAsEntry' in item) {
+        const entry = item.webkitGetAsEntry();
+
+        if (entry?.isDirectory) {
+            return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FOLDER_NOT_ALLOWED});
+        }
+    }
+
     return isFileCorrupted(fileObject).then((corruptionResult) => {
         if (!corruptionResult.isValid) {
             return corruptionResult;
diff --git a/src/libs/fileDownload/FileUtils.ts b/src/libs/fileDownload/FileUtils.ts
index 7b1eae8feb81..bf22bb6f763b 100644
--- a/src/libs/fileDownload/FileUtils.ts
+++ b/src/libs/fileDownload/FileUtils.ts
@@ -551,23 +551,6 @@ const normalizeFileObject = (file: FileObject): Promise<FileObject> => {
         });
 };
 
-const validateAttachment = (file: FileObject, isCheckingMultipleFiles?: boolean, isValidatingReceipt?: boolean) => {
-    const maxFileSize = isValidatingReceipt ? CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE : CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE;
-
-    if (!Str.isImage(file.name ?? '') && !isHeicOrHeifImage(file) && (file?.size ?? 0) > maxFileSize) {
-        return isCheckingMultipleFiles ? CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FILE_TOO_LARGE : CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE;
-    }
-
-    if (isValidatingReceipt && (file?.size ?? 0) < CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE) {
-        return CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL;
-    }
-
-    if (isValidatingReceipt && !isValidReceiptExtension(file)) {
-        return isCheckingMultipleFiles ? CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.WRONG_FILE_TYPE : CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.WRONG_FILE_TYPE;
-    }
-    return '';
-};
-
 type TranslationAdditionalData = {
     maxUploadSizeInMB?: number;
     fileLimit?: number;
@@ -681,7 +664,6 @@ export {
     resizeImageIfNeeded,
     createFile,
     validateReceipt,
-    validateAttachment,
     normalizeFileObject,
     isValidReceiptExtension,
     getFileValidationErrorText,

From 4a63bd49b8e6a9cc2520d636e602e9cdbcf10c45 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Tue, 16 Sep 2025 19:52:56 +0100
Subject: [PATCH 13/31] test: update tests according to changes in FileUtils

---
 tests/unit/AttachmentValidationTest.ts | 49 ++++++++++++++++++++++++++
 tests/unit/FileUtilsTest.ts            | 43 ----------------------
 2 files changed, 49 insertions(+), 43 deletions(-)
 create mode 100644 tests/unit/AttachmentValidationTest.ts

diff --git a/tests/unit/AttachmentValidationTest.ts b/tests/unit/AttachmentValidationTest.ts
new file mode 100644
index 000000000000..3dea2216ba1e
--- /dev/null
+++ b/tests/unit/AttachmentValidationTest.ts
@@ -0,0 +1,49 @@
+import {validateAttachmentFile} from '@libs/AttachmentValidation';
+import CONST from '../../src/CONST';
+
+jest.useFakeTimers();
+
+const createMockFile = (name: string, size: number) => ({
+    name,
+    size,
+});
+
+describe('AttachmentValidation', () => {
+    describe('validateAttachment', () => {
+        it('should not return SINGLE_FILE.FILE_TOO_SMALL when validating small attachment', () => {
+            const file = createMockFile('file.csv', CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE - 1);
+            const error = validateAttachmentFile(file, false, false);
+            expect(error).not.toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL);
+        });
+
+        it('should return SINGLE_FILE.FILE_TOO_SMALL when validating small receipt', () => {
+            const file = createMockFile('receipt.jpg', CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE - 1);
+            const error = validateAttachmentFile(file, false, true);
+            expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL);
+        });
+
+        it('should return SINGLE_FILE.FILE_TOO_LARGE for large non-image file', () => {
+            const file = createMockFile('file.pdf', CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE + 1);
+            const error = validateAttachmentFile(file);
+            expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE);
+        });
+
+        it('should return MULTIPLE_FILES.FILE_TOO_LARGE when checking multiple files', () => {
+            const file = createMockFile('file.pdf', CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE + 1);
+            const error = validateAttachmentFile(file, true);
+            expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FILE_TOO_LARGE);
+        });
+
+        it('should return SINGLE_FILE.WRONG_FILE_TYPE for invalid receipt extension', () => {
+            const file = createMockFile('receipt.exe', CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE - 1);
+            const error = validateAttachmentFile(file, false, true);
+            expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.WRONG_FILE_TYPE);
+        });
+
+        it('should return empty string for valid image receipt', () => {
+            const file = createMockFile('receipt.jpg', CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE - 1);
+            const error = validateAttachmentFile(file, false, true);
+            expect(error).toBe('');
+        });
+    });
+});
diff --git a/tests/unit/FileUtilsTest.ts b/tests/unit/FileUtilsTest.ts
index 3fd533f28080..a5f4f34fe913 100644
--- a/tests/unit/FileUtilsTest.ts
+++ b/tests/unit/FileUtilsTest.ts
@@ -4,11 +4,6 @@ import * as FileUtils from '../../src/libs/fileDownload/FileUtils';
 
 jest.useFakeTimers();
 
-const createMockFile = (name: string, size: number) => ({
-    name,
-    size,
-});
-
 describe('FileUtils', () => {
     describe('splitExtensionFromFileName', () => {
         it('should return correct file name and extension', () => {
@@ -43,42 +38,4 @@ describe('FileUtils', () => {
             expect(actualFileName).toEqual(expectedFileName.replace(CONST.REGEX.ILLEGAL_FILENAME_CHARACTERS, '_'));
         });
     });
-
-    describe('validateAttachment', () => {
-        it('should not return SINGLE_FILE.FILE_TOO_SMALL when validating small attachment', () => {
-            const file = createMockFile('file.csv', CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE - 1);
-            const error = FileUtils.validateAttachment(file, false, false);
-            expect(error).not.toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL);
-        });
-
-        it('should return SINGLE_FILE.FILE_TOO_SMALL when validating small receipt', () => {
-            const file = createMockFile('receipt.jpg', CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE - 1);
-            const error = FileUtils.validateAttachment(file, false, true);
-            expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL);
-        });
-
-        it('should return SINGLE_FILE.FILE_TOO_LARGE for large non-image file', () => {
-            const file = createMockFile('file.pdf', CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE + 1);
-            const error = FileUtils.validateAttachment(file);
-            expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE);
-        });
-
-        it('should return MULTIPLE_FILES.FILE_TOO_LARGE when checking multiple files', () => {
-            const file = createMockFile('file.pdf', CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE + 1);
-            const error = FileUtils.validateAttachment(file, true);
-            expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FILE_TOO_LARGE);
-        });
-
-        it('should return SINGLE_FILE.WRONG_FILE_TYPE for invalid receipt extension', () => {
-            const file = createMockFile('receipt.exe', CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE - 1);
-            const error = FileUtils.validateAttachment(file, false, true);
-            expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.WRONG_FILE_TYPE);
-        });
-
-        it('should return empty string for valid image receipt', () => {
-            const file = createMockFile('receipt.jpg', CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE - 1);
-            const error = FileUtils.validateAttachment(file, false, true);
-            expect(error).toBe('');
-        });
-    });
 });

From ca2820d8c973b117334237868e7f0ff2324d1afe Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Tue, 16 Sep 2025 19:53:10 +0100
Subject: [PATCH 14/31] fix: attachment file validation

---
 src/hooks/useFilesValidation.tsx | 55 ++++++++------------------------
 1 file changed, 13 insertions(+), 42 deletions(-)

diff --git a/src/hooks/useFilesValidation.tsx b/src/hooks/useFilesValidation.tsx
index 38383f1366fc..37ed510a5eed 100644
--- a/src/hooks/useFilesValidation.tsx
+++ b/src/hooks/useFilesValidation.tsx
@@ -8,15 +8,7 @@ import Text from '@components/Text';
 import TextLink from '@components/TextLink';
 import {validateAttachmentFile, validateMultipleAttachmentFiles} from '@libs/AttachmentValidation';
 import type {MultipleAttachmentsValidationError, SingleAttachmentValidationError} from '@libs/AttachmentValidation';
-import {
-    getFileValidationErrorText,
-    isHeicOrHeifImage,
-    normalizeFileObject,
-    resizeImageIfNeeded,
-    splitExtensionFromFileName,
-    validateAttachment,
-    validateImageForCorruption,
-} from '@libs/fileDownload/FileUtils';
+import {getFileValidationErrorText, isHeicOrHeifImage, resizeImageIfNeeded} from '@libs/fileDownload/FileUtils';
 import convertHeicImage from '@libs/fileDownload/heicConverter';
 import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
 import CONST from '@src/CONST';
@@ -101,38 +93,6 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
         setIsErrorModalVisible(true);
     };
 
-    const isValidFile = (originalFile: FileObject, item: DataTransferItem | undefined, isCheckingMultipleFiles?: boolean) => {
-        if (item && item.kind === 'file' && 'webkitGetAsEntry' in item) {
-            const entry = item.webkitGetAsEntry();
-
-            if (entry?.isDirectory) {
-                collectedErrors.current.push({error: CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FOLDER_NOT_ALLOWED});
-                return Promise.resolve(false);
-            }
-        }
-
-        return normalizeFileObject(originalFile)
-            .then((normalizedFile) =>
-                validateImageForCorruption(normalizedFile).then(() => {
-                    const error = validateAttachment(normalizedFile, isCheckingMultipleFiles, isValidatingReceipts);
-                    if (error) {
-                        const errorData = {
-                            error,
-                            fileExtension:
-                                error === CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.WRONG_FILE_TYPE ? splitExtensionFromFileName(normalizedFile.name ?? '').fileExtension : undefined,
-                        };
-                        collectedErrors.current.push(errorData);
-                        return false;
-                    }
-                    return true;
-                }),
-            )
-            .catch(() => {
-                collectedErrors.current.push({error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_CORRUPTED});
-                return false;
-            });
-    };
-
     const convertHeicImageToJpegPromise = (file: FileObject): Promise<FileObject> => {
         return new Promise((resolve, reject) => {
             convertHeicImage(file, {
@@ -189,7 +149,18 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
             originalFileOrder.current.set(file.uri ?? '', index);
         });
 
-        Promise.all(files.map((file, index) => isValidFile(file, items.at(index), files.length > 1).then((isValid) => (isValid ? file : null))))
+        Promise.all(
+            files.map((file, index) =>
+                validateAttachmentFile(file, items.at(index)).then((result) => {
+                    if (result.isValid) {
+                        onSourceChanged?.(result.validatedFile.source);
+                        return file;
+                    }
+                    collectedErrors.current.push({error: result.error});
+                    return null;
+                }),
+            ),
+        )
             .then((validationResults) => {
                 const filteredResults = validationResults.filter((result): result is FileObject => result !== null);
                 const pdfsToLoad = filteredResults.filter((file) => Str.isPDF(file.name ?? ''));

From d4ac8be404c27df9df97b8b3758d1e4b6a12cbc0 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Tue, 16 Sep 2025 19:53:23 +0100
Subject: [PATCH 15/31] refactor: move CONST keys for more order

---
 src/CONST/index.ts | 38 +++++++++++++++++++-------------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/src/CONST/index.ts b/src/CONST/index.ts
index b608de7c05e1..ab9c2ee5d043 100755
--- a/src/CONST/index.ts
+++ b/src/CONST/index.ts
@@ -265,6 +265,25 @@ const CONST = {
         MAX_FILE_LIMIT: 30,
     },
 
+    ATTACHMENT_VALIDATION_ERRORS: {
+        SINGLE_FILE: {
+            NO_FILE_PROVIDED: 'noFileProvided',
+            FILE_INVALID: 'fileInvalid',
+            WRONG_FILE_TYPE: 'wrongFileType',
+            FILE_TOO_LARGE: 'fileTooLarge',
+            FILE_TOO_SMALL: 'fileTooSmall',
+            FILE_CORRUPTED: 'fileCorrupted',
+            PROTECTED_FILE: 'protectedFile',
+            FOLDER_NOT_ALLOWED: 'folderNotAllowed',
+        },
+        MULTIPLE_FILES: {
+            WRONG_FILE_TYPE: 'multipleAttachmentsWrongFileType',
+            FILE_TOO_LARGE: 'multipleAttachmentsFileTooLarge',
+            FOLDER_NOT_ALLOWED: 'multipleAttachmentsFolderNotAllowed',
+            MAX_FILE_LIMIT_EXCEEDED: 'multipleAttachmentsMaxFileLimitExceeded',
+        },
+    },
+
     // Allowed extensions for spreadsheets import
     ALLOWED_SPREADSHEET_EXTENSIONS: ['xls', 'xlsx', 'csv', 'txt'],
 
@@ -1991,25 +2010,6 @@ const CONST = {
         // Video MimeTypes allowed by iOS photos app.
         VIDEO: /\.(mov|mp4)$/,
     },
-
-    ATTACHMENT_VALIDATION_ERRORS: {
-        SINGLE_FILE: {
-            NO_FILE_PROVIDED: 'noFileProvided',
-            FILE_INVALID: 'fileInvalid',
-            WRONG_FILE_TYPE: 'wrongFileType',
-            FILE_TOO_LARGE: 'fileTooLarge',
-            FILE_TOO_SMALL: 'fileTooSmall',
-            FILE_CORRUPTED: 'fileCorrupted',
-            PROTECTED_FILE: 'protectedFile',
-        },
-        MULTIPLE_FILES: {
-            WRONG_FILE_TYPE: 'multipleAttachmentsWrongFileType',
-            FILE_TOO_LARGE: 'multipleAttachmentsFileTooLarge',
-            FOLDER_NOT_ALLOWED: 'multipleAttachmentsFolderNotAllowed',
-            MAX_FILE_LIMIT_EXCEEDED: 'multipleAttachmentsMaxFileLimitExceeded',
-        },
-    },
-
     IOS_CAMERA_ROLL_ACCESS_ERROR: 'Access to photo library was denied',
     ADD_PAYMENT_MENU_POSITION_Y: 226,
     ADD_PAYMENT_MENU_POSITION_X: 356,

From 0adee50e92e64cf90a9a28185cd47a418c4d8b4f Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Tue, 16 Sep 2025 23:43:21 +0100
Subject: [PATCH 16/31] feat: check for HEIC or HEIF image errors

---
 src/CONST/index.ts               |  1 +
 src/libs/AttachmentValidation.ts | 10 ++++++++--
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/CONST/index.ts b/src/CONST/index.ts
index ab9c2ee5d043..c9e0e909d014 100755
--- a/src/CONST/index.ts
+++ b/src/CONST/index.ts
@@ -275,6 +275,7 @@ const CONST = {
             FILE_CORRUPTED: 'fileCorrupted',
             PROTECTED_FILE: 'protectedFile',
             FOLDER_NOT_ALLOWED: 'folderNotAllowed',
+            HEIC_OR_HEIF_IMAGE: 'heicOrHeifImage',
         },
         MULTIPLE_FILES: {
             WRONG_FILE_TYPE: 'multipleAttachmentsWrongFileType',
diff --git a/src/libs/AttachmentValidation.ts b/src/libs/AttachmentValidation.ts
index acde7ef59c9c..bb3a04f66b65 100644
--- a/src/libs/AttachmentValidation.ts
+++ b/src/libs/AttachmentValidation.ts
@@ -34,8 +34,14 @@ function validateAttachmentFile(file: FileObject, item?: DataTransferItem, isVal
 
     const maxFileSize = isValidatingReceipt ? CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE : CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE;
 
-    if (!Str.isImage(file.name ?? '') && !isHeicOrHeifImage(file) && (file?.size ?? 0) > maxFileSize) {
-        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE});
+    const isImage = Str.isImage(file.name ?? '');
+
+    if (isImage && isHeicOrHeifImage(file)) {
+        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.HEIC_OR_HEIF_IMAGE, file});
+    }
+
+    if (!isImage && !isHeicOrHeifImage(file) && (file?.size ?? 0) > maxFileSize) {
+        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE, file});
     }
 
     if (isValidatingReceipt && (file?.size ?? 0) < CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE) {

From e3955ce98104263464542e6983c84233dd8badcf Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Tue, 16 Sep 2025 23:43:37 +0100
Subject: [PATCH 17/31] refactor: remove unnecessary prop

---
 .../routes/report/ReportAddAttachmentModalContent.tsx            | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
index 36541d4376b9..2b37cd069a9f 100644
--- a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
+++ b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
@@ -195,7 +195,6 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
 
         return {
             file: validFilesToUpload,
-            fileToDisplayIndex: 0,
             source,
             isLoading,
             isAuthTokenRequired,

From 4100f3551913bf8fc30dd1e95dc21e9b6cf43791 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Tue, 16 Sep 2025 23:44:02 +0100
Subject: [PATCH 18/31] feat: add files to validation results

---
 src/libs/AttachmentValidation.ts | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/src/libs/AttachmentValidation.ts b/src/libs/AttachmentValidation.ts
index bb3a04f66b65..a83d2dc89a01 100644
--- a/src/libs/AttachmentValidation.ts
+++ b/src/libs/AttachmentValidation.ts
@@ -19,6 +19,7 @@ type SingleAttachmentValidationError = ValueOf<typeof CONST.ATTACHMENT_VALIDATIO
 type SingleAttachmentInvalidResult = {
     isValid: false;
     error: SingleAttachmentValidationError;
+    file: FileObject;
 };
 
 type SingleAttachmentValidationResult = SingleAttachmentValidResult | SingleAttachmentInvalidResult;
@@ -29,7 +30,7 @@ function isSingleAttachmentValidationResult(result: unknown): result is SingleAt
 
 function validateAttachmentFile(file: FileObject, item?: DataTransferItem, isValidatingReceipt?: boolean): Promise<SingleAttachmentValidationResult> {
     if (!file) {
-        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.NO_FILE_PROVIDED});
+        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.NO_FILE_PROVIDED, file});
     }
 
     const maxFileSize = isValidatingReceipt ? CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE : CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE;
@@ -45,11 +46,11 @@ function validateAttachmentFile(file: FileObject, item?: DataTransferItem, isVal
     }
 
     if (isValidatingReceipt && (file?.size ?? 0) < CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE) {
-        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL});
+        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL, file});
     }
 
     if (isValidatingReceipt && !isValidReceiptExtension(file)) {
-        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.WRONG_FILE_TYPE});
+        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.WRONG_FILE_TYPE, file});
     }
 
     let fileObject = file;
@@ -58,14 +59,14 @@ function validateAttachmentFile(file: FileObject, item?: DataTransferItem, isVal
     }
 
     if (!fileObject) {
-        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_INVALID});
+        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_INVALID, file});
     }
 
     if (item && item.kind === 'file' && 'webkitGetAsEntry' in item) {
         const entry = item.webkitGetAsEntry();
 
         if (entry?.isDirectory) {
-            return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FOLDER_NOT_ALLOWED});
+            return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FOLDER_NOT_ALLOWED, file});
         }
     }
 
@@ -118,6 +119,7 @@ type MultipleAttachmentsInvalidResult = {
     isValid: false;
     error: MultipleAttachmentsValidationError;
     fileResults: SingleAttachmentValidationResult[];
+    files: FileObject[];
 };
 type MultipleAttachmentsValidationResult = MultipleAttachmentsValidResult | MultipleAttachmentsInvalidResult;
 
@@ -125,16 +127,16 @@ function isMultipleAttachmentsValidationResult(result: unknown): result is Multi
     return typeof result === 'object' && result !== null && 'isValid' in result && typeof result.isValid === 'boolean' && ('validatedFiles' in result || 'fileResults' in result);
 }
 
-function validateMultipleAttachmentFiles(files: FileObject[]): Promise<MultipleAttachmentsValidationResult> {
+function validateMultipleAttachmentFiles(files: FileObject[], items?: DataTransferItem[]): Promise<MultipleAttachmentsValidationResult> {
     if (!files?.length || files.some((f) => isDirectory(f))) {
-        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FOLDER_NOT_ALLOWED, fileResults: []});
+        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FOLDER_NOT_ALLOWED, fileResults: [], files});
     }
 
     if (files.length > CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT) {
-        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.MAX_FILE_LIMIT_EXCEEDED, fileResults: []});
+        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.MAX_FILE_LIMIT_EXCEEDED, fileResults: [], files});
     }
 
-    return Promise.all(files.map((f) => validateAttachmentFile(f))).then((results) => {
+    return Promise.all(files.map((f, index) => validateAttachmentFile(f, items?.at(index)))).then((results) => {
         if (results.every((result) => result.isValid)) {
             return {
                 isValid: true,
@@ -146,6 +148,7 @@ function validateMultipleAttachmentFiles(files: FileObject[]): Promise<MultipleA
             isValid: false,
             error: CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.WRONG_FILE_TYPE,
             fileResults: results,
+            files,
         };
     });
 }

From beb2ded168acd6141ec7bef65d63f84a39ebd150 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Tue, 16 Sep 2025 23:44:13 +0100
Subject: [PATCH 19/31] refactor: useFilesValidation

---
 src/hooks/useFilesValidation.tsx | 192 +++++++++++++++++--------------
 1 file changed, 103 insertions(+), 89 deletions(-)

diff --git a/src/hooks/useFilesValidation.tsx b/src/hooks/useFilesValidation.tsx
index 37ed510a5eed..16ff0c5b9679 100644
--- a/src/hooks/useFilesValidation.tsx
+++ b/src/hooks/useFilesValidation.tsx
@@ -7,7 +7,7 @@ import PDFThumbnail from '@components/PDFThumbnail';
 import Text from '@components/Text';
 import TextLink from '@components/TextLink';
 import {validateAttachmentFile, validateMultipleAttachmentFiles} from '@libs/AttachmentValidation';
-import type {MultipleAttachmentsValidationError, SingleAttachmentValidationError} from '@libs/AttachmentValidation';
+import type {MultipleAttachmentsValidationError, SingleAttachmentInvalidResult, SingleAttachmentValidationError} from '@libs/AttachmentValidation';
 import {getFileValidationErrorText, isHeicOrHeifImage, resizeImageIfNeeded} from '@libs/fileDownload/FileUtils';
 import convertHeicImage from '@libs/fileDownload/heicConverter';
 import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
@@ -136,105 +136,108 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
         }
     }, [deduplicateErrors, pdfFilesToRender.length, onFilesValidated, resetValidationState]);
 
-    const validateAndResizeFiles = (files: FileObject[], items: DataTransferItem[]) => {
-        // Early return for empty files
-        if (files.length === 0) {
-            return;
-        }
-
-        // Reset collected errors for new validation
-        collectedErrors.current = [];
+    const convertAndResizeFiles = (invalidResults: SingleAttachmentInvalidResult[], files: FileObject[]) => {
+        new Promise<{processedFiles: FileObject[]; pdfsToLoad: FileObject[]}>((resolve) => {
+            const filteredResults = files.filter((result): result is FileObject => result !== null);
+            const pdfsToLoad = filteredResults.filter((file) => Str.isPDF(file.name ?? ''));
+            const otherFiles = filteredResults.filter((file) => !Str.isPDF(file.name ?? ''));
 
-        files.forEach((file, index) => {
-            originalFileOrder.current.set(file.uri ?? '', index);
-        });
+            const heicOrImageResults = invalidResults.filter((result) => result.error === CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.HEIC_OR_HEIF_IMAGE);
 
-        Promise.all(
-            files.map((file, index) =>
-                validateAttachmentFile(file, items.at(index)).then((result) => {
-                    if (result.isValid) {
-                        onSourceChanged?.(result.validatedFile.source);
-                        return file;
-                    }
-                    collectedErrors.current.push({error: result.error});
-                    return null;
-                }),
-            ),
-        )
-            .then((validationResults) => {
-                const filteredResults = validationResults.filter((result): result is FileObject => result !== null);
-                const pdfsToLoad = filteredResults.filter((file) => Str.isPDF(file.name ?? ''));
-                const otherFiles = filteredResults.filter((file) => !Str.isPDF(file.name ?? ''));
-
-                // Check if we need to convert images
-                if (otherFiles.some((file) => isHeicOrHeifImage(file))) {
+            heicOrImageResults.map((result) => {
                     setIsLoaderVisible(true);
 
-                    return Promise.all(otherFiles.map((file) => convertHeicImageToJpegPromise(file))).then((convertedImages) => {
-                        convertedImages.forEach((convertedFile, index) => {
-                            updateFileOrderMapping(otherFiles.at(index), convertedFile);
-                        });
+                Promise.all(result.map((result) => convertHeicImageToJpegPromise(result.file))).then((convertedImages) => {
+                    convertedImages.forEach((convertedFile, index) => {
+                        updateFileOrderMapping(otherFiles.at(index), convertedFile);
+                    });
 
-                        // Check if we need to resize images
-                        if (convertedImages.some((file) => (file.size ?? 0) > CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE)) {
-                            return Promise.all(convertedImages.map((file) => resizeImageIfNeeded(file))).then((processedFiles) => {
-                                processedFiles.forEach((resizedFile, index) => {
-                                    updateFileOrderMapping(convertedImages.at(index), resizedFile);
-                                });
-                                setIsLoaderVisible(false);
-                                return Promise.resolve({processedFiles, pdfsToLoad});
+                    // Check if we need to resize images
+                    if (convertedImages.some((file) => (file.size ?? 0) > CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE)) {
+                        Promise.all(convertedImages.map((file) => resizeImageIfNeeded(file))).then((processedFiles) => {
+                            processedFiles.forEach((resizedFile, index) => {
+                                updateFileOrderMapping(convertedImages.at(index), resizedFile);
                             });
-                        }
+                            setIsLoaderVisible(false);
+                            resolve({processedFiles, pdfsToLoad});
+                        });
+                    }
 
-                        // No resizing needed, just return the converted images
-                        setIsLoaderVisible(false);
-                        return Promise.resolve({processedFiles: convertedImages, pdfsToLoad});
-                    });
+                    // No resizing needed, just return the converted images
+                    setIsLoaderVisible(false);
+                    resolve({processedFiles: convertedImages, pdfsToLoad});
+                });
                 }
+            });
 
-                // No conversion needed, but check if we need to resize images
-                if (otherFiles.some((file) => (file.size ?? 0) > CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE)) {
-                    setIsLoaderVisible(true);
-                    return Promise.all(otherFiles.map((file) => resizeImageIfNeeded(file))).then((processedFiles) => {
-                        processedFiles.forEach((resizedFile, index) => {
-                            updateFileOrderMapping(otherFiles.at(index), resizedFile);
-                        });
-                        setIsLoaderVisible(false);
-                        return Promise.resolve({processedFiles, pdfsToLoad});
+            // Check if we need to convert images
+            if (otherFiles.some((file) => isHeicOrHeifImage(file))) {
+                setIsLoaderVisible(true);
+
+                Promise.all(otherFiles.map((file) => convertHeicImageToJpegPromise(file))).then((convertedImages) => {
+                    convertedImages.forEach((convertedFile, index) => {
+                        updateFileOrderMapping(otherFiles.at(index), convertedFile);
                     });
-                }
 
-                // No conversion or resizing needed, just return the valid images
-                return Promise.resolve({processedFiles: otherFiles, pdfsToLoad});
-            })
-            .then(({processedFiles, pdfsToLoad}) => {
-                if (pdfsToLoad.length) {
-                    validFiles.current = processedFiles;
-                    setPdfFilesToRender(pdfsToLoad);
-                } else {
-                    if (processedFiles.length > 0) {
-                        setValidFilesToUpload(processedFiles);
+                    // Check if we need to resize images
+                    if (convertedImages.some((file) => (file.size ?? 0) > CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE)) {
+                        Promise.all(convertedImages.map((file) => resizeImageIfNeeded(file))).then((processedFiles) => {
+                            processedFiles.forEach((resizedFile, index) => {
+                                updateFileOrderMapping(convertedImages.at(index), resizedFile);
+                            });
+                            setIsLoaderVisible(false);
+                            resolve({processedFiles, pdfsToLoad});
+                        });
                     }
 
-                    if (collectedErrors.current.length > 0) {
-                        const uniqueErrors = Array.from(new Set(collectedErrors.current.map((error) => JSON.stringify(error)))).map((errorStr) => JSON.parse(errorStr) as ErrorObject);
-                        setErrorQueue(uniqueErrors);
-                        setCurrentErrorIndex(0);
-                        const firstError = uniqueErrors.at(0);
-                        if (firstError) {
-                            setFileError(firstError.error);
-                            if (firstError.fileExtension) {
-                                setInvalidFileExtension(firstError.fileExtension);
-                            }
-                            setIsErrorModalVisible(true);
+                    // No resizing needed, just return the converted images
+                    setIsLoaderVisible(false);
+                    resolve({processedFiles: convertedImages, pdfsToLoad});
+                });
+            }
+
+            // No conversion needed, but check if we need to resize images
+            if (otherFiles.some((file) => (file.size ?? 0) > CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE)) {
+                setIsLoaderVisible(true);
+                Promise.all(otherFiles.map((file) => resizeImageIfNeeded(file))).then((processedFiles) => {
+                    processedFiles.forEach((resizedFile, index) => {
+                        updateFileOrderMapping(otherFiles.at(index), resizedFile);
+                    });
+                    setIsLoaderVisible(false);
+                    resolve({processedFiles, pdfsToLoad});
+                });
+            }
+
+            // No conversion or resizing needed, just return the valid images
+            resolve({processedFiles: otherFiles, pdfsToLoad});
+        }).then(({processedFiles, pdfsToLoad}) => {
+            if (pdfsToLoad.length) {
+                validFiles.current = processedFiles;
+                setPdfFilesToRender(pdfsToLoad);
+            } else {
+                if (processedFiles.length > 0) {
+                    setValidFilesToUpload(processedFiles);
+                }
+
+                if (collectedErrors.current.length > 0) {
+                    const uniqueErrors = Array.from(new Set(collectedErrors.current.map((error) => JSON.stringify(error)))).map((errorStr) => JSON.parse(errorStr) as ErrorObject);
+                    setErrorQueue(uniqueErrors);
+                    setCurrentErrorIndex(0);
+                    const firstError = uniqueErrors.at(0);
+                    if (firstError) {
+                        setFileError(firstError.error);
+                        if (firstError.fileExtension) {
+                            setInvalidFileExtension(firstError.fileExtension);
                         }
-                    } else if (processedFiles.length > 0) {
-                        const sortedFiles = sortFilesByOriginalOrder(processedFiles, originalFileOrder.current);
-                        onFilesValidated(sortedFiles);
-                        resetValidationState();
+                        setIsErrorModalVisible(true);
                     }
+                } else if (processedFiles.length > 0) {
+                    const sortedFiles = sortFilesByOriginalOrder(processedFiles, originalFileOrder.current);
+                    onFilesValidated(sortedFiles);
+                    resetValidationState();
                 }
-            });
+            }
+        });
     };
 
     const validateFiles = (files: File | FileObject[], items?: DataTransferItem[]) => {
@@ -242,12 +245,18 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
             return;
         }
 
+        // Reset collected errors for new validation
+        collectedErrors.current = [];
+
         if (Array.isArray(files)) {
             setIsValidatingMultipleFiles(true);
 
-            validateMultipleAttachmentFiles(files).then((result) => {
+            files.forEach((file, index) => {
+                originalFileOrder.current.set(file.uri ?? '', index);
+            });
+
+            validateMultipleAttachmentFiles(files, items).then((result) => {
                 if (result.isValid) {
-                    validateAndResizeFiles(result.validatedFiles, items ?? []);
                     onSourceChanged?.(result.validatedFiles.at(0)?.source);
                     return;
                 }
@@ -259,18 +268,23 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
                     }
                 }
 
+                convertAndResizeFiles(result, result.files);
+                collectedErrors.current.push({error: result.error});
                 setErrorAndOpenModal(result.error);
             });
             return;
         }
 
-        validateAttachmentFile(files).then((result) => {
+        originalFileOrder.current.set(files.uri ?? '', 0);
+
+        validateAttachmentFile(files, items?.at(0)).then((result) => {
             if (result.isValid) {
-                validateAndResizeFiles([result.validatedFile.file], items ?? []);
                 onSourceChanged?.(result.validatedFile.source);
                 return;
             }
 
+            convertAndResizeFiles([result], [files]);
+            collectedErrors.current.push({error: result.error});
             setErrorAndOpenModal(result.error);
         });
     };
@@ -278,7 +292,7 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
     const onConfirm = () => {
         if (fileError === CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.MAX_FILE_LIMIT_EXCEEDED) {
             setIsErrorModalVisible(false);
-            validateAndResizeFiles(filesToValidate.current, dataTransferItemList.current);
+            convertAndResizeFiles(filesToValidate.current);
             return;
         }
 

From 34f848e1db79a5bdaea560e80281267123b0e768 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Wed, 17 Sep 2025 11:29:42 +0100
Subject: [PATCH 20/31] refactor: revert attachment validation changes

---
 src/CONST/index.ts                            |  33 +-
 src/hooks/useFilesValidation.tsx              | 290 +++++++++---------
 src/libs/AttachmentUtils.ts                   | 105 +++++++
 src/libs/AttachmentValidation.ts              | 205 -------------
 src/libs/fileDownload/FileUtils.ts            |  40 ++-
 .../AttachmentModalBaseContent/index.tsx      |  15 +-
 .../AttachmentModalBaseContent/types.ts       |   7 +-
 .../hooks/useReportAttachmentModalType.ts     |  17 +-
 .../ReportAddAttachmentModalContent.tsx       |  64 ++--
 tests/unit/AttachmentValidationTest.ts        |  49 ---
 tests/unit/FileUtilsTest.ts                   |  43 +++
 11 files changed, 398 insertions(+), 470 deletions(-)
 create mode 100644 src/libs/AttachmentUtils.ts
 delete mode 100644 src/libs/AttachmentValidation.ts
 delete mode 100644 tests/unit/AttachmentValidationTest.ts

diff --git a/src/CONST/index.ts b/src/CONST/index.ts
index 9edfa7662b9f..69ac6b6d40b6 100755
--- a/src/CONST/index.ts
+++ b/src/CONST/index.ts
@@ -265,26 +265,6 @@ const CONST = {
         MAX_FILE_LIMIT: 30,
     },
 
-    ATTACHMENT_VALIDATION_ERRORS: {
-        SINGLE_FILE: {
-            NO_FILE_PROVIDED: 'noFileProvided',
-            FILE_INVALID: 'fileInvalid',
-            WRONG_FILE_TYPE: 'wrongFileType',
-            FILE_TOO_LARGE: 'fileTooLarge',
-            FILE_TOO_SMALL: 'fileTooSmall',
-            FILE_CORRUPTED: 'fileCorrupted',
-            PROTECTED_FILE: 'protectedFile',
-            FOLDER_NOT_ALLOWED: 'folderNotAllowed',
-            HEIC_OR_HEIF_IMAGE: 'heicOrHeifImage',
-        },
-        MULTIPLE_FILES: {
-            WRONG_FILE_TYPE: 'multipleAttachmentsWrongFileType',
-            FILE_TOO_LARGE: 'multipleAttachmentsFileTooLarge',
-            FOLDER_NOT_ALLOWED: 'multipleAttachmentsFolderNotAllowed',
-            MAX_FILE_LIMIT_EXCEEDED: 'multipleAttachmentsMaxFileLimitExceeded',
-        },
-    },
-
     // Allowed extensions for spreadsheets import
     ALLOWED_SPREADSHEET_EXTENSIONS: ['xls', 'xlsx', 'csv', 'txt'],
 
@@ -2012,6 +1992,19 @@ const CONST = {
         // Video MimeTypes allowed by iOS photos app.
         VIDEO: /\.(mov|mp4)$/,
     },
+
+    FILE_VALIDATION_ERRORS: {
+        WRONG_FILE_TYPE: 'wrongFileType',
+        WRONG_FILE_TYPE_MULTIPLE: 'wrongFileTypeMultiple',
+        FILE_TOO_LARGE: 'fileTooLarge',
+        FILE_TOO_LARGE_MULTIPLE: 'fileTooLargeMultiple',
+        FILE_TOO_SMALL: 'fileTooSmall',
+        FILE_CORRUPTED: 'fileCorrupted',
+        FOLDER_NOT_ALLOWED: 'folderNotAllowed',
+        MAX_FILE_LIMIT_EXCEEDED: 'fileLimitExceeded',
+        PROTECTED_FILE: 'protectedFile',
+    },
+
     IOS_CAMERA_ROLL_ACCESS_ERROR: 'Access to photo library was denied',
     ADD_PAYMENT_MENU_POSITION_Y: 226,
     ADD_PAYMENT_MENU_POSITION_X: 356,
diff --git a/src/hooks/useFilesValidation.tsx b/src/hooks/useFilesValidation.tsx
index 16ff0c5b9679..d047edbb5031 100644
--- a/src/hooks/useFilesValidation.tsx
+++ b/src/hooks/useFilesValidation.tsx
@@ -1,22 +1,29 @@
 import {Str} from 'expensify-common';
 import React, {useCallback, useRef, useState} from 'react';
 import {InteractionManager} from 'react-native';
+import type {ValueOf} from 'type-fest';
+import type {FileObject} from '@components/AttachmentModal';
 import ConfirmModal from '@components/ConfirmModal';
 import {useFullScreenLoader} from '@components/FullScreenLoaderContext';
 import PDFThumbnail from '@components/PDFThumbnail';
 import Text from '@components/Text';
 import TextLink from '@components/TextLink';
-import {validateAttachmentFile, validateMultipleAttachmentFiles} from '@libs/AttachmentValidation';
-import type {MultipleAttachmentsValidationError, SingleAttachmentInvalidResult, SingleAttachmentValidationError} from '@libs/AttachmentValidation';
-import {getFileValidationErrorText, isHeicOrHeifImage, resizeImageIfNeeded} from '@libs/fileDownload/FileUtils';
+import {
+    getFileValidationErrorText,
+    isHeicOrHeifImage,
+    normalizeFileObject,
+    resizeImageIfNeeded,
+    splitExtensionFromFileName,
+    validateAttachment,
+    validateImageForCorruption,
+} from '@libs/fileDownload/FileUtils';
 import convertHeicImage from '@libs/fileDownload/heicConverter';
-import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
 import CONST from '@src/CONST';
 import useLocalize from './useLocalize';
 import useThemeStyles from './useThemeStyles';
 
 type ErrorObject = {
-    error: SingleAttachmentValidationError | MultipleAttachmentsValidationError;
+    error: ValueOf<typeof CONST.FILE_VALIDATION_ERRORS>;
     fileExtension?: string;
 };
 
@@ -24,13 +31,13 @@ const sortFilesByOriginalOrder = (files: FileObject[], orderMap: Map<string, num
     return files.sort((a, b) => (orderMap.get(a.uri ?? '') ?? 0) - (orderMap.get(b.uri ?? '') ?? 0));
 };
 
-function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isValidatingReceipts = true, onSourceChanged?: (source: string | undefined) => void) {
+function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => void, isValidatingReceipts = true) {
     const styles = useThemeStyles();
     const {translate} = useLocalize();
     const [isErrorModalVisible, setIsErrorModalVisible] = useState(false);
-    const [fileError, setFileError] = useState<SingleAttachmentValidationError | MultipleAttachmentsValidationError>();
+    const [fileError, setFileError] = useState<ValueOf<typeof CONST.FILE_VALIDATION_ERRORS> | null>(null);
     const [pdfFilesToRender, setPdfFilesToRender] = useState<FileObject[]>([]);
-    const [validFilesToUpload, setValidFilesToUpload] = useState<FileObject[]>([]);
+    const [validFilesToUpload, setValidFilesToUpload] = useState([] as FileObject[]);
     const [isValidatingMultipleFiles, setIsValidatingMultipleFiles] = useState(false);
     const [invalidFileExtension, setInvalidFileExtension] = useState('');
     const [errorQueue, setErrorQueue] = useState<ErrorObject[]>([]);
@@ -69,7 +76,7 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
         setIsLoaderVisible(false);
         setValidFilesToUpload([]);
         setIsValidatingMultipleFiles(false);
-        setFileError(undefined);
+        setFileError(null);
         setInvalidFileExtension('');
         setErrorQueue([]);
         setCurrentErrorIndex(0);
@@ -88,11 +95,42 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
         });
     }, [resetValidationState]);
 
-    const setErrorAndOpenModal = (error: SingleAttachmentValidationError | MultipleAttachmentsValidationError) => {
+    const setErrorAndOpenModal = (error: ValueOf<typeof CONST.FILE_VALIDATION_ERRORS>) => {
         setFileError(error);
         setIsErrorModalVisible(true);
     };
 
+    const isValidFile = (originalFile: FileObject, item: DataTransferItem | undefined, isCheckingMultipleFiles?: boolean) => {
+        if (item && item.kind === 'file' && 'webkitGetAsEntry' in item) {
+            const entry = item.webkitGetAsEntry();
+
+            if (entry?.isDirectory) {
+                collectedErrors.current.push({error: CONST.FILE_VALIDATION_ERRORS.FOLDER_NOT_ALLOWED});
+                return Promise.resolve(false);
+            }
+        }
+
+        return normalizeFileObject(originalFile)
+            .then((normalizedFile) =>
+                validateImageForCorruption(normalizedFile).then(() => {
+                    const error = validateAttachment(normalizedFile, isCheckingMultipleFiles, isValidatingReceipts);
+                    if (error) {
+                        const errorData = {
+                            error,
+                            fileExtension: error === CONST.FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE_MULTIPLE ? splitExtensionFromFileName(normalizedFile.name ?? '').fileExtension : undefined,
+                        };
+                        collectedErrors.current.push(errorData);
+                        return false;
+                    }
+                    return true;
+                }),
+            )
+            .catch(() => {
+                collectedErrors.current.push({error: CONST.FILE_VALIDATION_ERRORS.FILE_CORRUPTED});
+                return false;
+            });
+    };
+
     const convertHeicImageToJpegPromise = (file: FileObject): Promise<FileObject> => {
         return new Promise((resolve, reject) => {
             convertHeicImage(file, {
@@ -131,168 +169,120 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
             }
         } else if (validFiles.current.length > 0) {
             const sortedFiles = sortFilesByOriginalOrder(validFiles.current, originalFileOrder.current);
-            onFilesValidated(sortedFiles);
+            proceedWithFilesAction(sortedFiles);
             resetValidationState();
         }
-    }, [deduplicateErrors, pdfFilesToRender.length, onFilesValidated, resetValidationState]);
+    }, [deduplicateErrors, pdfFilesToRender.length, proceedWithFilesAction, resetValidationState]);
 
-    const convertAndResizeFiles = (invalidResults: SingleAttachmentInvalidResult[], files: FileObject[]) => {
-        new Promise<{processedFiles: FileObject[]; pdfsToLoad: FileObject[]}>((resolve) => {
-            const filteredResults = files.filter((result): result is FileObject => result !== null);
-            const pdfsToLoad = filteredResults.filter((file) => Str.isPDF(file.name ?? ''));
-            const otherFiles = filteredResults.filter((file) => !Str.isPDF(file.name ?? ''));
+    const validateAndResizeFiles = (files: FileObject[], items: DataTransferItem[]) => {
+        // Early return for empty files
+        if (files.length === 0) {
+            return;
+        }
 
-            const heicOrImageResults = invalidResults.filter((result) => result.error === CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.HEIC_OR_HEIF_IMAGE);
+        // Reset collected errors for new validation
+        collectedErrors.current = [];
 
-            heicOrImageResults.map((result) => {
-                    setIsLoaderVisible(true);
+        files.forEach((file, index) => {
+            originalFileOrder.current.set(file.uri ?? '', index);
+        });
 
-                Promise.all(result.map((result) => convertHeicImageToJpegPromise(result.file))).then((convertedImages) => {
-                    convertedImages.forEach((convertedFile, index) => {
-                        updateFileOrderMapping(otherFiles.at(index), convertedFile);
-                    });
+        Promise.all(files.map((file, index) => isValidFile(file, items.at(index), files.length > 1).then((isValid) => (isValid ? file : null))))
+            .then((validationResults) => {
+                const filteredResults = validationResults.filter((result): result is FileObject => result !== null);
+                const pdfsToLoad = filteredResults.filter((file) => Str.isPDF(file.name ?? ''));
+                const otherFiles = filteredResults.filter((file) => !Str.isPDF(file.name ?? ''));
 
-                    // Check if we need to resize images
-                    if (convertedImages.some((file) => (file.size ?? 0) > CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE)) {
-                        Promise.all(convertedImages.map((file) => resizeImageIfNeeded(file))).then((processedFiles) => {
-                            processedFiles.forEach((resizedFile, index) => {
-                                updateFileOrderMapping(convertedImages.at(index), resizedFile);
-                            });
-                            setIsLoaderVisible(false);
-                            resolve({processedFiles, pdfsToLoad});
-                        });
-                    }
+                // Check if we need to convert images
+                if (otherFiles.some((file) => isHeicOrHeifImage(file))) {
+                    setIsLoaderVisible(true);
 
-                    // No resizing needed, just return the converted images
-                    setIsLoaderVisible(false);
-                    resolve({processedFiles: convertedImages, pdfsToLoad});
-                });
-                }
-            });
+                    return Promise.all(otherFiles.map((file) => convertHeicImageToJpegPromise(file))).then((convertedImages) => {
+                        convertedImages.forEach((convertedFile, index) => {
+                            updateFileOrderMapping(otherFiles.at(index), convertedFile);
+                        });
 
-            // Check if we need to convert images
-            if (otherFiles.some((file) => isHeicOrHeifImage(file))) {
-                setIsLoaderVisible(true);
+                        // Check if we need to resize images
+                        if (convertedImages.some((file) => (file.size ?? 0) > CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE)) {
+                            return Promise.all(convertedImages.map((file) => resizeImageIfNeeded(file))).then((processedFiles) => {
+                                processedFiles.forEach((resizedFile, index) => {
+                                    updateFileOrderMapping(convertedImages.at(index), resizedFile);
+                                });
+                                setIsLoaderVisible(false);
+                                return Promise.resolve({processedFiles, pdfsToLoad});
+                            });
+                        }
 
-                Promise.all(otherFiles.map((file) => convertHeicImageToJpegPromise(file))).then((convertedImages) => {
-                    convertedImages.forEach((convertedFile, index) => {
-                        updateFileOrderMapping(otherFiles.at(index), convertedFile);
+                        // No resizing needed, just return the converted images
+                        setIsLoaderVisible(false);
+                        return Promise.resolve({processedFiles: convertedImages, pdfsToLoad});
                     });
+                }
 
-                    // Check if we need to resize images
-                    if (convertedImages.some((file) => (file.size ?? 0) > CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE)) {
-                        Promise.all(convertedImages.map((file) => resizeImageIfNeeded(file))).then((processedFiles) => {
-                            processedFiles.forEach((resizedFile, index) => {
-                                updateFileOrderMapping(convertedImages.at(index), resizedFile);
-                            });
-                            setIsLoaderVisible(false);
-                            resolve({processedFiles, pdfsToLoad});
+                // No conversion needed, but check if we need to resize images
+                if (otherFiles.some((file) => (file.size ?? 0) > CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE)) {
+                    setIsLoaderVisible(true);
+                    return Promise.all(otherFiles.map((file) => resizeImageIfNeeded(file))).then((processedFiles) => {
+                        processedFiles.forEach((resizedFile, index) => {
+                            updateFileOrderMapping(otherFiles.at(index), resizedFile);
                         });
-                    }
-
-                    // No resizing needed, just return the converted images
-                    setIsLoaderVisible(false);
-                    resolve({processedFiles: convertedImages, pdfsToLoad});
-                });
-            }
-
-            // No conversion needed, but check if we need to resize images
-            if (otherFiles.some((file) => (file.size ?? 0) > CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE)) {
-                setIsLoaderVisible(true);
-                Promise.all(otherFiles.map((file) => resizeImageIfNeeded(file))).then((processedFiles) => {
-                    processedFiles.forEach((resizedFile, index) => {
-                        updateFileOrderMapping(otherFiles.at(index), resizedFile);
+                        setIsLoaderVisible(false);
+                        return Promise.resolve({processedFiles, pdfsToLoad});
                     });
-                    setIsLoaderVisible(false);
-                    resolve({processedFiles, pdfsToLoad});
-                });
-            }
-
-            // No conversion or resizing needed, just return the valid images
-            resolve({processedFiles: otherFiles, pdfsToLoad});
-        }).then(({processedFiles, pdfsToLoad}) => {
-            if (pdfsToLoad.length) {
-                validFiles.current = processedFiles;
-                setPdfFilesToRender(pdfsToLoad);
-            } else {
-                if (processedFiles.length > 0) {
-                    setValidFilesToUpload(processedFiles);
                 }
 
-                if (collectedErrors.current.length > 0) {
-                    const uniqueErrors = Array.from(new Set(collectedErrors.current.map((error) => JSON.stringify(error)))).map((errorStr) => JSON.parse(errorStr) as ErrorObject);
-                    setErrorQueue(uniqueErrors);
-                    setCurrentErrorIndex(0);
-                    const firstError = uniqueErrors.at(0);
-                    if (firstError) {
-                        setFileError(firstError.error);
-                        if (firstError.fileExtension) {
-                            setInvalidFileExtension(firstError.fileExtension);
+                // No conversion or resizing needed, just return the valid images
+                return Promise.resolve({processedFiles: otherFiles, pdfsToLoad});
+            })
+            .then(({processedFiles, pdfsToLoad}) => {
+                if (pdfsToLoad.length) {
+                    validFiles.current = processedFiles;
+                    setPdfFilesToRender(pdfsToLoad);
+                } else {
+                    if (processedFiles.length > 0) {
+                        setValidFilesToUpload(processedFiles);
+                    }
+
+                    if (collectedErrors.current.length > 0) {
+                        const uniqueErrors = Array.from(new Set(collectedErrors.current.map((error) => JSON.stringify(error)))).map((errorStr) => JSON.parse(errorStr) as ErrorObject);
+                        setErrorQueue(uniqueErrors);
+                        setCurrentErrorIndex(0);
+                        const firstError = uniqueErrors.at(0);
+                        if (firstError) {
+                            setFileError(firstError.error);
+                            if (firstError.fileExtension) {
+                                setInvalidFileExtension(firstError.fileExtension);
+                            }
+                            setIsErrorModalVisible(true);
                         }
-                        setIsErrorModalVisible(true);
+                    } else if (processedFiles.length > 0) {
+                        const sortedFiles = sortFilesByOriginalOrder(processedFiles, originalFileOrder.current);
+                        proceedWithFilesAction(sortedFiles);
+                        resetValidationState();
                     }
-                } else if (processedFiles.length > 0) {
-                    const sortedFiles = sortFilesByOriginalOrder(processedFiles, originalFileOrder.current);
-                    onFilesValidated(sortedFiles);
-                    resetValidationState();
                 }
-            }
-        });
+            });
     };
 
-    const validateFiles = (files: File | FileObject[], items?: DataTransferItem[]) => {
-        if (!files) {
-            return;
-        }
-
-        // Reset collected errors for new validation
-        collectedErrors.current = [];
-
-        if (Array.isArray(files)) {
+    const validateFiles = (files: FileObject[], items?: DataTransferItem[]) => {
+        if (files.length > 1) {
             setIsValidatingMultipleFiles(true);
-
-            files.forEach((file, index) => {
-                originalFileOrder.current.set(file.uri ?? '', index);
-            });
-
-            validateMultipleAttachmentFiles(files, items).then((result) => {
-                if (result.isValid) {
-                    onSourceChanged?.(result.validatedFiles.at(0)?.source);
-                    return;
-                }
-
-                if (result.error === CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.MAX_FILE_LIMIT_EXCEEDED) {
-                    filesToValidate.current = files.slice(0, CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT);
-                    if (items) {
-                        dataTransferItemList.current = items.slice(0, CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT);
-                    }
-                }
-
-                convertAndResizeFiles(result, result.files);
-                collectedErrors.current.push({error: result.error});
-                setErrorAndOpenModal(result.error);
-            });
-            return;
         }
-
-        originalFileOrder.current.set(files.uri ?? '', 0);
-
-        validateAttachmentFile(files, items?.at(0)).then((result) => {
-            if (result.isValid) {
-                onSourceChanged?.(result.validatedFile.source);
-                return;
+        if (files.length > CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT) {
+            filesToValidate.current = files.slice(0, CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT);
+            if (items) {
+                dataTransferItemList.current = items.slice(0, CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT);
             }
-
-            convertAndResizeFiles([result], [files]);
-            collectedErrors.current.push({error: result.error});
-            setErrorAndOpenModal(result.error);
-        });
+            setErrorAndOpenModal(CONST.FILE_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED);
+        } else {
+            validateAndResizeFiles(files, items ?? []);
+        }
     };
 
     const onConfirm = () => {
-        if (fileError === CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.MAX_FILE_LIMIT_EXCEEDED) {
+        if (fileError === CONST.FILE_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED) {
             setIsErrorModalVisible(false);
-            convertAndResizeFiles(filesToValidate.current);
+            validateAndResizeFiles(filesToValidate.current, dataTransferItemList.current);
             return;
         }
 
@@ -317,13 +307,13 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
             setIsErrorModalVisible(false);
             InteractionManager.runAfterInteractions(() => {
                 if (sortedFiles.length !== 0) {
-                    onFilesValidated(sortedFiles);
+                    proceedWithFilesAction(sortedFiles);
                 }
                 resetValidationState();
             });
         } else {
             if (sortedFiles.length !== 0) {
-                onFilesValidated(sortedFiles);
+                proceedWithFilesAction(sortedFiles);
             }
             hideModalAndReset();
         }
@@ -343,7 +333,7 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
                   onPassword={() => {
                       validatedPDFs.current.push(file);
                       if (isValidatingReceipts) {
-                          collectedErrors.current.push({error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.PROTECTED_FILE});
+                          collectedErrors.current.push({error: CONST.FILE_VALIDATION_ERRORS.PROTECTED_FILE});
                       } else {
                           validFiles.current.push(file);
                       }
@@ -351,7 +341,7 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
                   }}
                   onLoadError={() => {
                       validatedPDFs.current.push(file);
-                      collectedErrors.current.push({error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_CORRUPTED});
+                      collectedErrors.current.push({error: CONST.FILE_VALIDATION_ERRORS.FILE_CORRUPTED});
                       checkIfAllValidatedAndProceed();
                   }}
               />
@@ -363,7 +353,7 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
             return '';
         }
         const prompt = getFileValidationErrorText(fileError, {fileType: invalidFileExtension}, isValidatingReceipts).reason;
-        if (fileError === CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.WRONG_FILE_TYPE || fileError === CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.WRONG_FILE_TYPE) {
+        if (fileError === CONST.FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE_MULTIPLE || fileError === CONST.FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE) {
             return (
                 <Text>
                     {prompt}
@@ -388,8 +378,8 @@ function useFilesValidation(onFilesValidated: (files: FileObject[]) => void, isV
     );
 
     return {
-        validateFiles,
         PDFValidationComponent,
+        validateFiles,
         ErrorModal,
     };
 }
diff --git a/src/libs/AttachmentUtils.ts b/src/libs/AttachmentUtils.ts
new file mode 100644
index 000000000000..eea91499fa66
--- /dev/null
+++ b/src/libs/AttachmentUtils.ts
@@ -0,0 +1,105 @@
+import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
+import CONST from '@src/CONST';
+import {cleanFileName, validateImageForCorruption} from './fileDownload/FileUtils';
+
+type AttachmentValidationError = CorruptionError | 'fileDoesNotExist' | 'fileInvalid';
+type ValidResult = {
+    isValid: true;
+    fileType: 'file' | 'uri';
+    source: string;
+    file: FileObject;
+};
+type InvalidResult = {
+    isValid: false;
+    error: AttachmentValidationError;
+};
+
+type AttachmentValidationResult = ValidResult | InvalidResult;
+
+function validateAttachmentFile(file: FileObject): Promise<AttachmentValidationResult> {
+    if (!file || !isDirectoryCheck(file)) {
+        return Promise.resolve({isValid: false, error: 'fileDoesNotExist'});
+    }
+
+    let fileObject = file;
+    if ('getAsFile' in file && typeof file.getAsFile === 'function') {
+        fileObject = file.getAsFile() as FileObject;
+    }
+    if (!fileObject) {
+        return Promise.resolve({isValid: false, error: 'fileInvalid'});
+    }
+
+    return isFileCorrupted(fileObject).then((corruptionResult) => {
+        if (!corruptionResult.isValid) {
+            return corruptionResult as InvalidResult;
+        }
+
+        if (fileObject instanceof File) {
+            /**
+             * Cleaning file name, done here so that it covers all cases:
+             * upload, drag and drop, copy-paste
+             */
+            let updatedFile = fileObject;
+            const cleanName = cleanFileName(updatedFile.name);
+            if (updatedFile.name !== cleanName) {
+                updatedFile = new File([updatedFile], cleanName, {type: updatedFile.type});
+            }
+            const inputSource = URL.createObjectURL(updatedFile);
+            updatedFile.uri = inputSource;
+
+            return {isValid: true, fileType: 'file', source: inputSource, file: updatedFile} as ValidResult;
+        }
+
+        return {isValid: true, fileType: 'uri', source: fileObject.uri, file: fileObject} as ValidResult;
+    });
+}
+
+type CorruptionError = 'tooLarge' | 'tooSmall' | 'error';
+type NoCorruptionResult = {
+    isValid: true;
+};
+type CorruptionResult = {
+    isValid: false;
+    error: CorruptionError;
+};
+type AttachmentCorruptionValidationResult = NoCorruptionResult | CorruptionResult;
+
+function isFileCorrupted(fileObject: FileObject): Promise<AttachmentCorruptionValidationResult> {
+    return validateImageForCorruption(fileObject)
+        .then(() => {
+            if (fileObject.size && fileObject.size > CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE) {
+                return {
+                    isValid: false,
+                    error: 'tooLarge',
+                } satisfies AttachmentCorruptionValidationResult;
+            }
+
+            if (fileObject.size && fileObject.size < CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE) {
+                return {
+                    isValid: false,
+                    error: 'tooSmall',
+                } satisfies AttachmentCorruptionValidationResult;
+            }
+
+            return {
+                isValid: true,
+            } satisfies AttachmentCorruptionValidationResult;
+        })
+        .catch(() => {
+            return {
+                isValid: false,
+                error: 'error',
+            };
+        });
+}
+
+function isDirectoryCheck(data: FileObject) {
+    if ('webkitGetAsEntry' in data && (data as DataTransferItem).webkitGetAsEntry()?.isDirectory) {
+        return false;
+    }
+
+    return true;
+}
+
+export default validateAttachmentFile;
+export type {AttachmentValidationResult};
diff --git a/src/libs/AttachmentValidation.ts b/src/libs/AttachmentValidation.ts
deleted file mode 100644
index a83d2dc89a01..000000000000
--- a/src/libs/AttachmentValidation.ts
+++ /dev/null
@@ -1,205 +0,0 @@
-import {Str} from 'expensify-common';
-import type {ValueOf} from 'type-fest';
-import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
-import CONST from '@src/CONST';
-import {cleanFileName, isHeicOrHeifImage, isValidReceiptExtension, normalizeFileObject, validateImageForCorruption} from './fileDownload/FileUtils';
-
-type ValidatedFile = {
-    fileType: 'file' | 'uri';
-    source: string;
-    file: FileObject;
-};
-
-type SingleAttachmentValidResult = {
-    isValid: true;
-    validatedFile: ValidatedFile;
-};
-
-type SingleAttachmentValidationError = ValueOf<typeof CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE>;
-type SingleAttachmentInvalidResult = {
-    isValid: false;
-    error: SingleAttachmentValidationError;
-    file: FileObject;
-};
-
-type SingleAttachmentValidationResult = SingleAttachmentValidResult | SingleAttachmentInvalidResult;
-
-function isSingleAttachmentValidationResult(result: unknown): result is SingleAttachmentValidationResult {
-    return typeof result === 'object' && result !== null && 'isValid' in result && typeof result.isValid === 'boolean' && ('validatedFile' in result || 'error' in result);
-}
-
-function validateAttachmentFile(file: FileObject, item?: DataTransferItem, isValidatingReceipt?: boolean): Promise<SingleAttachmentValidationResult> {
-    if (!file) {
-        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.NO_FILE_PROVIDED, file});
-    }
-
-    const maxFileSize = isValidatingReceipt ? CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE : CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE;
-
-    const isImage = Str.isImage(file.name ?? '');
-
-    if (isImage && isHeicOrHeifImage(file)) {
-        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.HEIC_OR_HEIF_IMAGE, file});
-    }
-
-    if (!isImage && !isHeicOrHeifImage(file) && (file?.size ?? 0) > maxFileSize) {
-        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE, file});
-    }
-
-    if (isValidatingReceipt && (file?.size ?? 0) < CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE) {
-        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL, file});
-    }
-
-    if (isValidatingReceipt && !isValidReceiptExtension(file)) {
-        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.WRONG_FILE_TYPE, file});
-    }
-
-    let fileObject = file;
-    if ('getAsFile' in file && typeof file.getAsFile === 'function') {
-        fileObject = file.getAsFile() as FileObject;
-    }
-
-    if (!fileObject) {
-        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_INVALID, file});
-    }
-
-    if (item && item.kind === 'file' && 'webkitGetAsEntry' in item) {
-        const entry = item.webkitGetAsEntry();
-
-        if (entry?.isDirectory) {
-            return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FOLDER_NOT_ALLOWED, file});
-        }
-    }
-
-    return isFileCorrupted(fileObject).then((corruptionResult) => {
-        if (!corruptionResult.isValid) {
-            return corruptionResult;
-        }
-
-        let validatedFile: ValidatedFile;
-
-        if (fileObject instanceof File) {
-            /**
-             * Cleaning file name, done here so that it covers all cases:
-             * upload, drag and drop, copy-paste
-             */
-            let updatedFile = fileObject;
-            const cleanName = cleanFileName(updatedFile.name);
-            if (updatedFile.name !== cleanName) {
-                updatedFile = new File([updatedFile], cleanName, {type: updatedFile.type});
-            }
-            const inputSource = URL.createObjectURL(updatedFile);
-            updatedFile.uri = inputSource;
-
-            validatedFile = {
-                fileType: 'file',
-                source: inputSource,
-                file: updatedFile,
-            };
-
-            return {isValid: true, validatedFile};
-        }
-
-        validatedFile = {
-            fileType: 'uri',
-            source: fileObject.uri ?? '',
-            file: fileObject,
-        };
-
-        return {isValid: true, validatedFile};
-    });
-}
-
-type MultipleAttachmentsValidResult = {
-    isValid: true;
-    validatedFiles: ValidatedFile[];
-};
-
-type MultipleAttachmentsValidationError = ValueOf<typeof CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES>;
-type MultipleAttachmentsInvalidResult = {
-    isValid: false;
-    error: MultipleAttachmentsValidationError;
-    fileResults: SingleAttachmentValidationResult[];
-    files: FileObject[];
-};
-type MultipleAttachmentsValidationResult = MultipleAttachmentsValidResult | MultipleAttachmentsInvalidResult;
-
-function isMultipleAttachmentsValidationResult(result: unknown): result is MultipleAttachmentsValidationResult {
-    return typeof result === 'object' && result !== null && 'isValid' in result && typeof result.isValid === 'boolean' && ('validatedFiles' in result || 'fileResults' in result);
-}
-
-function validateMultipleAttachmentFiles(files: FileObject[], items?: DataTransferItem[]): Promise<MultipleAttachmentsValidationResult> {
-    if (!files?.length || files.some((f) => isDirectory(f))) {
-        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FOLDER_NOT_ALLOWED, fileResults: [], files});
-    }
-
-    if (files.length > CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT) {
-        return Promise.resolve({isValid: false, error: CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.MAX_FILE_LIMIT_EXCEEDED, fileResults: [], files});
-    }
-
-    return Promise.all(files.map((f, index) => validateAttachmentFile(f, items?.at(index)))).then((results) => {
-        if (results.every((result) => result.isValid)) {
-            return {
-                isValid: true,
-                validatedFiles: results.map((result) => result.validatedFile),
-            };
-        }
-
-        return {
-            isValid: false,
-            error: CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.WRONG_FILE_TYPE,
-            fileResults: results,
-            files,
-        };
-    });
-}
-
-function isFileCorrupted(fileObject: FileObject): Promise<SingleAttachmentValidationResult> {
-    return normalizeFileObject(fileObject).then((normalizedFile) => {
-        return validateImageForCorruption(normalizedFile)
-            .then(() => {
-                if (normalizedFile.size && normalizedFile.size > CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE) {
-                    return {
-                        isValid: false,
-                        error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE,
-                    } as SingleAttachmentInvalidResult;
-                }
-
-                if (normalizedFile.size && normalizedFile.size < CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE) {
-                    return {
-                        isValid: false,
-                        error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL,
-                    } as SingleAttachmentInvalidResult;
-                }
-
-                return {
-                    isValid: true,
-                } as SingleAttachmentValidResult;
-            })
-            .catch(() => {
-                return {
-                    isValid: false,
-                    error: CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_INVALID,
-                } as SingleAttachmentInvalidResult;
-            });
-    });
-}
-
-function isDirectory(data: FileObject) {
-    if ('webkitGetAsEntry' in data && (data as DataTransferItem).webkitGetAsEntry()?.isDirectory) {
-        return true;
-    }
-
-    return false;
-}
-
-export {validateAttachmentFile, validateMultipleAttachmentFiles, isSingleAttachmentValidationResult, isMultipleAttachmentsValidationResult};
-export type {
-    SingleAttachmentValidationResult,
-    SingleAttachmentValidResult,
-    SingleAttachmentInvalidResult,
-    SingleAttachmentValidationError,
-    MultipleAttachmentsValidationResult,
-    MultipleAttachmentsValidResult,
-    MultipleAttachmentsInvalidResult,
-    MultipleAttachmentsValidationError,
-};
diff --git a/src/libs/fileDownload/FileUtils.ts b/src/libs/fileDownload/FileUtils.ts
index bf22bb6f763b..e0db610c6215 100644
--- a/src/libs/fileDownload/FileUtils.ts
+++ b/src/libs/fileDownload/FileUtils.ts
@@ -3,8 +3,7 @@ import {Alert, Linking, Platform} from 'react-native';
 import type {ReactNativeBlobUtilReadStream} from 'react-native-blob-util';
 import ReactNativeBlobUtil from 'react-native-blob-util';
 import ImageSize from 'react-native-image-size';
-import type {TupleToUnion} from 'type-fest';
-import type {MultipleAttachmentsValidationError, SingleAttachmentValidationError} from '@libs/AttachmentValidation';
+import type {TupleToUnion, ValueOf} from 'type-fest';
 import DateUtils from '@libs/DateUtils';
 import getPlatform from '@libs/getPlatform';
 import {translateLocal} from '@libs/Localize';
@@ -551,6 +550,22 @@ const normalizeFileObject = (file: FileObject): Promise<FileObject> => {
         });
 };
 
+const validateAttachment = (file: FileObject, isCheckingMultipleFiles?: boolean, isValidatingReceipt?: boolean) => {
+    const maxFileSize = isValidatingReceipt ? CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE : CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE;
+    if (!Str.isImage(file.name ?? '') && !isHeicOrHeifImage(file) && (file?.size ?? 0) > maxFileSize) {
+        return isCheckingMultipleFiles ? CONST.FILE_VALIDATION_ERRORS.FILE_TOO_LARGE_MULTIPLE : CONST.FILE_VALIDATION_ERRORS.FILE_TOO_LARGE;
+    }
+
+    if (isValidatingReceipt && (file?.size ?? 0) < CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE) {
+        return CONST.FILE_VALIDATION_ERRORS.FILE_TOO_SMALL;
+    }
+
+    if (isValidatingReceipt && !isValidReceiptExtension(file)) {
+        return isCheckingMultipleFiles ? CONST.FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE_MULTIPLE : CONST.FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE;
+    }
+    return '';
+};
+
 type TranslationAdditionalData = {
     maxUploadSizeInMB?: number;
     fileLimit?: number;
@@ -558,7 +573,7 @@ type TranslationAdditionalData = {
 };
 
 const getFileValidationErrorText = (
-    validationError: SingleAttachmentValidationError | MultipleAttachmentsValidationError | undefined,
+    validationError: ValueOf<typeof CONST.FILE_VALIDATION_ERRORS> | null,
     additionalData: TranslationAdditionalData = {},
     isValidatingReceipt = false,
 ): {
@@ -573,17 +588,17 @@ const getFileValidationErrorText = (
     }
     const maxSize = isValidatingReceipt ? CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE : CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE;
     switch (validationError) {
-        case CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.WRONG_FILE_TYPE:
+        case CONST.FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE:
             return {
                 title: translateLocal('attachmentPicker.wrongFileType'),
                 reason: translateLocal('attachmentPicker.notAllowedExtension'),
             };
-        case CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.WRONG_FILE_TYPE:
+        case CONST.FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE_MULTIPLE:
             return {
                 title: translateLocal('attachmentPicker.someFilesCantBeUploaded'),
                 reason: translateLocal('attachmentPicker.unsupportedFileType', {fileType: additionalData.fileType ?? ''}),
             };
-        case CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE:
+        case CONST.FILE_VALIDATION_ERRORS.FILE_TOO_LARGE:
             return {
                 title: translateLocal('attachmentPicker.attachmentTooLarge'),
                 reason: isValidatingReceipt
@@ -592,34 +607,34 @@ const getFileValidationErrorText = (
                       })
                     : translateLocal('attachmentPicker.sizeExceeded'),
             };
-        case CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FILE_TOO_LARGE:
+        case CONST.FILE_VALIDATION_ERRORS.FILE_TOO_LARGE_MULTIPLE:
             return {
                 title: translateLocal('attachmentPicker.someFilesCantBeUploaded'),
                 reason: translateLocal('attachmentPicker.sizeLimitExceeded', {
                     maxUploadSizeInMB: additionalData.maxUploadSizeInMB ?? maxSize / 1024 / 1024,
                 }),
             };
-        case CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL:
+        case CONST.FILE_VALIDATION_ERRORS.FILE_TOO_SMALL:
             return {
                 title: translateLocal('attachmentPicker.attachmentTooSmall'),
                 reason: translateLocal('attachmentPicker.sizeNotMet'),
             };
-        case CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FOLDER_NOT_ALLOWED:
+        case CONST.FILE_VALIDATION_ERRORS.FOLDER_NOT_ALLOWED:
             return {
                 title: translateLocal('attachmentPicker.attachmentError'),
                 reason: translateLocal('attachmentPicker.folderNotAllowedMessage'),
             };
-        case CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.MAX_FILE_LIMIT_EXCEEDED:
+        case CONST.FILE_VALIDATION_ERRORS.MAX_FILE_LIMIT_EXCEEDED:
             return {
                 title: translateLocal('attachmentPicker.someFilesCantBeUploaded'),
                 reason: translateLocal('attachmentPicker.maxFileLimitExceeded'),
             };
-        case CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_CORRUPTED:
+        case CONST.FILE_VALIDATION_ERRORS.FILE_CORRUPTED:
             return {
                 title: translateLocal('attachmentPicker.attachmentError'),
                 reason: translateLocal('attachmentPicker.errorWhileSelectingCorruptedAttachment'),
             };
-        case CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.PROTECTED_FILE:
+        case CONST.FILE_VALIDATION_ERRORS.PROTECTED_FILE:
             return {
                 title: translateLocal('attachmentPicker.attachmentError'),
                 reason: translateLocal('attachmentPicker.protectedPDFNotSupported'),
@@ -664,6 +679,7 @@ export {
     resizeImageIfNeeded,
     createFile,
     validateReceipt,
+    validateAttachment,
     normalizeFileObject,
     isValidReceiptExtension,
     getFileValidationErrorText,
diff --git a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
index 1fc931085ef6..4520dd80a971 100644
--- a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
+++ b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
@@ -59,6 +59,7 @@ function AttachmentModalBaseContent({
     AttachmentContent,
     ExtraModals,
     onCarouselAttachmentChange = () => {},
+    onValidateFile,
 }: AttachmentModalBaseContentProps) {
     const styles = useThemeStyles();
     const {shouldUseNarrowLayout} = useResponsiveLayout();
@@ -87,7 +88,7 @@ function AttachmentModalBaseContent({
     const [currentAttachmentLink, setCurrentAttachmentLink] = useState(attachmentLink);
 
     const fallbackFile = useMemo(() => (originalFileName ? {name: originalFileName} : undefined), [originalFileName]);
-    const [files, setFilesInternal] = useState<FileObject | FileObject[] | undefined>(() => filesProp ?? fallbackFile);
+    const [files, setFilesInternal] = useState<FileObject | FileObject[] | undefined>();
     const [isMultipleFiles, setIsMultipleFiles] = useState<boolean>(() => Array.isArray(files));
     const fileToDisplay = useMemo(() => {
         if (isMultipleFiles) {
@@ -107,8 +108,16 @@ function AttachmentModalBaseContent({
     }, []);
 
     useEffect(() => {
-        setFile(filesProp ?? fallbackFile);
-    }, [filesProp, fallbackFile, setFile]);
+        if (!filesProp) {
+            return;
+        }
+
+        if (onValidateFile) {
+            onValidateFile?.(filesProp, setFile);
+        } else {
+            setFile(filesProp ?? fallbackFile);
+        }
+    }, [filesProp, fallbackFile, onValidateFile, setFile]);
 
     /**
      * Keeps the attachment source in sync with the attachment displayed currently in the carousel.
diff --git a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts
index 7d7b9996d1ed..a7dd1fcee4cb 100644
--- a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts
+++ b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts
@@ -19,6 +19,8 @@ type AttachmentModalContentData = {
     file: FileObject | undefined;
 };
 
+type OnValidateFileCallback = (file: FileObject | FileObject[] | undefined, setFile: (file: FileObject | FileObject[] | undefined) => void) => void;
+
 type ThreeDotsMenuItemGeneratorProps = AttachmentModalContentData & {
     isLocalSource: boolean;
 };
@@ -116,6 +118,9 @@ type AttachmentModalBaseContentProps = {
 
     /** Optional callback to fire when we want to do something after attachment carousel changes. */
     onCarouselAttachmentChange?: (attachment: Attachment) => void;
+
+    /** Optional callback to fire when we want to validate the file. */
+    onValidateFile?: OnValidateFileCallback;
 };
 
-export type {AttachmentModalBaseContentProps, AttachmentModalOnCloseOptions, DownloadAttachmentCallback, AttachmentContent, AttachmentContentProps};
+export type {AttachmentModalBaseContentProps, AttachmentModalOnCloseOptions, DownloadAttachmentCallback, AttachmentContent, AttachmentContentProps, OnValidateFileCallback};
diff --git a/src/pages/media/AttachmentModalScreen/routes/hooks/useReportAttachmentModalType.ts b/src/pages/media/AttachmentModalScreen/routes/hooks/useReportAttachmentModalType.ts
index d7aaa54c441a..69619a4c6f0f 100644
--- a/src/pages/media/AttachmentModalScreen/routes/hooks/useReportAttachmentModalType.ts
+++ b/src/pages/media/AttachmentModalScreen/routes/hooks/useReportAttachmentModalType.ts
@@ -1,33 +1,32 @@
 import {Str} from 'expensify-common';
 import {useEffect, useState} from 'react';
-import {translateLocal} from '@libs/Localize';
 import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
 import CONST from '@src/CONST';
 import type ModalType from '@src/types/utils/ModalType';
 
-function isPdfFile(sourceURL: string, fileObject: FileObject) {
-    return !!sourceURL && (Str.isPDF(sourceURL) || (fileObject && Str.isPDF(fileObject.name ?? translateLocal('attachmentView.unknownFilename'))));
+function isPdfFile(source: string | number, fileObject: FileObject) {
+    return !!source && (Str.isPDF(source) || (fileObject?.name ? Str.isPDF(fileObject.name) : false));
 }
 
-function useReportAttachmentModalType(file?: FileObject | FileObject[]) {
+function useReportAttachmentModalType(source?: string | number, file?: FileObject | FileObject[]) {
     const [modalType, setModalType] = useState<ModalType>(CONST.MODAL.MODAL_TYPE.CENTERED_UNSWIPEABLE);
     useEffect(() => {
-        if (!file) {
-            setModalType(CONST.MODAL.MODAL_TYPE.CENTERED_UNSWIPEABLE);
+        if (!file && !source) {
+            setModalType(CONST.MODAL.MODAL_TYPE.CENTERED);
             return;
         }
 
         let isPdf = false;
 
         if (Array.isArray(file)) {
-            isPdf = file.some((f) => isPdfFile(f.uri ?? '', f));
+            isPdf = file.some((f) => isPdfFile(source ?? f.uri ?? '', f));
         } else {
-            isPdf = isPdfFile(file?.uri ?? '', file ?? {});
+            isPdf = isPdfFile(source ?? file?.uri ?? '', file ?? {});
         }
 
         // If our attachment is a PDF, return the unswipeable Modal type.
         setModalType(isPdf ? CONST.MODAL.MODAL_TYPE.CENTERED_UNSWIPEABLE : CONST.MODAL.MODAL_TYPE.CENTERED);
-    }, [file]);
+    }, [file, source]);
 
     return modalType;
 }
diff --git a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
index 2b37cd069a9f..47cef9a88fe0 100644
--- a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
+++ b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
@@ -8,10 +8,12 @@ import useFilesValidation from '@hooks/useFilesValidation';
 import useNetwork from '@hooks/useNetwork';
 import useOnyx from '@hooks/useOnyx';
 import {openReport} from '@libs/actions/Report';
+import validateAttachmentFile from '@libs/AttachmentUtils';
+import type {AttachmentValidationResult} from '@libs/AttachmentUtils';
 import {cleanFileName} from '@libs/fileDownload/FileUtils';
 import {isReportNotFound} from '@libs/ReportUtils';
 import tryResolveUrlFromApiRoot from '@libs/tryResolveUrlFromApiRoot';
-import type {AttachmentContentProps, AttachmentModalBaseContentProps} from '@pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types';
+import type {AttachmentContentProps, AttachmentModalBaseContentProps, OnValidateFileCallback} from '@pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types';
 import AttachmentModalContainer from '@pages/media/AttachmentModalScreen/AttachmentModalContainer';
 import useDownloadAttachment from '@pages/media/AttachmentModalScreen/routes/hooks/useDownloadAttachment';
 import useNavigateToReportOnRefresh from '@pages/media/AttachmentModalScreen/routes/hooks/useNavigateToReportOnRefresh';
@@ -114,7 +116,7 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
 
     const [source, setSource] = useState(() => Number(sourceParam) || (typeof sourceParam === 'string' ? tryResolveUrlFromApiRoot(decodeURIComponent(sourceParam)) : undefined));
     const [validFilesToUpload, setValidFilesToUpload] = useState<FileObject[]>([]);
-    const {ErrorModal, validateFiles, PDFValidationComponent} = useFilesValidation(setValidFilesToUpload, false, setSource);
+    const {ErrorModal, validateFiles, PDFValidationComponent} = useFilesValidation(setValidFilesToUpload, false);
 
     useEffect(() => {
         if (!file) {
@@ -148,22 +150,33 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
         validateFiles(fileObjects, filteredItems);
     }, [dataTransferItems, file, validateFiles]);
 
-    const modalType = useReportAttachmentModalType(validFilesToUpload ?? file);
+    // Validates the attachment file and renders the appropriate modal type or errors
+    const onValidateFile: OnValidateFileCallback = useCallback((fileToValidate, setFile) => {
+        if (!fileToValidate) {
+            return;
+        }
 
-    const onConfirm = useCallback(
-        (f: FileObject | FileObject[]) => {
-            if (Array.isArray(validFilesToUpload) && validFilesToUpload.length > 0) {
-                onConfirmParam?.(validFilesToUpload);
-            } else {
-                onConfirmParam?.(f);
+        function updateState(result: AttachmentValidationResult | undefined) {
+            if (!result?.isValid) {
+                return;
             }
-        },
-        [onConfirmParam, validFilesToUpload],
-    );
 
-    const onDownloadAttachment = useDownloadAttachment({
-        isAuthTokenRequired,
-    });
+            setSource(result.source);
+            setFile(result.file);
+        }
+
+        if (Array.isArray(fileToValidate)) {
+            Promise.all(fileToValidate.map((f) => validateAttachmentFile(f))).then((results) => {
+                const firstValidResult = results.find((result) => result.isValid);
+                updateState(firstValidResult);
+            });
+            return;
+        }
+
+        validateAttachmentFile(file).then(updateState);
+    }, []);
+
+    const modalType = useReportAttachmentModalType(source, validFilesToUpload ?? file);
 
     const isLoading = useMemo(() => {
         if (isOffline || isReportNotFound(report) || !reportID) {
@@ -178,13 +191,20 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
         );
     }, [isOffline, report, reportID, isLoadingApp, reportMetadata?.isLoadingInitialReportActions, shouldFetchReport, validFilesToUpload]);
 
-    // const confirmAndContinue = useCallback(() => {
-    //     if (fileError !== CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.MAX_FILE_LIMIT_EXCEEDED) {
-    //         return;
-    //     }
+    const onConfirm = useCallback(
+        (f: FileObject | FileObject[]) => {
+            if (Array.isArray(validFilesToUpload) && validFilesToUpload.length > 0) {
+                onConfirmParam?.(validFilesToUpload);
+            } else {
+                onConfirmParam?.(f);
+            }
+        },
+        [onConfirmParam, validFilesToUpload],
+    );
 
-    //     setFilesToValidate(file);
-    // }, [fileError, file]);
+    const onDownloadAttachment = useDownloadAttachment({
+        isAuthTokenRequired,
+    });
 
     const contentProps = useMemo<AttachmentModalBaseContentProps>(() => {
         if (validFilesToUpload === undefined) {
@@ -195,6 +215,7 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
 
         return {
             file: validFilesToUpload,
+            onValidateFile,
             source,
             isLoading,
             isAuthTokenRequired,
@@ -224,6 +245,7 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
         shouldDisableSendButton,
         source,
         validFilesToUpload,
+        onValidateFile,
     ]);
 
     return (
diff --git a/tests/unit/AttachmentValidationTest.ts b/tests/unit/AttachmentValidationTest.ts
deleted file mode 100644
index 3dea2216ba1e..000000000000
--- a/tests/unit/AttachmentValidationTest.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import {validateAttachmentFile} from '@libs/AttachmentValidation';
-import CONST from '../../src/CONST';
-
-jest.useFakeTimers();
-
-const createMockFile = (name: string, size: number) => ({
-    name,
-    size,
-});
-
-describe('AttachmentValidation', () => {
-    describe('validateAttachment', () => {
-        it('should not return SINGLE_FILE.FILE_TOO_SMALL when validating small attachment', () => {
-            const file = createMockFile('file.csv', CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE - 1);
-            const error = validateAttachmentFile(file, false, false);
-            expect(error).not.toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL);
-        });
-
-        it('should return SINGLE_FILE.FILE_TOO_SMALL when validating small receipt', () => {
-            const file = createMockFile('receipt.jpg', CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE - 1);
-            const error = validateAttachmentFile(file, false, true);
-            expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL);
-        });
-
-        it('should return SINGLE_FILE.FILE_TOO_LARGE for large non-image file', () => {
-            const file = createMockFile('file.pdf', CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE + 1);
-            const error = validateAttachmentFile(file);
-            expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE);
-        });
-
-        it('should return MULTIPLE_FILES.FILE_TOO_LARGE when checking multiple files', () => {
-            const file = createMockFile('file.pdf', CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE + 1);
-            const error = validateAttachmentFile(file, true);
-            expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.MULTIPLE_FILES.FILE_TOO_LARGE);
-        });
-
-        it('should return SINGLE_FILE.WRONG_FILE_TYPE for invalid receipt extension', () => {
-            const file = createMockFile('receipt.exe', CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE - 1);
-            const error = validateAttachmentFile(file, false, true);
-            expect(error).toBe(CONST.ATTACHMENT_VALIDATION_ERRORS.SINGLE_FILE.WRONG_FILE_TYPE);
-        });
-
-        it('should return empty string for valid image receipt', () => {
-            const file = createMockFile('receipt.jpg', CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE - 1);
-            const error = validateAttachmentFile(file, false, true);
-            expect(error).toBe('');
-        });
-    });
-});
diff --git a/tests/unit/FileUtilsTest.ts b/tests/unit/FileUtilsTest.ts
index a5f4f34fe913..344d0c705a6b 100644
--- a/tests/unit/FileUtilsTest.ts
+++ b/tests/unit/FileUtilsTest.ts
@@ -4,6 +4,11 @@ import * as FileUtils from '../../src/libs/fileDownload/FileUtils';
 
 jest.useFakeTimers();
 
+const createMockFile = (name: string, size: number) => ({
+    name,
+    size,
+});
+
 describe('FileUtils', () => {
     describe('splitExtensionFromFileName', () => {
         it('should return correct file name and extension', () => {
@@ -38,4 +43,42 @@ describe('FileUtils', () => {
             expect(actualFileName).toEqual(expectedFileName.replace(CONST.REGEX.ILLEGAL_FILENAME_CHARACTERS, '_'));
         });
     });
+
+    describe('validateAttachment', () => {
+        it('should not return FILE_TOO_SMALL when validating small attachment', () => {
+            const file = createMockFile('file.csv', CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE - 1);
+            const error = FileUtils.validateAttachment(file, false, false);
+            expect(error).not.toBe(CONST.FILE_VALIDATION_ERRORS.FILE_TOO_SMALL);
+        });
+
+        it('should return FILE_TOO_SMALL when validating small receipt', () => {
+            const file = createMockFile('receipt.jpg', CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE - 1);
+            const error = FileUtils.validateAttachment(file, false, true);
+            expect(error).toBe(CONST.FILE_VALIDATION_ERRORS.FILE_TOO_SMALL);
+        });
+
+        it('should return FILE_TOO_LARGE for large non-image file', () => {
+            const file = createMockFile('file.pdf', CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE + 1);
+            const error = FileUtils.validateAttachment(file);
+            expect(error).toBe(CONST.FILE_VALIDATION_ERRORS.FILE_TOO_LARGE);
+        });
+
+        it('should return FILE_TOO_LARGE_MULTIPLE when checking multiple files', () => {
+            const file = createMockFile('file.pdf', CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE + 1);
+            const error = FileUtils.validateAttachment(file, true);
+            expect(error).toBe(CONST.FILE_VALIDATION_ERRORS.FILE_TOO_LARGE_MULTIPLE);
+        });
+
+        it('should return WRONG_FILE_TYPE for invalid receipt extension', () => {
+            const file = createMockFile('receipt.exe', CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE - 1);
+            const error = FileUtils.validateAttachment(file, false, true);
+            expect(error).toBe(CONST.FILE_VALIDATION_ERRORS.WRONG_FILE_TYPE);
+        });
+
+        it('should return empty string for valid image receipt', () => {
+            const file = createMockFile('receipt.jpg', CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE - 1);
+            const error = FileUtils.validateAttachment(file, false, true);
+            expect(error).toBe('');
+        });
+    });
 });

From 2896fffcb1b25b39ccdfd2f4976824376fc1919c Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Wed, 17 Sep 2025 11:31:20 +0100
Subject: [PATCH 21/31] fix: TS error and improve isPdfFile function

---
 .../routes/hooks/useReportAttachmentModalType.ts          | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/pages/media/AttachmentModalScreen/routes/hooks/useReportAttachmentModalType.ts b/src/pages/media/AttachmentModalScreen/routes/hooks/useReportAttachmentModalType.ts
index 69619a4c6f0f..ac7f4e704bb6 100644
--- a/src/pages/media/AttachmentModalScreen/routes/hooks/useReportAttachmentModalType.ts
+++ b/src/pages/media/AttachmentModalScreen/routes/hooks/useReportAttachmentModalType.ts
@@ -5,7 +5,13 @@ import CONST from '@src/CONST';
 import type ModalType from '@src/types/utils/ModalType';
 
 function isPdfFile(source: string | number, fileObject: FileObject) {
-    return !!source && (Str.isPDF(source) || (fileObject?.name ? Str.isPDF(fileObject.name) : false));
+    if (!source) {
+        return false;
+    }
+
+    const isSourcePdf = typeof source === 'string' ? Str.isPDF(source) : false;
+    const isFilePdf = fileObject?.name ? Str.isPDF(fileObject.name) : false;
+    return isSourcePdf || isFilePdf;
 }
 
 function useReportAttachmentModalType(source?: string | number, file?: FileObject | FileObject[]) {

From 5d682e53ffce9adcc3df465e7c967086ef78c31a Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Wed, 17 Sep 2025 11:46:06 +0100
Subject: [PATCH 22/31] fix: invalid prop

---
 .../routes/report/ReportAddAttachmentModalContent.tsx           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
index 47cef9a88fe0..06c8ca2049a6 100644
--- a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
+++ b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
@@ -173,7 +173,7 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
             return;
         }
 
-        validateAttachmentFile(file).then(updateState);
+        validateAttachmentFile(fileToValidate).then(updateState);
     }, []);
 
     const modalType = useReportAttachmentModalType(source, validFilesToUpload ?? file);

From 438d06d4b24255c51be8a2f515b0642d95ccef6e Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Sat, 20 Sep 2025 11:34:11 +0100
Subject: [PATCH 23/31] fix: add missing displayName

---
 .../routes/report/ReportAddAttachmentModalContent.tsx            | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
index 06c8ca2049a6..049891c0041e 100644
--- a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
+++ b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
@@ -303,5 +303,6 @@ function AddAttachmentModalCarouselView({fileToDisplay, files}: AttachmentConten
         />
     );
 }
+AddAttachmentModalCarouselView.displayName = 'AddAttachmentModalCarouselView';
 
 export default ReportAddAttachmentModalContent;

From bfae2ab02829613b781fd25ab91231e0c42510f1 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Tue, 23 Sep 2025 16:01:29 +0100
Subject: [PATCH 24/31] refactor: move attachment validation to
 ReportActionCompose

---
 src/hooks/useFilesValidation.tsx              |  10 +-
 src/libs/fileDownload/FileUtils.ts            |  48 +++++
 .../ReportActionCompose.tsx                   | 145 ++-----------
 .../useAttachmentUploadValidation.ts          | 202 ++++++++++++++++++
 .../ReportAddAttachmentModalContent.tsx       | 121 +++--------
 5 files changed, 300 insertions(+), 226 deletions(-)
 create mode 100644 src/pages/home/report/ReportActionCompose/useAttachmentUploadValidation.ts

diff --git a/src/hooks/useFilesValidation.tsx b/src/hooks/useFilesValidation.tsx
index eed67deff167..f8c5d1e1a6c8 100644
--- a/src/hooks/useFilesValidation.tsx
+++ b/src/hooks/useFilesValidation.tsx
@@ -31,7 +31,7 @@ const sortFilesByOriginalOrder = (files: FileObject[], orderMap: Map<string, num
     return files.sort((a, b) => (orderMap.get(a.uri ?? '') ?? 0) - (orderMap.get(b.uri ?? '') ?? 0));
 };
 
-function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => void, isValidatingReceipts = true) {
+function useFilesValidation(proceedWithFilesAction: (files: FileObject[], dataTransferItems: DataTransferItem[]) => void, isValidatingReceipts = true) {
     const styles = useThemeStyles();
     const {translate} = useLocalize();
     const [isErrorModalVisible, setIsErrorModalVisible] = useState(false);
@@ -169,7 +169,7 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
             }
         } else if (validFiles.current.length > 0) {
             const sortedFiles = sortFilesByOriginalOrder(validFiles.current, originalFileOrder.current);
-            proceedWithFilesAction(sortedFiles);
+            proceedWithFilesAction(sortedFiles, dataTransferItemList.current);
             resetValidationState();
         }
     }, [deduplicateErrors, pdfFilesToRender.length, proceedWithFilesAction, resetValidationState]);
@@ -257,7 +257,7 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
                         }
                     } else if (processedFiles.length > 0) {
                         const sortedFiles = sortFilesByOriginalOrder(processedFiles, originalFileOrder.current);
-                        proceedWithFilesAction(sortedFiles);
+                        proceedWithFilesAction(sortedFiles, dataTransferItemList.current);
                         resetValidationState();
                     }
                 }
@@ -307,13 +307,13 @@ function useFilesValidation(proceedWithFilesAction: (files: FileObject[]) => voi
             setIsErrorModalVisible(false);
             InteractionManager.runAfterInteractions(() => {
                 if (sortedFiles.length !== 0) {
-                    proceedWithFilesAction(sortedFiles);
+                    proceedWithFilesAction(sortedFiles, dataTransferItemList.current);
                 }
                 resetValidationState();
             });
         } else {
             if (sortedFiles.length !== 0) {
-                proceedWithFilesAction(sortedFiles);
+                proceedWithFilesAction(sortedFiles, dataTransferItemList.current);
             }
             hideModalAndReset();
         }
diff --git a/src/libs/fileDownload/FileUtils.ts b/src/libs/fileDownload/FileUtils.ts
index c2979ef2d380..943a07ba1d44 100644
--- a/src/libs/fileDownload/FileUtils.ts
+++ b/src/libs/fileDownload/FileUtils.ts
@@ -654,6 +654,51 @@ const getConfirmModalPrompt = (attachmentInvalidReason: TranslationPaths | undef
     return translateLocal(attachmentInvalidReason);
 };
 
+function getFilesFromClipboardEvent(event: DragEvent) {
+    if (event.dataTransfer?.files.length && event.dataTransfer?.files.length > 1) {
+        const files = Array.from(event.dataTransfer?.files).map((file) => {
+            // eslint-disable-next-line no-param-reassign
+            file.uri = URL.createObjectURL(file);
+            return file;
+        });
+        return files;
+    }
+
+    const data = event.dataTransfer?.files[0];
+    if (data) {
+        data.uri = URL.createObjectURL(data);
+        return [data];
+    }
+
+    return [];
+}
+
+function cleanFileObject(fileObject: FileObject): FileObject {
+    if ('getAsFile' in fileObject && typeof fileObject.getAsFile === 'function') {
+        return fileObject.getAsFile() as FileObject;
+    }
+
+    return fileObject;
+}
+
+function cleanFileObjectName(fileObject: FileObject): FileObject {
+    if (fileObject instanceof File) {
+        const cleanName = cleanFileName(fileObject.name);
+        if (fileObject.name !== cleanName) {
+            const updatedFile = new File([fileObject], cleanName, {type: fileObject.type});
+            const inputSource = URL.createObjectURL(updatedFile);
+            updatedFile.uri = inputSource;
+            return updatedFile;
+        }
+        if (!fileObject.uri) {
+            const inputSource = URL.createObjectURL(fileObject);
+            // eslint-disable-next-line no-param-reassign
+            fileObject.uri = inputSource;
+        }
+    }
+    return fileObject;
+}
+
 export {
     showGeneralErrorAlert,
     showSuccessAlert,
@@ -682,4 +727,7 @@ export {
     getFileValidationErrorText,
     hasHeicOrHeifExtension,
     getConfirmModalPrompt,
+    getFilesFromClipboardEvent,
+    cleanFileObject,
+    cleanFileObjectName,
 };
diff --git a/src/pages/home/report/ReportActionCompose/ReportActionCompose.tsx b/src/pages/home/report/ReportActionCompose/ReportActionCompose.tsx
index 3d1c166dc5df..cc83a8291c53 100644
--- a/src/pages/home/report/ReportActionCompose/ReportActionCompose.tsx
+++ b/src/pages/home/report/ReportActionCompose/ReportActionCompose.tsx
@@ -20,7 +20,6 @@ import OfflineWithFeedback from '@components/OfflineWithFeedback';
 import {usePersonalDetails} from '@components/OnyxListItemProvider';
 import useCurrentUserPersonalDetails from '@hooks/useCurrentUserPersonalDetails';
 import useDebounce from '@hooks/useDebounce';
-import useFilesValidation from '@hooks/useFilesValidation';
 import useHandleExceedMaxCommentLength from '@hooks/useHandleExceedMaxCommentLength';
 import useHandleExceedMaxTaskTitleLength from '@hooks/useHandleExceedMaxTaskTitleLength';
 import useLocalize from '@hooks/useLocalize';
@@ -48,29 +47,21 @@ import {
     isGroupChat,
     isReportApproved,
     isReportTransactionThread,
-    isSelfDM,
     isSettled,
     temporary_getMoneyRequestOptions,
 } from '@libs/ReportUtils';
-import {shouldRestrictUserBillableActions} from '@libs/SubscriptionUtils';
 import {getTransactionID, hasReceipt as hasReceiptTransactionUtils, isDistanceRequest, isManualDistanceRequest} from '@libs/TransactionUtils';
 import willBlurTextInputOnTapOutsideFunc from '@libs/willBlurTextInputOnTapOutside';
-import Navigation from '@navigation/Navigation';
 import AgentZeroProcessingRequestIndicator from '@pages/home/report/AgentZeroProcessingRequestIndicator';
 import ParticipantLocalTime from '@pages/home/report/ParticipantLocalTime';
 import ReportTypingIndicator from '@pages/home/report/ReportTypingIndicator';
-import AttachmentModalContext from '@pages/media/AttachmentModalScreen/AttachmentModalContext';
 import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
 import {hideEmojiPicker, isActive as isActiveEmojiPickerAction} from '@userActions/EmojiPickerAction';
-import {initMoneyRequest, replaceReceipt, setMoneyRequestParticipantsFromReport, setMoneyRequestReceipt} from '@userActions/IOU';
 import {addAttachment as addAttachmentReportActions, setIsComposerFullSize} from '@userActions/Report';
 import Timing from '@userActions/Timing';
-import {buildOptimisticTransactionAndCreateDraft} from '@userActions/TransactionEdit';
 import {isBlockedFromConcierge as isBlockedFromConciergeUserAction} from '@userActions/User';
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
-import ROUTES from '@src/ROUTES';
-import type SCREENS from '@src/SCREENS';
 import type * as OnyxTypes from '@src/types/onyx';
 import type * as OnyxCommon from '@src/types/onyx/OnyxCommon';
 import {isEmptyObject} from '@src/types/utils/EmptyObject';
@@ -78,6 +69,7 @@ import AttachmentPickerWithMenuItems from './AttachmentPickerWithMenuItems';
 import ComposerWithSuggestions from './ComposerWithSuggestions';
 import type {ComposerRef, ComposerWithSuggestionsProps} from './ComposerWithSuggestions/ComposerWithSuggestions';
 import SendButton from './SendButton';
+import useAttachmentUploadValidation from './useAttachmentUploadValidation';
 
 type SuggestionsRef = {
     resetSuggestions: () => void;
@@ -501,116 +493,21 @@ function ReportActionCompose({
         [isComposerFullSize, reportID, debouncedValidate],
     );
 
-    const reportAttachmentsContext = useContext(AttachmentModalContext);
-    const showAttachmentModalScreen = useCallback(
-        (file: FileObject | FileObject[], dataTransferItems?: DataTransferItem[]) => {
-            reportAttachmentsContext.setCurrentAttachment<typeof SCREENS.REPORT_ADD_ATTACHMENT>({
-                reportID,
-                file,
-                dataTransferItems,
-                headerTitle: translate('reportActionCompose.sendAttachment'),
-                onConfirm: addAttachment,
-                onShow: () => setIsAttachmentPreviewActive(true),
-                onClose: onAttachmentPreviewClose,
-                shouldDisableSendButton: !!exceededMaxLength,
-            });
-            Navigation.navigate(ROUTES.REPORT_ADD_ATTACHMENT.getRoute(reportID));
-        },
-        [addAttachment, exceededMaxLength, onAttachmentPreviewClose, reportAttachmentsContext, reportID, translate],
-    );
-
-    const handleAttachmentDrop = useCallback(
-        (event: DragEvent) => {
-            if (isAttachmentPreviewActive) {
-                return;
-            }
-            if (event.dataTransfer?.files.length && event.dataTransfer?.files.length > 1) {
-                const files = Array.from(event.dataTransfer?.files).map((file) => {
-                    // eslint-disable-next-line no-param-reassign
-                    file.uri = URL.createObjectURL(file);
-                    return file;
-                });
-                showAttachmentModalScreen(files, Array.from(event.dataTransfer?.items ?? []));
-                return;
-            }
-
-            const data = event.dataTransfer?.files[0];
-            if (data) {
-                data.uri = URL.createObjectURL(data);
-                showAttachmentModalScreen([data], Array.from(event.dataTransfer?.items ?? []));
-            }
-        },
-        [isAttachmentPreviewActive, showAttachmentModalScreen],
-    );
-
-    const saveFileAndInitMoneyRequest = (files: FileObject[]) => {
-        if (files.length === 0) {
-            return;
-        }
-        if (shouldAddOrReplaceReceipt && transactionID) {
-            const source = URL.createObjectURL(files.at(0) as Blob);
-            replaceReceipt({transactionID, file: files.at(0) as File, source});
-        } else {
-            const initialTransaction = initMoneyRequest({
-                reportID,
-                newIouRequestType: CONST.IOU.REQUEST_TYPE.SCAN,
-                report,
-                parentReport: newParentReport,
-                currentDate,
-            });
-
-            files.forEach((file, index) => {
-                const source = URL.createObjectURL(file as Blob);
-                const newTransaction =
-                    index === 0
-                        ? (initialTransaction as Partial<OnyxTypes.Transaction>)
-                        : buildOptimisticTransactionAndCreateDraft({
-                              initialTransaction: initialTransaction as Partial<OnyxTypes.Transaction>,
-                              currentUserPersonalDetails,
-                              reportID,
-                          });
-                const newTransactionID = newTransaction?.transactionID ?? CONST.IOU.OPTIMISTIC_TRANSACTION_ID;
-                setMoneyRequestReceipt(newTransactionID, source, file.name ?? '', true);
-                setMoneyRequestParticipantsFromReport(newTransactionID, report);
-            });
-            Navigation.navigate(
-                ROUTES.MONEY_REQUEST_STEP_CONFIRMATION.getRoute(
-                    CONST.IOU.ACTION.CREATE,
-                    isSelfDM(report) ? CONST.IOU.TYPE.TRACK : CONST.IOU.TYPE.SUBMIT,
-                    CONST.IOU.OPTIMISTIC_TRANSACTION_ID,
-                    reportID,
-                ),
-            );
-        }
-    };
-
-    const {validateFiles, PDFValidationComponent, ErrorModal} = useFilesValidation(saveFileAndInitMoneyRequest);
-
-    const handleAddingReceipt = (e: DragEvent) => {
-        if (policy && shouldRestrictUserBillableActions(policy.id)) {
-            Navigation.navigate(ROUTES.RESTRICTED_ACTION.getRoute(policy.id));
-            return;
-        }
-        if (shouldAddOrReplaceReceipt && transactionID) {
-            const file = e?.dataTransfer?.files?.[0];
-            if (file) {
-                file.uri = URL.createObjectURL(file);
-                validateFiles([file], Array.from(e.dataTransfer?.items ?? []));
-                return;
-            }
-        }
-
-        const files = Array.from(e?.dataTransfer?.files ?? []);
-        if (files.length === 0) {
-            return;
-        }
-        files.forEach((file) => {
-            // eslint-disable-next-line no-param-reassign
-            file.uri = URL.createObjectURL(file);
-        });
-
-        validateFiles(files, Array.from(e.dataTransfer?.items ?? []));
-    };
+    const {validateAttachments, onReceiptDropped, PDFValidationComponent, ErrorModal} = useAttachmentUploadValidation({
+        policy,
+        reportID,
+        addAttachment,
+        onAttachmentPreviewClose,
+        exceededMaxLength,
+        shouldAddOrReplaceReceipt,
+        transactionID,
+        report,
+        newParentReport,
+        currentDate,
+        currentUserPersonalDetails,
+        isAttachmentPreviewActive,
+        setIsAttachmentPreviewActive,
+    });
 
     return (
         <View style={[shouldShowReportRecipientLocalTime && !isOffline && styles.chatItemComposeWithFirstRow, isComposerFullSize && styles.chatItemFullComposeRow]}>
@@ -639,7 +536,7 @@ function ReportActionCompose({
                     >
                         {PDFValidationComponent}
                         <AttachmentPickerWithMenuItems
-                            onAttachmentPicked={showAttachmentModalScreen}
+                            onAttachmentPicked={(files) => validateAttachments({files})}
                             reportID={reportID}
                             report={report}
                             currentUserPersonalDetails={currentUserPersonalDetails}
@@ -682,7 +579,7 @@ function ReportActionCompose({
                             inputPlaceholder={inputPlaceholder}
                             isComposerFullSize={isComposerFullSize}
                             setIsFullComposerAvailable={setIsFullComposerAvailable}
-                            onFilePasted={showAttachmentModalScreen}
+                            onFilePasted={(files) => validateAttachments({files})}
                             onCleared={submitForm}
                             disabled={isBlockedFromConcierge}
                             setIsCommentEmpty={setIsCommentEmpty}
@@ -697,13 +594,13 @@ function ReportActionCompose({
                         {shouldDisplayDualDropZone && (
                             <DualDropZone
                                 isEditing={shouldAddOrReplaceReceipt && hasReceipt}
-                                onAttachmentDrop={handleAttachmentDrop}
-                                onReceiptDrop={handleAddingReceipt}
+                                onAttachmentDrop={(e) => validateAttachments({dragEvent: e})}
+                                onReceiptDrop={(e) => onReceiptDropped(e)}
                                 shouldAcceptSingleReceipt={shouldAddOrReplaceReceipt}
                             />
                         )}
                         {!shouldDisplayDualDropZone && (
-                            <DragAndDropConsumer onDrop={handleAttachmentDrop}>
+                            <DragAndDropConsumer onDrop={(e) => validateAttachments({dragEvent: e})}>
                                 <DropZoneUI
                                     icon={Expensicons.MessageInABottle}
                                     dropTitle={translate('dropzone.addAttachments')}
diff --git a/src/pages/home/report/ReportActionCompose/useAttachmentUploadValidation.ts b/src/pages/home/report/ReportActionCompose/useAttachmentUploadValidation.ts
new file mode 100644
index 000000000000..6f91f188aa1d
--- /dev/null
+++ b/src/pages/home/report/ReportActionCompose/useAttachmentUploadValidation.ts
@@ -0,0 +1,202 @@
+import {useCallback, useContext, useRef} from 'react';
+import type {OnyxEntry} from 'react-native-onyx';
+import type {CurrentUserPersonalDetails} from '@components/CurrentUserPersonalDetailsProvider';
+import useFilesValidation from '@hooks/useFilesValidation';
+import useLocalize from '@hooks/useLocalize';
+import {cleanFileObject, cleanFileObjectName, getFilesFromClipboardEvent} from '@libs/fileDownload/FileUtils';
+import {isSelfDM} from '@libs/ReportUtils';
+import {shouldRestrictUserBillableActions} from '@libs/SubscriptionUtils';
+import Navigation from '@navigation/Navigation';
+import AttachmentModalContext from '@pages/media/AttachmentModalScreen/AttachmentModalContext';
+import type {FileObject} from '@pages/media/AttachmentModalScreen/types';
+import {initMoneyRequest, replaceReceipt, setMoneyRequestParticipantsFromReport, setMoneyRequestReceipt} from '@userActions/IOU';
+import {buildOptimisticTransactionAndCreateDraft} from '@userActions/TransactionEdit';
+import CONST from '@src/CONST';
+import ROUTES from '@src/ROUTES';
+import type SCREENS from '@src/SCREENS';
+import type * as OnyxTypes from '@src/types/onyx';
+
+type AttachmentUploadValidationProps = {
+    policy: OnyxEntry<OnyxTypes.Policy>;
+    reportID: string;
+    addAttachment: (file: FileObject | FileObject[]) => void;
+    onAttachmentPreviewClose: () => void;
+    exceededMaxLength: boolean | number | null;
+    shouldAddOrReplaceReceipt: boolean;
+    transactionID: string | undefined;
+    report: OnyxEntry<OnyxTypes.Report>;
+    newParentReport: OnyxEntry<OnyxTypes.Report>;
+    currentDate: string | undefined;
+    currentUserPersonalDetails: CurrentUserPersonalDetails;
+    isAttachmentPreviewActive: boolean;
+    setIsAttachmentPreviewActive: (isActive: boolean) => void;
+};
+
+function useAttachmentUploadValidation({
+    policy,
+    reportID,
+    addAttachment,
+    onAttachmentPreviewClose,
+    exceededMaxLength,
+    shouldAddOrReplaceReceipt,
+    transactionID,
+    report,
+    newParentReport,
+    currentDate,
+    currentUserPersonalDetails,
+    isAttachmentPreviewActive,
+    setIsAttachmentPreviewActive,
+}: AttachmentUploadValidationProps) {
+    const {translate} = useLocalize();
+
+    const reportAttachmentsContext = useContext(AttachmentModalContext);
+    const showAttachmentModalScreen = useCallback(
+        (file: FileObject | FileObject[], dataTransferItems?: DataTransferItem[]) => {
+            reportAttachmentsContext.setCurrentAttachment<typeof SCREENS.REPORT_ADD_ATTACHMENT>({
+                reportID,
+                file,
+                dataTransferItems,
+                headerTitle: translate('reportActionCompose.sendAttachment'),
+                onConfirm: addAttachment,
+                onShow: () => setIsAttachmentPreviewActive(true),
+                onClose: onAttachmentPreviewClose,
+                shouldDisableSendButton: !!exceededMaxLength,
+            });
+            Navigation.navigate(ROUTES.REPORT_ADD_ATTACHMENT.getRoute(reportID));
+        },
+        [addAttachment, exceededMaxLength, onAttachmentPreviewClose, reportAttachmentsContext, reportID, setIsAttachmentPreviewActive, translate],
+    );
+
+    const attachmentUploadType = useRef<'receipt' | 'attachment'>(undefined);
+    const onFilesValidated = (files: FileObject[], dataTransferItems: DataTransferItem[]) => {
+        if (files.length === 0) {
+            return;
+        }
+
+        if (attachmentUploadType.current === 'attachment') {
+            showAttachmentModalScreen(files, dataTransferItems);
+            return;
+        }
+
+        if (shouldAddOrReplaceReceipt && transactionID) {
+            const source = URL.createObjectURL(files.at(0) as Blob);
+            replaceReceipt({transactionID, file: files.at(0) as File, source});
+        } else {
+            const initialTransaction = initMoneyRequest({
+                reportID,
+                newIouRequestType: CONST.IOU.REQUEST_TYPE.SCAN,
+                report,
+                parentReport: newParentReport,
+                currentDate,
+            });
+
+            files.forEach((file, index) => {
+                const source = URL.createObjectURL(file as Blob);
+                const newTransaction =
+                    index === 0
+                        ? (initialTransaction as Partial<OnyxTypes.Transaction>)
+                        : buildOptimisticTransactionAndCreateDraft({
+                              initialTransaction: initialTransaction as Partial<OnyxTypes.Transaction>,
+                              currentUserPersonalDetails,
+                              reportID,
+                          });
+                const newTransactionID = newTransaction?.transactionID ?? CONST.IOU.OPTIMISTIC_TRANSACTION_ID;
+                setMoneyRequestReceipt(newTransactionID, source, file.name ?? '', true);
+                setMoneyRequestParticipantsFromReport(newTransactionID, report);
+            });
+            Navigation.navigate(
+                ROUTES.MONEY_REQUEST_STEP_CONFIRMATION.getRoute(
+                    CONST.IOU.ACTION.CREATE,
+                    isSelfDM(report) ? CONST.IOU.TYPE.TRACK : CONST.IOU.TYPE.SUBMIT,
+                    CONST.IOU.OPTIMISTIC_TRANSACTION_ID,
+                    reportID,
+                ),
+            );
+        }
+    };
+
+    const {validateFiles, PDFValidationComponent, ErrorModal} = useFilesValidation(onFilesValidated);
+
+    const validateAttachments = useCallback(
+        ({dragEvent, files}: {dragEvent?: DragEvent; files?: FileObject | FileObject[]}) => {
+            if (isAttachmentPreviewActive) {
+                return;
+            }
+
+            let extractedFiles: FileObject[] = [];
+
+            if (!files) {
+                if (!dragEvent) {
+                    return;
+                }
+
+                extractedFiles = getFilesFromClipboardEvent(dragEvent);
+            } else {
+                extractedFiles = Array.isArray(files) ? files : [files];
+            }
+
+            const dataTransferItems = Array.from(dragEvent?.dataTransfer?.items ?? []);
+            if (extractedFiles.length === 0) {
+                return;
+            }
+
+            const validIndices: number[] = [];
+            const fileObjects = extractedFiles
+                .map((item, index) => {
+                    const fileObject = cleanFileObject(item);
+                    const cleanedFileObject = cleanFileObjectName(fileObject);
+                    if (cleanedFileObject !== null) {
+                        validIndices.push(index);
+                    }
+                    return cleanedFileObject;
+                })
+                .filter((fileObject) => fileObject !== null);
+
+            if (!fileObjects.length) {
+                return;
+            }
+
+            // Create a filtered items array that matches the fileObjects
+            const filteredItems = dataTransferItems && validIndices.length > 0 ? validIndices.map((index) => dataTransferItems.at(index) ?? ({} as DataTransferItem)) : undefined;
+
+            attachmentUploadType.current = 'attachment';
+            validateFiles(fileObjects, filteredItems);
+        },
+        [isAttachmentPreviewActive, validateFiles],
+    );
+
+    const onReceiptDropped = useCallback(
+        (e: DragEvent) => {
+            if (policy && shouldRestrictUserBillableActions(policy.id)) {
+                Navigation.navigate(ROUTES.RESTRICTED_ACTION.getRoute(policy.id));
+                return;
+            }
+
+            const files = getFilesFromClipboardEvent(e);
+            const items = Array.from(e.dataTransfer?.items ?? []);
+
+            if (shouldAddOrReplaceReceipt && transactionID) {
+                const file = files.at(0);
+                if (!file) {
+                    return;
+                }
+
+                attachmentUploadType.current = 'receipt';
+                validateFiles([file], items);
+            }
+
+            attachmentUploadType.current = 'receipt';
+            validateFiles(files, items);
+        },
+        [policy, shouldAddOrReplaceReceipt, transactionID, validateFiles],
+    );
+
+    return {
+        validateAttachments,
+        onReceiptDropped,
+        PDFValidationComponent,
+        ErrorModal,
+    };
+}
+
+export default useAttachmentUploadValidation;
diff --git a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
index 049891c0041e..fab36b16755a 100644
--- a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
+++ b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
@@ -4,13 +4,11 @@ import AttachmentCarouselView from '@components/Attachments/AttachmentCarousel/A
 import useCarouselArrows from '@components/Attachments/AttachmentCarousel/useCarouselArrows';
 import useAttachmentErrors from '@components/Attachments/AttachmentView/useAttachmentErrors';
 import type {Attachment} from '@components/Attachments/types';
-import useFilesValidation from '@hooks/useFilesValidation';
 import useNetwork from '@hooks/useNetwork';
 import useOnyx from '@hooks/useOnyx';
 import {openReport} from '@libs/actions/Report';
 import validateAttachmentFile from '@libs/AttachmentUtils';
 import type {AttachmentValidationResult} from '@libs/AttachmentUtils';
-import {cleanFileName} from '@libs/fileDownload/FileUtils';
 import {isReportNotFound} from '@libs/ReportUtils';
 import tryResolveUrlFromApiRoot from '@libs/tryResolveUrlFromApiRoot';
 import type {AttachmentContentProps, AttachmentModalBaseContentProps, OnValidateFileCallback} from '@pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types';
@@ -24,32 +22,6 @@ import ONYXKEYS from '@src/ONYXKEYS';
 import type SCREENS from '@src/SCREENS';
 import {isEmptyObject} from '@src/types/utils/EmptyObject';
 
-function cleanFileObject(fileObject: FileObject): FileObject {
-    if ('getAsFile' in fileObject && typeof fileObject.getAsFile === 'function') {
-        return fileObject.getAsFile() as FileObject;
-    }
-
-    return fileObject;
-}
-
-function cleanFileObjectName(fileObject: FileObject): FileObject {
-    if (fileObject instanceof File) {
-        const cleanName = cleanFileName(fileObject.name);
-        if (fileObject.name !== cleanName) {
-            const updatedFile = new File([fileObject], cleanName, {type: fileObject.type});
-            const inputSource = URL.createObjectURL(updatedFile);
-            updatedFile.uri = inputSource;
-            return updatedFile;
-        }
-        if (!fileObject.uri) {
-            const inputSource = URL.createObjectURL(fileObject);
-            // eslint-disable-next-line no-param-reassign
-            fileObject.uri = inputSource;
-        }
-    }
-    return fileObject;
-}
-
 const convertFileToAttachment = (file: FileObject | undefined): Attachment => {
     if (!file) {
         return {source: ''};
@@ -65,7 +37,6 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
     const {
         attachmentID,
         file,
-        dataTransferItems,
         source: sourceParam,
         isAuthTokenRequired,
         attachmentLink,
@@ -115,40 +86,6 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
     }, [reportID, fetchReport, shouldFetchReport]);
 
     const [source, setSource] = useState(() => Number(sourceParam) || (typeof sourceParam === 'string' ? tryResolveUrlFromApiRoot(decodeURIComponent(sourceParam)) : undefined));
-    const [validFilesToUpload, setValidFilesToUpload] = useState<FileObject[]>([]);
-    const {ErrorModal, validateFiles, PDFValidationComponent} = useFilesValidation(setValidFilesToUpload, false);
-
-    useEffect(() => {
-        if (!file) {
-            return;
-        }
-
-        const files = Array.isArray(file) ? file : [file];
-        if (files.length === 0) {
-            return;
-        }
-
-        const validIndices: number[] = [];
-        const fileObjects = files
-            .map((item, index) => {
-                const fileObject = cleanFileObject(item);
-                const cleanedFileObject = cleanFileObjectName(fileObject);
-                if (cleanedFileObject !== null) {
-                    validIndices.push(index);
-                }
-                return cleanedFileObject;
-            })
-            .filter((fileObject) => fileObject !== null);
-
-        if (!fileObjects.length) {
-            return;
-        }
-
-        // Create a filtered items array that matches the fileObjects
-        const filteredItems = dataTransferItems && validIndices.length > 0 ? validIndices.map((index) => dataTransferItems.at(index) ?? ({} as DataTransferItem)) : undefined;
-
-        validateFiles(fileObjects, filteredItems);
-    }, [dataTransferItems, file, validateFiles]);
 
     // Validates the attachment file and renders the appropriate modal type or errors
     const onValidateFile: OnValidateFileCallback = useCallback((fileToValidate, setFile) => {
@@ -176,30 +113,25 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
         validateAttachmentFile(fileToValidate).then(updateState);
     }, []);
 
-    const modalType = useReportAttachmentModalType(source, validFilesToUpload ?? file);
+    const modalType = useReportAttachmentModalType(source, file);
 
     const isLoading = useMemo(() => {
         if (isOffline || isReportNotFound(report) || !reportID) {
             return false;
         }
         const isEmptyReport = isEmptyObject(report);
-        return (
-            !!isLoadingApp ||
-            isEmptyReport ||
-            (reportMetadata?.isLoadingInitialReportActions !== false && shouldFetchReport) ||
-            (Array.isArray(validFilesToUpload) && validFilesToUpload.length === 0)
-        );
-    }, [isOffline, report, reportID, isLoadingApp, reportMetadata?.isLoadingInitialReportActions, shouldFetchReport, validFilesToUpload]);
+        return !!isLoadingApp || isEmptyReport || (reportMetadata?.isLoadingInitialReportActions !== false && shouldFetchReport) || (Array.isArray(file) && file.length === 0);
+    }, [isOffline, report, reportID, isLoadingApp, reportMetadata?.isLoadingInitialReportActions, shouldFetchReport, file]);
 
     const onConfirm = useCallback(
         (f: FileObject | FileObject[]) => {
-            if (Array.isArray(validFilesToUpload) && validFilesToUpload.length > 0) {
-                onConfirmParam?.(validFilesToUpload);
+            if (Array.isArray(file) && file.length > 0) {
+                onConfirmParam?.(file);
             } else {
                 onConfirmParam?.(f);
             }
         },
-        [onConfirmParam, validFilesToUpload],
+        [onConfirmParam, file],
     );
 
     const onDownloadAttachment = useDownloadAttachment({
@@ -207,14 +139,14 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
     });
 
     const contentProps = useMemo<AttachmentModalBaseContentProps>(() => {
-        if (validFilesToUpload === undefined) {
+        if (file === undefined || (Array.isArray(file) && file.length === 0)) {
             return {
                 isLoading: true,
             };
         }
 
         return {
-            file: validFilesToUpload,
+            file,
             onValidateFile,
             source,
             isLoading,
@@ -229,36 +161,31 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
             onConfirm,
             onDownloadAttachment,
             AttachmentContent: AddAttachmentModalCarouselView,
-            ExtraModals: ErrorModal,
         };
     }, [
-        ErrorModal,
-        accountID,
-        attachmentID,
+        file,
+        onValidateFile,
+        source,
+        isLoading,
+        isAuthTokenRequired,
         attachmentLink,
+        originalFileName,
+        attachmentID,
+        accountID,
         headerTitle,
-        isAuthTokenRequired,
-        isLoading,
+        shouldDisableSendButton,
         onConfirm,
         onDownloadAttachment,
-        originalFileName,
-        shouldDisableSendButton,
-        source,
-        validFilesToUpload,
-        onValidateFile,
     ]);
 
     return (
-        <>
-            {PDFValidationComponent}
-            <AttachmentModalContainer
-                navigation={navigation}
-                contentProps={contentProps}
-                modalType={modalType}
-                onShow={onShow}
-                onClose={onClose}
-            />
-        </>
+        <AttachmentModalContainer
+            navigation={navigation}
+            contentProps={contentProps}
+            modalType={modalType}
+            onShow={onShow}
+            onClose={onClose}
+        />
     );
 }
 ReportAddAttachmentModalContent.displayName = 'ReportAddAttachmentModalContent';

From 1987deb9c108a17cd03219776e15a5373d5b94b3 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Tue, 23 Sep 2025 16:01:55 +0100
Subject: [PATCH 25/31] refactor: replace ExtraModels prop with ExtraContent in
 container

---
 .../AttachmentModalBaseContent/index.tsx      |  2 -
 .../AttachmentModalBaseContent/types.ts       |  3 --
 .../AttachmentModalContainer/index.native.tsx | 27 +++++-----
 .../AttachmentModalContainer/index.tsx        | 50 +++++++++++--------
 .../media/AttachmentModalScreen/types.ts      | 10 ++++
 5 files changed, 55 insertions(+), 37 deletions(-)

diff --git a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
index 4520dd80a971..e2bbcd3777aa 100644
--- a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
+++ b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
@@ -57,7 +57,6 @@ function AttachmentModalBaseContent({
     onClose,
     onConfirm,
     AttachmentContent,
-    ExtraModals,
     onCarouselAttachmentChange = () => {},
     onValidateFile,
 }: AttachmentModalBaseContentProps) {
@@ -353,7 +352,6 @@ function AttachmentModalBaseContent({
                     )}
                 </LayoutAnimationConfig>
             )}
-            {ExtraModals}
         </GestureHandlerRootView>
     );
 }
diff --git a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts
index a7dd1fcee4cb..15d08df5ea1b 100644
--- a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts
+++ b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts
@@ -104,9 +104,6 @@ type AttachmentModalBaseContentProps = {
 
     AttachmentContent?: AttachmentContent;
 
-    /** Extra modals to be displayed in the modal */
-    ExtraModals?: React.ReactNode;
-
     /** Callback triggered when the download button is pressed */
     onDownloadAttachment?: DownloadAttachmentCallback;
 
diff --git a/src/pages/media/AttachmentModalScreen/AttachmentModalContainer/index.native.tsx b/src/pages/media/AttachmentModalScreen/AttachmentModalContainer/index.native.tsx
index 87a8c4fc1f00..10b481181824 100644
--- a/src/pages/media/AttachmentModalScreen/AttachmentModalContainer/index.native.tsx
+++ b/src/pages/media/AttachmentModalScreen/AttachmentModalContainer/index.native.tsx
@@ -8,7 +8,7 @@ import AttachmentModalContext from '@pages/media/AttachmentModalScreen/Attachmen
 import type {AttachmentModalScreenType} from '@pages/media/AttachmentModalScreen/types';
 import type AttachmentModalContainerProps from './types';
 
-function AttachmentModalContainer<Screen extends AttachmentModalScreenType>({contentProps, navigation, onShow, onClose}: AttachmentModalContainerProps<Screen>) {
+function AttachmentModalContainer<Screen extends AttachmentModalScreenType>({contentProps, navigation, onShow, onClose, ExtraContent}: AttachmentModalContainerProps<Screen>) {
     const attachmentsContext = useContext(AttachmentModalContext);
     const testID = typeof contentProps.source === 'string' ? contentProps.source : (contentProps.source?.toString() ?? '');
 
@@ -36,17 +36,20 @@ function AttachmentModalContainer<Screen extends AttachmentModalScreenType>({con
     }, [onShow]);
 
     return (
-        <ScreenWrapper
-            navigation={navigation}
-            testID={`attachment-modal-${testID}`}
-            enableEdgeToEdgeBottomSafeAreaPadding
-        >
-            <AttachmentModalBaseContent
-                // eslint-disable-next-line react/jsx-props-no-spreading
-                {...contentProps}
-                onClose={closeScreen}
-            />
-        </ScreenWrapper>
+        <>
+            <ScreenWrapper
+                navigation={navigation}
+                testID={`attachment-modal-${testID}`}
+                enableEdgeToEdgeBottomSafeAreaPadding
+            >
+                <AttachmentModalBaseContent
+                    // eslint-disable-next-line react/jsx-props-no-spreading
+                    {...contentProps}
+                    onClose={closeScreen}
+                />
+            </ScreenWrapper>
+            {ExtraContent}
+        </>
     );
 }
 
diff --git a/src/pages/media/AttachmentModalScreen/AttachmentModalContainer/index.tsx b/src/pages/media/AttachmentModalScreen/AttachmentModalContainer/index.tsx
index dd98a9097fee..aa3adfd9b6e3 100644
--- a/src/pages/media/AttachmentModalScreen/AttachmentModalContainer/index.tsx
+++ b/src/pages/media/AttachmentModalScreen/AttachmentModalContainer/index.tsx
@@ -8,7 +8,14 @@ import type {AttachmentModalScreenType} from '@pages/media/AttachmentModalScreen
 import CONST from '@src/CONST';
 import type AttachmentModalContainerProps from './types';
 
-function AttachmentModalContainer<Screen extends AttachmentModalScreenType>({contentProps, modalType, onShow, onClose, shouldHandleNavigationBack}: AttachmentModalContainerProps<Screen>) {
+function AttachmentModalContainer<Screen extends AttachmentModalScreenType>({
+    contentProps,
+    modalType,
+    onShow,
+    onClose,
+    shouldHandleNavigationBack,
+    ExtraContent,
+}: AttachmentModalContainerProps<Screen>) {
     const [isVisible, setIsVisible] = useState(true);
     const attachmentsContext = useContext(AttachmentModalContext);
 
@@ -39,26 +46,29 @@ function AttachmentModalContainer<Screen extends AttachmentModalScreenType>({con
     }, [onShow]);
 
     return (
-        <Modal
-            isVisible={isVisible}
-            type={modalType ?? CONST.MODAL.MODAL_TYPE.CENTERED_UNSWIPEABLE}
-            initialFocus={() => {
-                if (!contentProps.submitRef?.current) {
-                    return false;
-                }
-                return contentProps.submitRef.current;
-            }}
-            shouldHandleNavigationBack={shouldHandleNavigationBack}
-            onClose={closeModal}
-            enableEdgeToEdgeBottomSafeAreaPadding
-        >
-            <AttachmentModalBaseContent
-                // eslint-disable-next-line react/jsx-props-no-spreading
-                {...contentProps}
-                shouldDisplayHelpButton={false}
+        <>
+            <Modal
+                isVisible={isVisible}
+                type={modalType ?? CONST.MODAL.MODAL_TYPE.CENTERED_UNSWIPEABLE}
+                initialFocus={() => {
+                    if (!contentProps.submitRef?.current) {
+                        return false;
+                    }
+                    return contentProps.submitRef.current;
+                }}
+                shouldHandleNavigationBack={shouldHandleNavigationBack}
                 onClose={closeModal}
-            />
-        </Modal>
+                enableEdgeToEdgeBottomSafeAreaPadding
+            >
+                <AttachmentModalBaseContent
+                    // eslint-disable-next-line react/jsx-props-no-spreading
+                    {...contentProps}
+                    shouldDisplayHelpButton={false}
+                    onClose={closeModal}
+                />
+            </Modal>
+            {ExtraContent}
+        </>
     );
 }
 
diff --git a/src/pages/media/AttachmentModalScreen/types.ts b/src/pages/media/AttachmentModalScreen/types.ts
index b5e5df5bbd5a..e383d298bc97 100644
--- a/src/pages/media/AttachmentModalScreen/types.ts
+++ b/src/pages/media/AttachmentModalScreen/types.ts
@@ -22,10 +22,20 @@ type ImagePickerResponse = {
 type FileObject = Partial<File | ImagePickerResponse>;
 
 type AttachmentModalContainerModalProps = {
+    /** The type of the modal */
     modalType?: ModalType;
+
+    /** Callback to fire when the modal is shown */
     onShow?: () => void;
+
+    /** Callback to fire when the modal is closed */
     onClose?: () => void;
+
+    /** Whether to handle navigation back */
     shouldHandleNavigationBack?: boolean;
+
+    /** Extra modals to be displayed in the modal */
+    ExtraContent?: React.ReactNode;
 };
 
 const ATTACHMENT_MODAL_SCREENS = [

From e15abfc6f817ba21d71c3732f29b3889b26e9ff9 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Wed, 24 Sep 2025 12:47:07 +0100
Subject: [PATCH 26/31] fix: file validation and source extraction in "Add
 attachment"

---
 .../AttachmentModalBaseContent/index.tsx      |  9 +--
 .../AttachmentModalBaseContent/types.ts       |  7 +-
 .../ReportAddAttachmentModalContent.tsx       | 66 +++++++++++--------
 3 files changed, 41 insertions(+), 41 deletions(-)

diff --git a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
index e2bbcd3777aa..b3566746ae90 100644
--- a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
+++ b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
@@ -58,7 +58,6 @@ function AttachmentModalBaseContent({
     onConfirm,
     AttachmentContent,
     onCarouselAttachmentChange = () => {},
-    onValidateFile,
 }: AttachmentModalBaseContentProps) {
     const styles = useThemeStyles();
     const {shouldUseNarrowLayout} = useResponsiveLayout();
@@ -111,12 +110,8 @@ function AttachmentModalBaseContent({
             return;
         }
 
-        if (onValidateFile) {
-            onValidateFile?.(filesProp, setFile);
-        } else {
-            setFile(filesProp ?? fallbackFile);
-        }
-    }, [filesProp, fallbackFile, onValidateFile, setFile]);
+        setFile(filesProp ?? fallbackFile);
+    }, [filesProp, fallbackFile, setFile]);
 
     /**
      * Keeps the attachment source in sync with the attachment displayed currently in the carousel.
diff --git a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts
index 15d08df5ea1b..cbdd6f8b7882 100644
--- a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts
+++ b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types.ts
@@ -19,8 +19,6 @@ type AttachmentModalContentData = {
     file: FileObject | undefined;
 };
 
-type OnValidateFileCallback = (file: FileObject | FileObject[] | undefined, setFile: (file: FileObject | FileObject[] | undefined) => void) => void;
-
 type ThreeDotsMenuItemGeneratorProps = AttachmentModalContentData & {
     isLocalSource: boolean;
 };
@@ -115,9 +113,6 @@ type AttachmentModalBaseContentProps = {
 
     /** Optional callback to fire when we want to do something after attachment carousel changes. */
     onCarouselAttachmentChange?: (attachment: Attachment) => void;
-
-    /** Optional callback to fire when we want to validate the file. */
-    onValidateFile?: OnValidateFileCallback;
 };
 
-export type {AttachmentModalBaseContentProps, AttachmentModalOnCloseOptions, DownloadAttachmentCallback, AttachmentContent, AttachmentContentProps, OnValidateFileCallback};
+export type {AttachmentModalBaseContentProps, AttachmentModalOnCloseOptions, DownloadAttachmentCallback, AttachmentContent, AttachmentContentProps};
diff --git a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
index fab36b16755a..ce879e9a7005 100644
--- a/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
+++ b/src/pages/media/AttachmentModalScreen/routes/report/ReportAddAttachmentModalContent.tsx
@@ -11,7 +11,7 @@ import validateAttachmentFile from '@libs/AttachmentUtils';
 import type {AttachmentValidationResult} from '@libs/AttachmentUtils';
 import {isReportNotFound} from '@libs/ReportUtils';
 import tryResolveUrlFromApiRoot from '@libs/tryResolveUrlFromApiRoot';
-import type {AttachmentContentProps, AttachmentModalBaseContentProps, OnValidateFileCallback} from '@pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types';
+import type {AttachmentContentProps, AttachmentModalBaseContentProps} from '@pages/media/AttachmentModalScreen/AttachmentModalBaseContent/types';
 import AttachmentModalContainer from '@pages/media/AttachmentModalScreen/AttachmentModalContainer';
 import useDownloadAttachment from '@pages/media/AttachmentModalScreen/routes/hooks/useDownloadAttachment';
 import useNavigateToReportOnRefresh from '@pages/media/AttachmentModalScreen/routes/hooks/useNavigateToReportOnRefresh';
@@ -36,7 +36,7 @@ const convertFileToAttachment = (file: FileObject | undefined): Attachment => {
 function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScreenProps<typeof SCREENS.REPORT_ADD_ATTACHMENT>) {
     const {
         attachmentID,
-        file,
+        file: fileParam,
         source: sourceParam,
         isAuthTokenRequired,
         attachmentLink,
@@ -59,8 +59,6 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
         canBeMissing: false,
     });
 
-    useNavigateToReportOnRefresh({source: sourceParam, file, reportID});
-
     const [isLoadingApp] = useOnyx(ONYXKEYS.IS_LOADING_APP, {canBeMissing: true});
     const {isOffline} = useNetwork();
 
@@ -87,67 +85,80 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
 
     const [source, setSource] = useState(() => Number(sourceParam) || (typeof sourceParam === 'string' ? tryResolveUrlFromApiRoot(decodeURIComponent(sourceParam)) : undefined));
 
-    // Validates the attachment file and renders the appropriate modal type or errors
-    const onValidateFile: OnValidateFileCallback = useCallback((fileToValidate, setFile) => {
-        if (!fileToValidate) {
+    const [validFiles, setValidFiles] = useState<FileObject | FileObject[] | undefined>(fileParam);
+    useEffect(() => {
+        if (!fileParam) {
             return;
         }
 
-        function updateState(result: AttachmentValidationResult | undefined) {
-            if (!result?.isValid) {
+        function updateState(result: AttachmentValidationResult | AttachmentValidationResult[]) {
+            if (Array.isArray(result)) {
+                const validResults = result.filter((r) => r.isValid);
+                if (validResults.length === 0) {
+                    return;
+                }
+
+                const validatedFiles = validResults.map((r) => r.file);
+                const firstValidSource = validResults.at(0)?.source;
+
+                setSource(firstValidSource);
+                setValidFiles(validatedFiles);
+                return;
+            }
+
+            if (!result.isValid) {
                 return;
             }
 
             setSource(result.source);
-            setFile(result.file);
+            setValidFiles(result.file);
         }
 
-        if (Array.isArray(fileToValidate)) {
-            Promise.all(fileToValidate.map((f) => validateAttachmentFile(f))).then((results) => {
-                const firstValidResult = results.find((result) => result.isValid);
-                updateState(firstValidResult);
-            });
+        if (Array.isArray(fileParam)) {
+            Promise.all(fileParam.map((f) => validateAttachmentFile(f))).then(updateState);
             return;
         }
 
-        validateAttachmentFile(fileToValidate).then(updateState);
-    }, []);
+        validateAttachmentFile(fileParam).then(updateState);
+    }, [fileParam]);
 
-    const modalType = useReportAttachmentModalType(source, file);
+    const modalType = useReportAttachmentModalType(source, validFiles);
+    useNavigateToReportOnRefresh({source: sourceParam, file: validFiles, reportID});
 
     const isLoading = useMemo(() => {
         if (isOffline || isReportNotFound(report) || !reportID) {
             return false;
         }
         const isEmptyReport = isEmptyObject(report);
-        return !!isLoadingApp || isEmptyReport || (reportMetadata?.isLoadingInitialReportActions !== false && shouldFetchReport) || (Array.isArray(file) && file.length === 0);
-    }, [isOffline, report, reportID, isLoadingApp, reportMetadata?.isLoadingInitialReportActions, shouldFetchReport, file]);
+        return !!isLoadingApp || isEmptyReport || (reportMetadata?.isLoadingInitialReportActions !== false && shouldFetchReport) || (Array.isArray(validFiles) && validFiles.length === 0);
+    }, [isOffline, report, reportID, isLoadingApp, reportMetadata?.isLoadingInitialReportActions, shouldFetchReport, validFiles]);
 
     const onConfirm = useCallback(
         (f: FileObject | FileObject[]) => {
-            if (Array.isArray(file) && file.length > 0) {
-                onConfirmParam?.(file);
+            if (Array.isArray(validFiles) && validFiles.length > 0) {
+                onConfirmParam?.(validFiles);
             } else {
                 onConfirmParam?.(f);
             }
         },
-        [onConfirmParam, file],
+        [validFiles, onConfirmParam],
     );
 
     const onDownloadAttachment = useDownloadAttachment({
         isAuthTokenRequired,
     });
 
+    useNavigateToReportOnRefresh({source: sourceParam, file: validFiles, reportID});
+
     const contentProps = useMemo<AttachmentModalBaseContentProps>(() => {
-        if (file === undefined || (Array.isArray(file) && file.length === 0)) {
+        if (validFiles === undefined || (Array.isArray(validFiles) && validFiles.length === 0)) {
             return {
                 isLoading: true,
             };
         }
 
         return {
-            file,
-            onValidateFile,
+            file: validFiles,
             source,
             isLoading,
             isAuthTokenRequired,
@@ -163,8 +174,7 @@ function ReportAddAttachmentModalContent({route, navigation}: AttachmentModalScr
             AttachmentContent: AddAttachmentModalCarouselView,
         };
     }, [
-        file,
-        onValidateFile,
+        validFiles,
         source,
         isLoading,
         isAuthTokenRequired,

From 3080cd35be1fba56e4223c3a0bab88def2d0088c Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Wed, 24 Sep 2025 13:11:53 +0100
Subject: [PATCH 27/31] fix: allow pasting multiple files

---
 src/components/Composer/implementation/index.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/Composer/implementation/index.tsx b/src/components/Composer/implementation/index.tsx
index 1ddcb16d2251..dd51e5e3e394 100755
--- a/src/components/Composer/implementation/index.tsx
+++ b/src/components/Composer/implementation/index.tsx
@@ -163,7 +163,7 @@ function Composer(
             // If paste contains files, then trigger file management
             if (event.clipboardData?.files.length && event.clipboardData.files.length > 0) {
                 // Prevent the default so we do not post the file name into the text box
-                onPasteFile(event.clipboardData.files[0]);
+                onPasteFile(Array.from(event.clipboardData.files));
                 return true;
             }
 

From 376ae6dded55ef440d0bdf898bcfd6c4f0613b20 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Sun, 28 Sep 2025 20:04:31 +0100
Subject: [PATCH 28/31] refactor: rename onPasteFile prop

---
 .../ComposerWithSuggestions/ComposerWithSuggestions.tsx     | 6 +++---
 .../home/report/ReportActionCompose/ReportActionCompose.tsx | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/pages/home/report/ReportActionCompose/ComposerWithSuggestions/ComposerWithSuggestions.tsx b/src/pages/home/report/ReportActionCompose/ComposerWithSuggestions/ComposerWithSuggestions.tsx
index 06bf533431c5..50f39437bc1a 100644
--- a/src/pages/home/report/ReportActionCompose/ComposerWithSuggestions/ComposerWithSuggestions.tsx
+++ b/src/pages/home/report/ReportActionCompose/ComposerWithSuggestions/ComposerWithSuggestions.tsx
@@ -101,7 +101,7 @@ type ComposerWithSuggestionsProps = Partial<ChildrenProps> & {
     inputPlaceholder: string;
 
     /** Callback when a file is pasted */
-    onFilePasted: (file: FileObject | FileObject[]) => void;
+    onPasteFile: (file: FileObject | FileObject[]) => void;
 
     /** Whether the input is disabled, defaults to false */
     disabled?: boolean;
@@ -215,7 +215,7 @@ function ComposerWithSuggestions({
     setIsFullComposerAvailable,
     isMenuVisible,
     inputPlaceholder,
-    onFilePasted,
+    onPasteFile,
     disabled,
     setIsCommentEmpty,
     handleSendMessage,
@@ -811,7 +811,7 @@ function ComposerWithSuggestions({
                     onClick={setShouldBlockSuggestionCalcToFalse}
                     onPasteFile={(files) => {
                         textInputRef.current?.blur();
-                        onFilePasted(files);
+                        onPasteFile(files);
                     }}
                     onClear={onClear}
                     isDisabled={disabled}
diff --git a/src/pages/home/report/ReportActionCompose/ReportActionCompose.tsx b/src/pages/home/report/ReportActionCompose/ReportActionCompose.tsx
index cc83a8291c53..a5914db59787 100644
--- a/src/pages/home/report/ReportActionCompose/ReportActionCompose.tsx
+++ b/src/pages/home/report/ReportActionCompose/ReportActionCompose.tsx
@@ -579,7 +579,7 @@ function ReportActionCompose({
                             inputPlaceholder={inputPlaceholder}
                             isComposerFullSize={isComposerFullSize}
                             setIsFullComposerAvailable={setIsFullComposerAvailable}
-                            onFilePasted={(files) => validateAttachments({files})}
+                            onPasteFile={(files) => validateAttachments({files})}
                             onCleared={submitForm}
                             disabled={isBlockedFromConcierge}
                             setIsCommentEmpty={setIsCommentEmpty}

From 852b073db8fe9a1d9da098a53af8d6f27b22cadb Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Sun, 28 Sep 2025 20:13:53 +0100
Subject: [PATCH 29/31] fix: don't validate receipts by default

---
 .../report/ReportActionCompose/useAttachmentUploadValidation.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/pages/home/report/ReportActionCompose/useAttachmentUploadValidation.ts b/src/pages/home/report/ReportActionCompose/useAttachmentUploadValidation.ts
index 6f91f188aa1d..472114887b14 100644
--- a/src/pages/home/report/ReportActionCompose/useAttachmentUploadValidation.ts
+++ b/src/pages/home/report/ReportActionCompose/useAttachmentUploadValidation.ts
@@ -115,7 +115,7 @@ function useAttachmentUploadValidation({
         }
     };
 
-    const {validateFiles, PDFValidationComponent, ErrorModal} = useFilesValidation(onFilesValidated);
+    const {validateFiles, PDFValidationComponent, ErrorModal} = useFilesValidation(onFilesValidated, false);
 
     const validateAttachments = useCallback(
         ({dragEvent, files}: {dragEvent?: DragEvent; files?: FileObject | FileObject[]}) => {

From 80a2d46ed54dac4403abb752734ede842c46bcdc Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Tue, 7 Oct 2025 11:50:58 +0100
Subject: [PATCH 30/31] fix: add missing `isAttachmentLoaded` logic

---
 .../AttachmentModalBaseContent/index.tsx                   | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
index d6668a3c4330..41b2cadd277a 100644
--- a/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
+++ b/src/pages/media/AttachmentModalScreen/AttachmentModalBaseContent/index.tsx
@@ -1,4 +1,4 @@
-import React, {memo, useCallback, useEffect, useMemo, useState} from 'react';
+import React, {memo, useCallback, useContext, useEffect, useMemo, useState} from 'react';
 import {View} from 'react-native';
 import {GestureHandlerRootView} from 'react-native-gesture-handler';
 import Animated, {FadeIn, LayoutAnimationConfig, useSharedValue} from 'react-native-reanimated';
@@ -186,14 +186,15 @@ function AttachmentModalBaseContent({
         };
     }, [clearAttachmentErrors]);
 
+    const {isAttachmentLoaded} = useContext(AttachmentStateContext);
     const shouldShowDownloadButton = useMemo(() => {
         const isValidContext = !isEmptyObject(report) || type === CONST.ATTACHMENT_TYPE.SEARCH;
         if (!isValidContext || isErrorInAttachment(source)) {
             return false;
         }
 
-        return !!onDownloadAttachment && isDownloadButtonReadyToBeShown && !shouldShowNotFoundPage && !isOffline && !isLocalSource;
-    }, [isDownloadButtonReadyToBeShown, isErrorInAttachment, isLocalSource, isOffline, onDownloadAttachment, report, shouldShowNotFoundPage, source, type]);
+        return !!onDownloadAttachment && isDownloadButtonReadyToBeShown && !shouldShowNotFoundPage && !isOffline && !isLocalSource && isAttachmentLoaded?.(source);
+    }, [isAttachmentLoaded, isDownloadButtonReadyToBeShown, isErrorInAttachment, isLocalSource, isOffline, onDownloadAttachment, report, shouldShowNotFoundPage, source, type]);
 
     // We need to pass a shared value of type boolean to the context, so `falseSV` acts as a default value.
     const falseSV = useSharedValue(false);

From 605f6223b7825d056119a58342d879adb5579936 Mon Sep 17 00:00:00 2001
From: Christoph Pader <chris@margelo.com>
Date: Wed, 8 Oct 2025 21:35:24 +0100
Subject: [PATCH 31/31] refactor: prefer early return

---
 .../useAttachmentUploadValidation.ts          | 63 ++++++++++---------
 1 file changed, 32 insertions(+), 31 deletions(-)

diff --git a/src/pages/home/report/ReportActionCompose/useAttachmentUploadValidation.ts b/src/pages/home/report/ReportActionCompose/useAttachmentUploadValidation.ts
index 472114887b14..72ddb99fa2cf 100644
--- a/src/pages/home/report/ReportActionCompose/useAttachmentUploadValidation.ts
+++ b/src/pages/home/report/ReportActionCompose/useAttachmentUploadValidation.ts
@@ -81,38 +81,39 @@ function useAttachmentUploadValidation({
         if (shouldAddOrReplaceReceipt && transactionID) {
             const source = URL.createObjectURL(files.at(0) as Blob);
             replaceReceipt({transactionID, file: files.at(0) as File, source});
-        } else {
-            const initialTransaction = initMoneyRequest({
-                reportID,
-                newIouRequestType: CONST.IOU.REQUEST_TYPE.SCAN,
-                report,
-                parentReport: newParentReport,
-                currentDate,
-            });
-
-            files.forEach((file, index) => {
-                const source = URL.createObjectURL(file as Blob);
-                const newTransaction =
-                    index === 0
-                        ? (initialTransaction as Partial<OnyxTypes.Transaction>)
-                        : buildOptimisticTransactionAndCreateDraft({
-                              initialTransaction: initialTransaction as Partial<OnyxTypes.Transaction>,
-                              currentUserPersonalDetails,
-                              reportID,
-                          });
-                const newTransactionID = newTransaction?.transactionID ?? CONST.IOU.OPTIMISTIC_TRANSACTION_ID;
-                setMoneyRequestReceipt(newTransactionID, source, file.name ?? '', true);
-                setMoneyRequestParticipantsFromReport(newTransactionID, report);
-            });
-            Navigation.navigate(
-                ROUTES.MONEY_REQUEST_STEP_CONFIRMATION.getRoute(
-                    CONST.IOU.ACTION.CREATE,
-                    isSelfDM(report) ? CONST.IOU.TYPE.TRACK : CONST.IOU.TYPE.SUBMIT,
-                    CONST.IOU.OPTIMISTIC_TRANSACTION_ID,
-                    reportID,
-                ),
-            );
+            return;
         }
+
+        const initialTransaction = initMoneyRequest({
+            reportID,
+            newIouRequestType: CONST.IOU.REQUEST_TYPE.SCAN,
+            report,
+            parentReport: newParentReport,
+            currentDate,
+        });
+
+        files.forEach((file, index) => {
+            const source = URL.createObjectURL(file as Blob);
+            const newTransaction =
+                index === 0
+                    ? (initialTransaction as Partial<OnyxTypes.Transaction>)
+                    : buildOptimisticTransactionAndCreateDraft({
+                          initialTransaction: initialTransaction as Partial<OnyxTypes.Transaction>,
+                          currentUserPersonalDetails,
+                          reportID,
+                      });
+            const newTransactionID = newTransaction?.transactionID ?? CONST.IOU.OPTIMISTIC_TRANSACTION_ID;
+            setMoneyRequestReceipt(newTransactionID, source, file.name ?? '', true);
+            setMoneyRequestParticipantsFromReport(newTransactionID, report);
+        });
+        Navigation.navigate(
+            ROUTES.MONEY_REQUEST_STEP_CONFIRMATION.getRoute(
+                CONST.IOU.ACTION.CREATE,
+                isSelfDM(report) ? CONST.IOU.TYPE.TRACK : CONST.IOU.TYPE.SUBMIT,
+                CONST.IOU.OPTIMISTIC_TRANSACTION_ID,
+                reportID,
+            ),
+        );
     };
 
     const {validateFiles, PDFValidationComponent, ErrorModal} = useFilesValidation(onFilesValidated, false);