Merge branch 'main' into docs-tag-gl-code-column-92692

Author: stephanieelliott

.claude/settings.json

@@ -6,7 +6,7 @@
                 "hooks": [
                     {
                         "type": "command",
-                        "command": "FILE=$(jq -r '.tool_input.file_path') && [ -f \"$FILE\" ] && ./node_modules/.bin/prettier --experimental-cli --no-cache --write --ignore-unknown \"$FILE\""
+                        "command": "FILE=$(jq -r '.tool_input.file_path') && [ -f \"$FILE\" ] && ./node_modules/.bin/oxfmt --write --no-error-on-unmatched-pattern \"$FILE\""
                     }
                 ]
             }

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

@@ -35,6 +35,8 @@ Coding standards for the Expensify App. Each standard is a standalone file in `r
 - [PERF-14](rules/perf-14-use-sync-external-store.md) — Use useSyncExternalStore
 - [PERF-15](rules/perf-15-cleanup-async-effects.md) — Clean up async Effects
 - [PERF-16](rules/perf-16-guard-double-init.md) — Guard double initialization
+- [PERF-17](rules/perf-17-pass-raw-index-on-demand.md) — Pass raw source, index on demand (no pre-built digest)
+- [PERF-18](rules/perf-18-use-pre-mount-destination.md) — Use usePreMountDestination for RHP pre-mounting
 
 ### Consistency
 - [CONSISTENCY-1](rules/consistency-1-no-platform-checks.md) — No platform-specific checks in components
@@ -48,6 +50,9 @@ Coding standards for the Expensify App. Each standard is a standalone file in `r
 - [CONSISTENCY-9](rules/consistency-9-file-naming.md) — Name files after what they export
 - [CONSISTENCY-10](rules/consistency-10-jsdoc.md) — Follow the JSDoc style guidelines
 - [CONSISTENCY-11](rules/consistency-11-no-todo-comments.md) — Track future work in an issue, not a TODO comment
+- [CONSISTENCY-12](rules/consistency-12-callback-named-for-action.md) — Name callbacks for what they do, not the event they handle
+- [CONSISTENCY-13](rules/consistency-13-document-props.md) — Document component props with a JSDoc block comment
+- [CONSISTENCY-14](rules/consistency-14-new-file-header.md) — Non-trivial new files start with a header description
 
 ### Clean React Patterns
 - [CLEAN-REACT-PATTERNS-0](rules/clean-react-0-compiler.md) — React Compiler compliance

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

@@ -7,7 +7,7 @@ title: 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`.
+React Compiler is enabled in this codebase (`babel-plugin-react-compiler` runs first in both Rspack 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:
 

.claude/skills/coding-standards/rules/clean-react-1-composition-over-config.md

@@ -213,7 +213,6 @@ function Section({title, renderSubtitle, renderTitle, overlayContent}: SectionPr
 
 ```tsx
 <Table data={items} columns={columns}>
-  <Table.SearchBar />
   <Table.Header />
   <Table.Body />
 </Table>

.claude/skills/coding-standards/rules/consistency-12-callback-named-for-action.md

@@ -0,0 +1,51 @@
+---
+ruleId: CONSISTENCY-12
+title: Name callbacks for what they do, not the event they handle
+---
+
+## [CONSISTENCY-12] Name callbacks for what they do, not the event they handle
+
+### Reasoning
+
+Per `contributingGuides/STYLE.md`, a callback method should be named for the action it performs, not for the event slot it happens to be wired to. `toggleReport` tells the reader what happens; `onIconClick` only tells you where it was attached and has to be re-read to learn what it does. Naming by behavior keeps handlers reusable across triggers and searchable by intent. The `on*` / `handle*` naming belongs on the JSX prop, not on the function definition.
+
+### Incorrect
+
+```tsx
+function ReportHeader() {
+    const onIconClick = () => Report.toggleReport(reportID);
+    const handleButtonPress = () => Navigation.dismissModal();
+
+    return <Icon onPress={onIconClick} />;
+}
+```
+
+### Correct
+
+```tsx
+function ReportHeader() {
+    const toggleReport = () => Report.toggleReport(reportID);
+    const dismissModal = () => Navigation.dismissModal();
+
+    return <Icon onPress={toggleReport} />;
+}
+```
+
+---
+
+### Review Metadata
+
+Flag ONLY when ALL of these are true:
+
+- The changed code **declares** a function (function declaration or arrow/function assigned to a `const`/`let`) whose name matches `^(on|handle)[A-Z]` and describes the triggering event (e.g. `onIconClick`, `handleButtonPress`, `onRowClick`)
+- The name refers to the event slot rather than the action performed, and a behavior-based name (`toggleReport`, `dismissModal`) would be clearer
+
+**DO NOT flag if:**
+
+- The `on*` / `handle*` name appears only as a JSX prop assignment or call site (e.g. `onPress={toggleReport}`) rather than as the function's own declaration
+- The function genuinely represents a named event in an event system or implements an external API/interface that dictates the name (e.g. a required `onSuccess` callback prop, `onLayout`, DOM event handler contracts)
+- The handler is a prop being passed through/forwarded rather than defined here
+- The file is a test or story
+
+**Search Patterns** (hints for reviewers):
+- `const on[A-Z]` / `const handle[A-Z]` / `function on[A-Z]` / `function handle[A-Z]`

