Merge branch 'main' into collectioneur/transition-tracker-v2

Author: collectioneur

.claude/skills/coding-standards/SKILL.md

@@ -44,6 +44,7 @@ Coding standards for the Expensify App. Each standard is a standalone file in `r
 - [CONSISTENCY-6](rules/consistency-6-proper-error-handling.md) — Proper error handling
 
 ### Clean React Patterns
+- [CLEAN-REACT-PATTERNS-0](rules/clean-react-0-compiler.md) — React Compiler compliance
 - [CLEAN-REACT-PATTERNS-1](rules/clean-react-1-composition-over-config.md) — Composition over configuration
 - [CLEAN-REACT-PATTERNS-2](rules/clean-react-2-own-behavior.md) — Components own their behavior
 - [CLEAN-REACT-PATTERNS-3](rules/clean-react-3-context-free-contracts.md) — Context-free component contracts

.claude/skills/coding-standards/rules/clean-react-0-compiler.md

@@ -0,0 +1,127 @@
+---
+ruleId: CLEAN-REACT-PATTERNS-0
+title: React Compiler compliance
+---
+
+## [CLEAN-REACT-PATTERNS-0] React Compiler compliance
+
+### Reasoning
+
+React Compiler is enabled in this codebase (`babel-plugin-react-compiler` runs first in both webpack and metro configs). It automatically memoizes components and hooks at the AST level — analyzing data flow, tracking dependencies, and inserting fine-grained caching that is more precise than any hand-written `useMemo`, `useCallback`, or `React.memo`.
+
+Manual memoization is therefore:
+
+1. **Redundant** — the compiler already handles it, so the manual wrapper adds zero value
+2. **Harmful** — it interferes with the compiler's optimization model, potentially preventing it from applying its own caching strategy or causing double-wrapping
+3. **Noisy** — it clutters the codebase with dependency arrays that must be maintained, reviewed, and debugged
+
+The codebase enforces this via:
+- **Babel plugin**: `babel-plugin-react-compiler` in `babel.config.js`
+- **ESLint processor**: `eslint-plugin-react-compiler-compat` suppresses redundant lint rules when files compile successfully
+- **CI compliance check**: `scripts/react-compiler-compliance-check.ts` blocks PRs with manual memoization in new files
+
+Reference: [React Compiler documentation](https://react.dev/learn/react-compiler)
+
+### Incorrect
+
+#### Incorrect (useCallback)
+
+```tsx
+function ReportScreen({reportID}: {reportID: string}) {
+    const handlePress = useCallback(() => {
+        Navigation.navigate(ROUTES.REPORT_DETAILS.getRoute(reportID));
+    }, [reportID]);
+
+    return <Button onPress={handlePress} />;
+}
+```
+
+#### Incorrect (useMemo)
+
+```tsx
+function PolicyList({policies}: {policies: Policy[]}) {
+    const sortedPolicies = useMemo(
+        () => policies.sort((a, b) => a.name.localeCompare(b.name)),
+        [policies],
+    );
+
+    return <FlatList data={sortedPolicies} renderItem={renderItem} />;
+}
+```
+
+#### Incorrect (React.memo)
+
+```tsx
+const Avatar = React.memo(function Avatar({source, size}: AvatarProps) {
+    return <Image source={source} style={getAvatarStyle(size)} />;
+});
+```
+
+### Correct
+
+#### Correct (plain function — compiler memoizes automatically)
+
+```tsx
+function ReportScreen({reportID}: {reportID: string}) {
+    const handlePress = () => {
+        Navigation.navigate(ROUTES.REPORT_DETAILS.getRoute(reportID));
+    };
+
+    return <Button onPress={handlePress} />;
+}
+```
+
+#### Correct (plain expression — compiler memoizes automatically)
+
+```tsx
+function PolicyList({policies}: {policies: Policy[]}) {
+    const sortedPolicies = policies.sort((a, b) => a.name.localeCompare(b.name));
+
+    return <FlatList data={sortedPolicies} renderItem={renderItem} />;
+}
+```
+
+#### Correct (plain component — compiler memoizes automatically)
+
+```tsx
+function Avatar({source, size}: AvatarProps) {
+    return <Image source={source} style={getAvatarStyle(size)} />;
+}
+```
+
+---
+
+### Review Metadata
+
+#### Verification
+
+Before flagging, verify that the file actually compiles with React Compiler:
+
+```bash
+npx react-compiler-healthcheck --src "<filepath>" --verbose
+```
+
+If the output contains **"Failed to compile"** for the file under review, the rule **does not apply** — the author may have no alternative to manual memoization until the compilation issue is resolved.
+
+#### Condition
+
+The verification step above is a prerequisite. Only flag when the file compiles successfully AND any of these are true in new or modified code:
+
+1. **`useCallback`** — A function is wrapped in `useCallback`. The compiler automatically memoizes closures based on their captured variables.
+2. **`useMemo`** — A value is wrapped in `useMemo`. The compiler automatically caches derived values.
+3. **`React.memo`** — A component is wrapped in `React.memo` (or `memo` imported from React). The compiler automatically skips re-rendering components whose props haven't changed.
+
+**Response:** Challenge the author: "React Compiler is enabled — remove the manual memoization and restructure the code so the compiler can handle it."
+
+The goal is to fix the root cause (make code compiler-friendly) rather than slap on manual memoization as a workaround.
+
+**Search Patterns:**
+- `useCallback\s*\(` — manual callback memoization
+- `useMemo\s*\(` — manual value memoization
+- `React\.memo\s*\(` or `memo\s*\(` — manual component memoization
+- Import statements: `useCallback`, `useMemo` from `react`
+
+**DO NOT flag if:**
+- The file does not compile with React Compiler (verified by the compliance check in the Verification section above)
+- The code is inside `node_modules/`, `patches/`, or test fixtures
+- The manual memoization exists in unchanged lines (pre-existing code not touched by the diff)

.github/ISSUE_TEMPLATE/OnboardOffboardExpertContributor.md

@@ -34,4 +34,6 @@ Which action do you wish to take for this team member (select one):
 ### Ring0 Tasks
 
 - [ ] If adding, add to the appropriate GitHub child team of [external-expert-contributors](https://github.com/orgs/Expensify/teams/external-expert-contributors/teams) (each agency must have its own child team)
+- [ ] If adding, create an [IdentityDot account](https://stackoverflowteams.com/c/expensify/questions/22914) for the contributor
 - [ ] If removing, remove from our organization [here](https://github.com/orgs/Expensify/people)
+- [ ] If removing, delete the contributor's [IdentityDot account](https://stackoverflowteams.com/c/expensify/questions/22914)

.github/actions/javascript/getPullRequestIncrementalChanges/getPullRequestIncrementalChanges.ts

@@ -1,5 +1,6 @@
 import * as core from '@actions/core';
 import {context} from '@actions/github';
+import {RequestError} from '@octokit/request-error';
 import type {PullRequestEvent, PullRequestSynchronizeEvent} from '@octokit/webhooks-types';
 import {getJSONInput} from '@github/libs/ActionUtils';
 import CONST from '@github/libs/CONST';
@@ -89,7 +90,29 @@ async function run(): Promise<void> {
 
         // Now we know there are local changes - get PR diff from the GitHub API to compare
         console.log(`🌐 Using GitHub API to validate ${localChangedFiles.size} files with local changes`);
-        const prDiff = Git.parseDiff(await GitHubUtils.getPullRequestDiff(prNumber));
+
+        let prDiffString: string;
+        try {
+            prDiffString = await GitHubUtils.getPullRequestDiff(prNumber);
+        } catch (error) {
+            const isTooLarge =
+                error instanceof RequestError &&
+                typeof error.response?.data === 'object' &&
+                error.response.data !== null &&
+                'errors' in error.response.data &&
+                ((error.response.data as {errors?: Array<{code?: string}>}).errors ?? []).some((e) => e.code === 'too_large');
+
+            if (!isTooLarge) {
+                throw error;
+            }
+
+            core.warning(`PR #${prNumber} diff is too large for the GitHub API. Skipping incremental change detection.`);
+            core.setOutput('CHANGED_FILES', JSON.stringify([]));
+            core.setOutput('HAS_CHANGES', false);
+            return;
+        }
+
+        const prDiff = Git.parseDiff(prDiffString);
 
         // Compare the local push diff with the PR diff and collect changed files, checking for overlapping content changes at the line level
         for (const prFileDiff of prDiff.files) {

.github/actions/javascript/getPullRequestIncrementalChanges/index.js

@@ -11582,6 +11582,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const core = __importStar(__nccwpck_require__(2186));
 const github_1 = __nccwpck_require__(5438);
+const request_error_1 = __nccwpck_require__(537);
 const ActionUtils_1 = __nccwpck_require__(6981);
 const CONST_1 = __importDefault(__nccwpck_require__(9873));
 const GithubUtils_1 = __importDefault(__nccwpck_require__(9296));
@@ -11655,7 +11656,25 @@ async function run() {
         }
         // Now we know there are local changes - get PR diff from the GitHub API to compare
         console.log(`🌐 Using GitHub API to validate ${localChangedFiles.size} files with local changes`);
-        const prDiff = Git_1.default.parseDiff(await GithubUtils_1.default.getPullRequestDiff(prNumber));
+        let prDiffString;
+        try {
+            prDiffString = await GithubUtils_1.default.getPullRequestDiff(prNumber);
+        }
+        catch (error) {
+            const isTooLarge = error instanceof request_error_1.RequestError &&
+                typeof error.response?.data === 'object' &&
+                error.response.data !== null &&
+                'errors' in error.response.data &&
+                (error.response.data.errors ?? []).some((e) => e.code === 'too_large');
+            if (!isTooLarge) {
+                throw error;
+            }
+            core.warning(`PR #${prNumber} diff is too large for the GitHub API. Skipping incremental change detection.`);
+            core.setOutput('CHANGED_FILES', JSON.stringify([]));
+            core.setOutput('HAS_CHANGES', false);
+            return;
+        }
+        const prDiff = Git_1.default.parseDiff(prDiffString);
         // Compare the local push diff with the PR diff and collect changed files, checking for overlapping content changes at the line level
         for (const prFileDiff of prDiff.files) {
             const filePath = prFileDiff.filePath;
@@ -12506,6 +12525,7 @@ class Git {
                         newStart,
                         newCount,
                         lines: [],
+                        contextLineCount: 0,
                     };
                 }
                 continue;
@@ -12533,7 +12553,8 @@ class Git {
                     });
                 }
                 else if (firstChar === ' ') {
-                    // Context line - skip it (we only care about added/removed lines)
+                    // Context line - count it so calculateLineNumber accounts for position advancement
+                    currentHunk.contextLineCount++;
                     continue;
                 }
                 else if (firstChar === '\\') {
@@ -12597,9 +12618,9 @@ class Git {
         const removedCount = hunk.lines.filter((l) => l.type === 'removed').length;
         switch (lineType) {
             case 'added':
-                return hunk.newStart + addedCount;
+                return hunk.newStart + hunk.contextLineCount + addedCount;
             case 'removed':
-                return hunk.oldStart + removedCount;
+                return hunk.oldStart + hunk.contextLineCount + removedCount;
             default:
                 throw new Error(`Unknown line type: ${String(lineType)}`);
         }
@@ -12795,6 +12816,7 @@ class Git {
                 newStart: 1,
                 newCount: lines.length,
                 lines: diffLines,
+                contextLineCount: 0,
             };
             const fileDiff = {
                 filePath,

.github/actions/javascript/reviewerChecklist/index.js

@@ -11622,15 +11622,13 @@ function checkIssueForCompletedChecklist(numberOfChecklistItems) {
     })
         .then(() => {
         console.log(`Looking through all ${combinedComments.length} comments for the reviewer checklist...`);
+        const maxCompletedItems = numberOfChecklistItems + 2;
+        const minCompletedItems = numberOfChecklistItems - 2;
         let foundReviewerChecklist = false;
         let numberOfFinishedChecklistItems = 0;
         let numberOfUnfinishedChecklistItems = 0;
         // Once we've gathered all the data, loop through each comment and look to see if it contains the reviewer checklist
         for (let i = 0; i < combinedComments.length; i++) {
-            // Skip all other comments if we already found the reviewer checklist
-            if (foundReviewerChecklist) {
-                break;
-            }
             const whitespace = /([\n\r])/gm;
             const comment = combinedComments.at(i)?.replaceAll(whitespace, '');
             console.log(`Comment ${i} starts with: ${comment?.slice(0, 20)}...`);
@@ -11640,14 +11638,16 @@ function checkIssueForCompletedChecklist(numberOfChecklistItems) {
                 foundReviewerChecklist = true;
                 numberOfFinishedChecklistItems = (comment?.match(/- \[x\]/gi) ?? []).length;
                 numberOfUnfinishedChecklistItems = (comment?.match(/- \[ \]/g) ?? []).length;
+                if (numberOfFinishedChecklistItems >= minCompletedItems && numberOfFinishedChecklistItems <= maxCompletedItems && numberOfUnfinishedChecklistItems === 0) {
+                    console.log('PR Reviewer checklist is complete 🎉');
+                    return;
+                }
             }
         }
         if (!foundReviewerChecklist) {
             core.setFailed('No PR Reviewer Checklist was found');
             return;
         }
-        const maxCompletedItems = numberOfChecklistItems + 2;
-        const minCompletedItems = numberOfChecklistItems - 2;
         console.log(`You completed ${numberOfFinishedChecklistItems} out of ${numberOfChecklistItems} checklist items with ${numberOfUnfinishedChecklistItems} unfinished items`);
         if (numberOfFinishedChecklistItems >= minCompletedItems && numberOfFinishedChecklistItems <= maxCompletedItems && numberOfUnfinishedChecklistItems === 0) {
             console.log('PR Reviewer checklist is complete 🎉');

.github/actions/javascript/reviewerChecklist/reviewerChecklist.ts

@@ -43,17 +43,14 @@ function checkIssueForCompletedChecklist(numberOfChecklistItems: number) {
         })
         .then(() => {
             console.log(`Looking through all ${combinedComments.length} comments for the reviewer checklist...`);
+            const maxCompletedItems = numberOfChecklistItems + 2;
+            const minCompletedItems = numberOfChecklistItems - 2;
             let foundReviewerChecklist = false;
             let numberOfFinishedChecklistItems = 0;
             let numberOfUnfinishedChecklistItems = 0;
 
             // Once we've gathered all the data, loop through each comment and look to see if it contains the reviewer checklist
             for (let i = 0; i < combinedComments.length; i++) {
-                // Skip all other comments if we already found the reviewer checklist
-                if (foundReviewerChecklist) {
-                    break;
-                }
-
                 const whitespace = /([\n\r])/gm;
                 const comment = combinedComments.at(i)?.replaceAll(whitespace, '');
 
@@ -65,6 +62,11 @@ function checkIssueForCompletedChecklist(numberOfChecklistItems: number) {
                     foundReviewerChecklist = true;
                     numberOfFinishedChecklistItems = (comment?.match(/- \[x\]/gi) ?? []).length;
                     numberOfUnfinishedChecklistItems = (comment?.match(/- \[ \]/g) ?? []).length;
+
+                    if (numberOfFinishedChecklistItems >= minCompletedItems && numberOfFinishedChecklistItems <= maxCompletedItems && numberOfUnfinishedChecklistItems === 0) {
+                        console.log('PR Reviewer checklist is complete 🎉');
+                        return;
+                    }
                 }
             }
 
@@ -73,9 +75,6 @@ function checkIssueForCompletedChecklist(numberOfChecklistItems: number) {
                 return;
             }
 
-            const maxCompletedItems = numberOfChecklistItems + 2;
-            const minCompletedItems = numberOfChecklistItems - 2;
-
             console.log(`You completed ${numberOfFinishedChecklistItems} out of ${numberOfChecklistItems} checklist items with ${numberOfUnfinishedChecklistItems} unfinished items`);
 
             if (numberOfFinishedChecklistItems >= minCompletedItems && numberOfFinishedChecklistItems <= maxCompletedItems && numberOfUnfinishedChecklistItems === 0) {