.claude/skills/coding-standards/rules/consistency-13-document-props.md

@@ -0,0 +1,51 @@
+---
+ruleId: CONSISTENCY-13
+title: Document component props with a JSDoc block comment
+---
+
+## [CONSISTENCY-13] Document component props with a JSDoc block comment
+
+### Reasoning
+
+Per `contributingGuides/STYLE.md`, every component prop is documented with a `/** ... */` block comment above it so its purpose is clear at the definition site. This rule enforces the *presence* of that documentation when a new props type is added with no documented props at all. It is the companion to CONSISTENCY-10, which enforces JSDoc *style* and catches the mixed cases (a `//` comment on a prop, or an undocumented prop sitting next to documented siblings). Together they ensure every prop carries a `/** */` block.
+
+### Incorrect
+
+```tsx
+type ButtonProps = {
+    isDisabled: boolean;
+    onPress: () => void;
+};
+```
+
+### Correct
+
+```tsx
+type ButtonProps = {
+    /** Whether the button is disabled */
+    isDisabled: boolean;
+
+    /** Called when the button is pressed */
+    onPress: () => void;
+};
+```
+
+---
+
+### Review Metadata
+
+Flag ONLY when ALL of these are true:
+
+- The changed code adds (or newly introduces the members of) a component props type/interface - a `type`/`interface` whose name ends in `Props`
+- It declares one or more of its own props
+- **None** of those props has a `/** ... */` block comment above it
+
+**DO NOT flag if:**
+
+- At least one prop in the type is already documented with `/** */` (the mixed/undocumented-sibling and `//`-comment cases belong to CONSISTENCY-10, not here - avoid double-flagging)
+- The type only re-exports, extends, intersects, or spreads props from a base type documented elsewhere and declares no new members of its own
+- The props are inherited from a shared base type
+- The file is a test or story
+
+**Search Patterns** (hints for reviewers):
+- Added `type ...Props = {` / `interface ...Props {` blocks whose members have no preceding `/** */`

.claude/skills/coding-standards/rules/consistency-14-new-file-header.md

@@ -0,0 +1,55 @@
+---
+ruleId: CONSISTENCY-14
+title: Non-trivial new files start with a header description
+---
+
+## [CONSISTENCY-14] Non-trivial new files start with a header description
+
+### Reasoning
+
+When a new file is added it should carry a short description of what it does and/or why it is needed at the top, unless the code is self explanatory. A one-line header comment on a new module, component, hook, or util orients the next reader immediately instead of forcing them to reverse-engineer the file's purpose from its exports.
+
+### Incorrect
+
+A new `src/libs/CardUtils/deriveLimit.ts` that opens straight into code:
+
+```tsx
+import type {Card} from '@src/types/onyx';
+
+function deriveLimit(card: Card): number {
+    // ...
+}
+```
+
+### Correct
+
+```tsx
+/**
+ * Helpers for deriving a card's spend limit from its Onyx data.
+ */
+import type {Card} from '@src/types/onyx';
+
+function deriveLimit(card: Card): number {
+    // ...
+}
+```
+
+---
+
+### Review Metadata
+
+Flag ONLY when ALL of these are true:
+
+- The change **adds a new file** (not a modification of an existing one) under `src/**`
+- The file contains non-trivial logic (more than a few lines; not a pure re-export or a single constant)
+- Its first non-import, non-directive token is not a comment - there is no header comment describing the file
+
+**DO NOT flag if:**
+
+- The file is a barrel / `index.*` re-export file, a platform-suffixed variant (`.ios`/`.android`/`.native`/`.web`) of a file documented in its base variant, or a type-only declaration file
+- The file is short and self explanatory (e.g. a tiny constant, a one-line util whose name says everything)
+- The file is a test, story, snapshot, or generated/config file
+- A header comment is already present
+
+**Search Patterns** (hints for reviewers):
+- Newly added files under `src/**` whose first line is `import`/`export` with no leading `/** */` or `//` header

.claude/skills/coding-standards/rules/perf-17-pass-raw-index-on-demand.md

@@ -0,0 +1,91 @@
+---
+ruleId: PERF-17
+title: Avoid intermediate lookup layers
+---
+
+## [PERF-17] Avoid intermediate lookup layers
+
+### Reasoning
+
+Building a derived lookup structure (`new Set`/`new Map`/`Object.fromEntries` or a hand-built index) from a collection you already hold - just to answer membership/per-element checks downstream - is O(n) construction, often re-run every render, for something the callee can index O(1) straight from the raw source. Pass the raw collection and do the lookup on demand inside the callee instead.
+
+### Examples
+
+#### Incorrect
+
+```tsx
+// Archived reports in last-accessed navigation (ReportRouteParamHandler.tsx)
+// Builds an intermediate lookup layer from the full collection on every render.
+const archivedReportsIDSet = useArchivedReportsIDSet();
+
+useFocusEffect(
+    useCallback(() => {
+        const report = findLastAccessedReport(ignoreDomainRooms, isOpenOnAdminRoom, undefined, archivedReportsIDSet);
+    }, [archivedReportsIDSet, ignoreDomainRooms, isOpenOnAdminRoom]),
+);
+```
+
+#### Correct
+
+```tsx
+// Pass raw collection and index on demand inside the callee.
+const [reportNameValuePairs] = useOnyx(ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS);
+
+useFocusEffect(
+    useCallback(() => {
+        const report = findLastAccessedReport(ignoreDomainRooms, isOpenOnAdminRoom, undefined, reportNameValuePairs);
+    }, [reportNameValuePairs, ignoreDomainRooms, isOpenOnAdminRoom]),
+);
+
+// inside findLastAccessedReport:
+const reportNVP = reportNameValuePairs?.[`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${reportID}`];
+const isArchived = isArchivedReport(reportNVP);
+```
+
+#### Incorrect
+
+```tsx
+// Distance rates membership in workspace settings (PolicyDistanceRatesPage.tsx)
+const selectableRates = useMemo(() => buildSelectableRates(customUnitRates), [customUnitRates]);
+
+// Unnecessary intermediate lookup layer from data already keyed by ID.
+const rateIDs = useMemo(() => new Set(Object.keys(selectableRates)), [selectableRates]);
+
+const isSelectable = rateIDs.has(transaction?.comment?.customUnit?.customUnitRateID);
+```
+
+#### Correct
+
+```tsx
+const selectableRates = useMemo(() => buildSelectableRates(customUnitRates), [customUnitRates]);
+
+const rateID = transaction?.comment?.customUnit?.customUnitRateID;
+const isSelectable = !!rateID && !!selectableRates[rateID];
+```
+
+---
+
+### Review Metadata
+
+**Flag when ALL of these are true:**
+
+- A derived lookup structure (`new Set`/`new Map`/`Object.fromEntries`, or a hand-built index object) is constructed from a collection/array the code already holds.
+- It is built eagerly - at component scope or on every render (e.g. a hook or `useMemo` over the whole collection) - rather than behind the branch that needs it.
+- Its only purpose is membership/lookup checks answerable O(1) directly against the raw source, i.e. the raw source is already keyed (object / `Map` / Onyx collection).
+
+Increase confidence (not required):
+
+- The callee runs conditionally/lazily (for example, inside a `useCallback`/event handler, `useFocusEffect`, or a `useState(() => ...)` initializer), so the intermediate lookup layer is rebuilt on every render even when the callee and lookup never run.
+
+**DO NOT flag if:**
+
+- Genuine repeated querying against the intermediate lookup layer is confirmed (for example, `.has(...)` inside a loop or multiple distinct lookup sites). If that evidence is not visible in the diff, confirm it by searching the callee or changed file.
+- The raw source isn't already available to the callee and would otherwise need its own expensive fetch.
+- The structure meaningfully reshapes data (not just a membership/lookup index) and the callee needs the whole thing.
+- The raw source is an array: a `Set`/`Map` that turns O(n) `.includes`/scan membership into O(1) `.has` is a real precompute win, not a violation.
+
+**Search Patterns** (hints for reviewers):
+- `new Set\(`
+- `new Map\(`
+- `Object\.fromEntries`
+- `\.has\(`