[$250] Link redirects to new.expensify.com when clicked

[m-natarajan]

If you haven’t already, check out our contributing guidelines for onboarding and email contributors@expensify.com to request to join our Slack channel!

---

Version Number: 9.3.74-0
Reproducible in staging?: Y
Reproducible in production?: Y
If this was caught during regression testing, add the test name, ID and link from BrowserStack:
Email or phone of affected tester (no customers):
Logs: https://stackoverflow.com/c/expensify/questions/4856
Expensify/Expensify Issue URL:
Issue reported by: @allgandalf
Slack conversation (hyperlinked to channel name): #Expensify Bugs

Action Performed:

1. Scanned Expense via smartscan
2. It was successful, then got the message from Concierge with link:
   FYI, I probably could have imported this receipt automatically. Would you be open to connecting your personal or company card? I support over 10,000 banks around the world, so I can probably connect to yours!
3. Tap on the link

Expected Result:

User redirected to the Wallet section

Actual Result:

User redirected to mWeb (New.expensify.com)

Workaround:

Unknown

Platforms:

Select the officially supported platforms where the issue was reproduced:

• Android: App
• Android: mWeb Chrome
• iOS: App
• iOS: mWeb Safari
• iOS: mWeb Chrome
• Windows: Chrome
• MacOS: Chrome / Safari

Screenshots/Videos

ScreenRecording_05-14-2026.16-40-58_1.MP4

View all open jobs on GitHub

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022055030583107071379
• Upwork Job ID: 2055030583107071379
• Last Price Increase: 2026-05-21

[MelvinBot]

Proposal

What is the root cause of that problem?

In BaseAnchorForCommentsOnly.tsx:56, linkHref is always set to href (for non-image links), regardless of whether onPress is defined for in-app navigation:

const linkHref = !linkHasImage ? href : undefined;

This linkHref is then passed as href={linkHref} to the inner Text component.

On native iOS, React Native's Text with href triggers Linking.openURL at the native level when tapped — opening Safari. This happens even though the outer PressableWithSecondaryInteraction (which renders as a Text in inline mode on native) has an onPress handler that would correctly call Navigation.navigate for in-app navigation. The native href handling preempts or races with the JS-level onPress.

The link detection itself works correctly — AnchorRenderer.tsx:38-54 correctly identifies new.expensify.com/settings/wallet as an internal path via getInternalNewExpensifyPath and sets onPress to call openLink → Navigation.navigate. The problem is that the inner Text's native href behavior opens the browser before (or alongside) the intended in-app navigation.

What changes do you think we should make in order to solve the problem?

In BaseAnchorForCommentsOnly.tsx:56, conditionally exclude linkHref when onPress is defined (meaning navigation is handled in JS):

const linkHref = !linkHasImage && !onPress ? href : undefined;

On native, onPress is always provided by AnchorForCommentsOnly/index.native.tsx, so the inner Text would never get a native href on mobile — taps are handled entirely by the JS onPress chain, which correctly distinguishes internal (in-app navigation) from external (explicit Linking.openURL) links.

On web, when onPress is set for internal links, the href is similarly unnecessary because the PressableWithSecondaryInteraction on web already calls event.preventDefault() before invoking onPress. For external links where onPress is undefined, linkHref would still be set, preserving the current <a> tag behavior (right-click, middle-click, etc.).

The tooltip text at line 88 also uses linkHref, so it would become undefined for internal links. This is acceptable since the tooltip primarily aids web hover — and for internal links the navigation behavior is more important than the tooltip.

What alternative solutions did you explore? (Optional)

An alternative is making the fix only in the native-specific index.native.tsx by passing href={onPress ? '' : href} to BaseAnchorForCommentsOnly. However, this loses the href value for native-side accessibility labeling and context menu display (accessibilityLabel={href} and selection: href at lines 84 and 68), so the shared-component approach is cleaner.

Investigation details

Full data flow:

1. Concierge message contains <a href="https://new.expensify.com/settings/wallet">connecting</a>
2. TextCommentFragment runs adjustExpensifyLinksForEnv (no-op in production)
3. AnchorRenderer calls getInternalNewExpensifyPath(href) → returns "settings/wallet" (truthy)
4. onLinkPress is set to () => openLink(href, environmentURL) and passed as onPress to AnchorForCommentsOnly
5. Native AnchorForCommentsOnly wraps it in onLinkPress and passes both onPress and href to BaseAnchorForCommentsOnly
6. BaseAnchorForCommentsOnly sets linkProps.onPress = onPress (line 50) but ALSO sets linkHref = href (line 56)
7. Inner Text gets href={linkHref} → native iOS opens Safari via Linking.openURL
8. The outer onPress (which would call Navigation.navigate("settings/wallet")) is preempted

Key files:

• AnchorRenderer.tsx — link detection and onPress setup
• AnchorForCommentsOnly/index.native.tsx — native wrapper
• BaseAnchorForCommentsOnly.tsx — shared component where the bug lives
• PressableWithSecondaryInteraction/index.native.tsx — renders as Text in inline mode on native

Possibly related issue: #85924 — "Deeplinks - OD Report link is opening in Chrome rather than the app" may share the same root cause.

---

Next Steps for Contributor+ team: Reply with @MelvinBot implement this to create a draft PR, @MelvinBot <your feedback> to refine this analysis, or explain why you are rejecting Melvin's proposal.

[yusufdeveloper2903]

Proposal

What is the root cause of that problem?

When a Concierge message link like https://new.expensify.com/settings/wallet is tapped, AnchorRenderer correctly classifies it as an internal route and routes the press to openLink(). But openLink() only navigates internally when the link's host also matches the running build's environmentURL:

App/src/libs/actions/Link.ts

Lines 204 to 213 in 92101fd

	if (internalNewExpensifyPath && hasSameOrigin) {
	if (isAnonymousUser() && !canAnonymousUserAccessRoute(internalNewExpensifyPath)) {
	signOutAndRedirectToSignIn();
	return;
	}
	if (shouldCloseRHP) {
	Navigation.closeRHPFlow();
	}
	Navigation.navigate(internalNewExpensifyPath as Route);
	return;

hasSameOrigin is Url.hasSameExpensifyOrigin(href, environmentURL) (Link.ts#L173-L174). On any build whose environmentURL isn't new.expensify.com (staging, adhoc, dev), a production new.expensify.com link fails this check, so openLink skips the Navigation.navigate(...) branch and falls through to openExternalLink(href) (Link.ts#L223) — opening mWeb instead of the in-app Wallet.

This guard is redundant and harmful: getInternalNewExpensifyPath() (Link.ts#L148-L156) has already authoritatively established the link is an internal NewDot route — it accepts the production, staging, and dev origins. Whether the link's host equals the current build's host says nothing about whether the path can be navigated internally; settings/wallet is a valid in-app route on every environment.

adjustExpensifyLinksForEnv() (EnvironmentContextProvider/index.tsx#L31-L62, added in e0196386a02) is a band-aid for exactly this: it rewrites the https://new.expensify.com host in chat HTML to the current env so hasSameOrigin passes. But it only runs for TextCommentFragment text, only matches the literal https://new.expensify.com prefix through a brittle String.replace of the raw markup, and is a no-op on production. Whenever that rewrite doesn't fire, openLink still wrongly bails to mWeb.

What changes do you think we should make in order to solve the problem?

Stop gating internal navigation on the running environment — getInternalNewExpensifyPath() is already the source of truth.

 function openLink(href: string, environmentURL: string, isAttachment = false) {
-    const hasSameOrigin = Url.hasSameExpensifyOrigin(href, environmentURL);
     const hasExpensifyOrigin = Url.hasSameExpensifyOrigin(href, CONFIG.EXPENSIFY.EXPENSIFY_URL) || Url.hasSameExpensifyOrigin(href, CONFIG.EXPENSIFY.STAGING_API_ROOT);

-    if (internalNewExpensifyPath && hasSameOrigin) {
+    if (internalNewExpensifyPath) {

With this, any link getInternalNewExpensifyPath() resolves to a path is navigated in-app via react-navigation regardless of which environment the build is running — so https://new.expensify.com/settings/wallet opens the Wallet section directly. The environmentURL param can stay in the signature (callers still pass it; args: after-used keeps lint happy) or be dropped in a follow-up cleanup. Other openLink callers that pass external URLs (Xero/Gusto/QBO setup links, CONST.PRICING) are unaffected — getInternalNewExpensifyPath returns '' for them, so they still fall through to openExternalLink.

What alternative solutions did you explore? (Optional)

• Harden adjustExpensifyLinksForEnv (parse/serialize the DOM instead of String.replace, apply it to every fragment type): still a band-aid — it keeps openLink's environment coupling and has to be perfect everywhere a link can render. Fixing the guard at the source makes the rewrite unnecessary for this path.
• Special-case /settings/wallet: doesn't generalize — the same break hits every internal Concierge link (More Features, Workspaces, etc.), which is the bug e0196386a02 already tried to patch.

[KJ21-ENG]

🚨 Edited by proposal-police: This proposal was edited at 2026-05-14 21:10:29 UTC.

Proposal

Please re-state the problem that we are trying to solve in this issue.

On iOS, tapping Concierge's https://new.expensify.com/settings/wallet link after a SmartScan receipt opens new.expensify.com in an external browser/mWeb instead of navigating inside the app to Settings > Wallet.

What is the root cause of that problem?

The Concierge message is rendered as a comment link. AnchorRenderer correctly detects https://new.expensify.com/settings/wallet as an internal NewDot path and passes an onPress handler that would call openLink(...) and navigate to the in-app route.

App/src/components/HTMLEngineProvider/HTMLRenderers/AnchorRenderer.tsx

Lines 36 to 54 in acf18a6

	const attrHref = htmlAttribs.href || htmlAttribs[CONST.ATTACHMENT_SOURCE_ATTRIBUTE] || '';
	const parentStyle = tnode.parent?.styles?.nativeTextRet ?? {};
	const internalNewExpensifyPath = getInternalNewExpensifyPath(attrHref);
	const internalExpensifyPath = getInternalExpensifyPath(attrHref);
	const isVideo = attrHref && Str.isVideo(attrHref);
	const linkHasImage = tnode.tagName === 'a' && tnode.children.some((child) => child.tagName === 'img');
	const isDeleted = HTMLEngineUtils.isDeletedNode(tnode);
	const isChildOfTaskTitle = HTMLEngineUtils.isChildOfTaskTitle(tnode);
	const textDecorationLineStyle = isDeleted ? styles.lineThrough : {};
	const onLinkPress = useMemo(() => {
	if (internalNewExpensifyPath || internalExpensifyPath) {
	return () => openLink(attrHref, environmentURL, isAttachment);
	}
	return undefined;
	}, [internalNewExpensifyPath, internalExpensifyPath, attrHref, environmentURL, isAttachment]);

On native, AnchorForCommentsOnly then always wraps that in its own onPress: internal links call the handler from AnchorRenderer, while external links fall back to Linking.openURL(href).

App/src/components/AnchorForCommentsOnly/index.native.tsx

Lines 6 to 20 in acf18a6

	function AnchorForCommentsOnly({onPress, href = '', ...props}: AnchorForCommentsOnlyProps) {
	const onLinkPress = () => {
	if (onPress) {
	onPress();
	} else {
	Linking.openURL(href);
	}
	};
	return (
	<BaseAnchorForCommentsOnly
	{...props}
	href={href}
	onPress={onLinkPress}
	/>

The problem is in the shared base anchor. Even when an onPress handler exists, it still passes the raw href into the inner Text component:

App/src/components/AnchorForCommentsOnly/BaseAnchorForCommentsOnly.tsx

Lines 48 to 100 in acf18a6

	const linkProps: LinkProps = {};
	if (onPress) {
	linkProps.onPress = onPress;
	} else {
	linkProps.href = href;
	}
	const defaultTextStyle = canUseTouchScreen() || shouldUseNarrowLayout ? {} : {...styles.userSelectText, ...styles.cursorPointer};
	const isEmail = Str.isValidEmail(href.replaceAll(/mailto:/gi, ''));
	const linkHref = !linkHasImage ? href : undefined;
	const isFocused = useIsFocused();
	return (
	<PressableWithSecondaryInteraction
	inline
	suppressHighlighting
	style={[styles.cursorDefault, !!flattenStyle.fontSize && StyleUtils.getFontSizeStyle(flattenStyle.fontSize)]}
	onSecondaryInteraction={(event) => {
	showContextMenu({
	type: isEmail ? CONST.CONTEXT_MENU_TYPES.EMAIL : CONST.CONTEXT_MENU_TYPES.LINK,
	event,
	selection: href,
	contextMenuAnchor: linkRef.current,
	});
	}}
	onPress={(event) => {
	if (!linkProps.onPress) {
	return;
	}
	event?.preventDefault();
	linkProps.onPress();
	}}
	onPressIn={onPressIn}
	onPressOut={onPressOut}
	role={CONST.ROLE.LINK}
	tabIndex={-1}
	accessibilityLabel={href}
	wrapperStyle={wrapperStyle}
	>
	<Tooltip
	text={linkHref}
	isFocused={isFocused}
	>
	<Text
	ref={linkRef}
	style={StyleSheet.flatten([style, defaultTextStyle])}
	role={CONST.ROLE.LINK}
	tabIndex={0}
	hrefAttrs={{
	rel,
	target: isEmail || !linkProps.href ? '_self' : target,
	}}
	href={linkHref}

That inner component spreads the href prop directly onto React Native's Text.

App/src/components/Text.tsx

Lines 72 to 80 in acf18a6

	return (
	<RNText
	allowFontScaling={false}
	ref={ref}
	style={componentStyle}
	// On Android, TalkBack reads style metadata (e.g. color codes) along with text content.
	// Setting accessibilityLabel explicitly causes TalkBack to read only the label, skipping style info.
	accessibilityLabel={typeof children === 'string' && !!children && Platform.OS === 'android' ? children : undefined}
	{...props}

On iOS, a native Text with href opens the URL through the platform URL handler. So the browser opens new.expensify.com before, or instead of, the JS press path that would call Navigation.navigate('settings/wallet').

This also explains why the bug reproduces in production. A production new.expensify.com/settings/wallet link should pass openLink()'s same-origin check, so removing that check alone does not address the production failure shown in the recordings. The JS in-app route is already available; the native href is bypassing it.

What changes do you think we should make in order to solve the problem?

Suppress the native Text href whenever the anchor already has a JS onPress handler.

A platform-aware version keeps web link affordances intact while preventing iOS from opening the browser:

const linkHref = !linkHasImage && (Platform.OS === 'web' || !onPress) ? href : undefined;

Then:

• Native internal links no longer give the inner Text a URL to open directly, so taps run the existing JS onPress path and navigate via openLink().
• Native external links still work because AnchorForCommentsOnly/index.native.tsx falls back to Linking.openURL(href) in its wrapper.
• Web can keep the current href behavior for browser affordances while the existing event.preventDefault() path continues to handle internal navigation.
• Attachment/image links stay unchanged because linkHasImage already suppresses the text href.

Add focused regression coverage for BaseAnchorForCommentsOnly / AnchorForCommentsOnly:

• on native with an onPress, assert the rendered inner Text does not receive href and pressing the link calls the JS handler;
• on native without an internal handler, assert the wrapper fallback still opens external links through Linking.openURL;
• on web, assert normal href behavior is preserved for links that rely on browser/link affordances.

What alternative solutions did you explore? (Optional)

I initially considered changing openLink() to remove the environmentURL same-origin guard. That is useful hardening for cross-environment NewDot links, but it does not explain the production repro because production new.expensify.com links already satisfy that origin check.

I also considered special-casing settings/wallet, but the failure is generic to comment anchors on iOS: any internal link can be opened externally if the nested native Text receives href while JS is supposed to own the press.

[melvin-bot]

Triggered auto assignment to Contributor-plus team member for initial proposal review - @dmkt9 (External)

[melvin-bot]

Job added to Upwork: https://www.upwork.com/jobs/~022055030583107071379

[neerajbachani]

Proposal

[KJ21-ENG]

Updated my proposal after reviewing the recordings: production also reproduces, so the fix moves from the environment-origin guard to suppressing the native Text href when JS owns the link press.

[emkhalid]

Proposal

What is the root cause of that problem?

In src/components/AnchorForCommentsOnly/BaseAnchorForCommentsOnly.tsx, the component decides whether a link should be handled by JS onPress or by a native/browser href.

App/src/components/AnchorForCommentsOnly/BaseAnchorForCommentsOnly.tsx

Lines 48 to 53 in 8c42be7

	const linkProps: LinkProps = {};
	if (onPress) {
	linkProps.onPress = onPress;
	} else {
	linkProps.href = href;
	}

But the inner Text still receives the raw href whenever the link is not an image, even when onPress exists and JS is supposed to own the press handling.

App/src/components/AnchorForCommentsOnly/BaseAnchorForCommentsOnly.tsx

Line 56 in 8c42be7

const linkHref = !linkHasImage ? href : undefined;

That linkHref is then passed to the inner Text.

App/src/components/AnchorForCommentsOnly/BaseAnchorForCommentsOnly.tsx

Line 100 in 8c42be7

href={linkHref}

For Concierge comment links, AnchorRenderer correctly detects https://new.expensify.com/settings/wallet as an internal New Expensify link and passes an onPress handler.

App/src/components/HTMLEngineProvider/HTMLRenderers/AnchorRenderer.tsx

Lines 48 to 54 in 8c42be7

	const onLinkPress = useMemo(() => {
	if (internalNewExpensifyPath || internalExpensifyPath) {
	return () => openLink(attrHref, environmentURL, isAttachment);
	}
	return undefined;
	}, [internalNewExpensifyPath, internalExpensifyPath, attrHref, environmentURL, isAttachment]);

On native, the Text component forwards props to React Native Text.

App/src/components/Text.tsx

Lines 72 to 80 in 8c42be7

	return (
	<RNText
	allowFontScaling={false}
	ref={ref}
	style={componentStyle}
	// On Android, TalkBack reads style metadata (e.g. color codes) along with text content.
	// Setting accessibilityLabel explicitly causes TalkBack to read only the label, skipping style info.
	accessibilityLabel={typeof children === 'string' && !!children && Platform.OS === 'android' ? children : undefined}
	{...props}

So on iOS/native, the inner Text still has a native href to open directly. This can open https://new.expensify.com/settings/wallet externally before or instead of the JS onPress path that would call openLink() and navigate in-app to settings/wallet.

What changes do you think we should make in order to solve the problem?

In src/components/AnchorForCommentsOnly/BaseAnchorForCommentsOnly.tsx, use the existing linkProps.href decision instead of the raw href when building linkHref.

App/src/components/AnchorForCommentsOnly/BaseAnchorForCommentsOnly.tsx

Lines 48 to 56 in 8c42be7

	const linkProps: LinkProps = {};
	if (onPress) {
	linkProps.onPress = onPress;
	} else {
	linkProps.href = href;
	}
	const defaultTextStyle = canUseTouchScreen() || shouldUseNarrowLayout ? {} : {...styles.userSelectText, ...styles.cursorPointer};
	const isEmail = Str.isValidEmail(href.replaceAll(/mailto:/gi, ''));
	const linkHref = !linkHasImage ? href : undefined;

diff --git a/src/components/AnchorForCommentsOnly/BaseAnchorForCommentsOnly.tsx b/src/components/AnchorForCommentsOnly/BaseAnchorForCommentsOnly.tsx
@@
-    const linkHref = !linkHasImage ? href : undefined;
+    const linkHref = !linkHasImage ? linkProps.href : undefined;

This keeps the component's existing source of truth:

• If onPress exists, linkProps.onPress is set and linkProps.href remains undefined, so the inner Text does not receive a native href.
• If no onPress exists, linkProps.href is set to href, so normal native/browser link handling is preserved.
• Image links remain unchanged because linkHasImage still suppresses href.

This fixes the issue because internal Concierge links no longer give the nested native Text a URL to open directly. The press is handled by the existing JS path, which calls openLink() and navigates to the internal Wallet route.

What alternative solutions did you explore? (Optional)

I considered changing linkHref to check onPress directly, for example:

-    const linkHref = !linkHasImage ? href : undefined;
+    const linkHref = !linkHasImage && !onPress ? href : undefined;

That also works, but it duplicates the same decision already represented by linkProps. Using linkProps.href is smaller and keeps the code aligned with the component's existing link-handling logic.

I also considered removing the hasSameOrigin guard in openLink().

App/src/libs/actions/Link.ts

Lines 173 to 204 in 8c42be7

	function openLink(href: string, environmentURL: string, isAttachment = false) {
	const hasSameOrigin = Url.hasSameExpensifyOrigin(href, environmentURL);
	const hasExpensifyOrigin = Url.hasSameExpensifyOrigin(href, CONFIG.EXPENSIFY.EXPENSIFY_URL) || Url.hasSameExpensifyOrigin(href, CONFIG.EXPENSIFY.STAGING_API_ROOT);
	const internalNewExpensifyPath = getInternalNewExpensifyPath(href);
	const internalExpensifyPath = getInternalExpensifyPath(href);
	const isNarrowLayout = getIsNarrowLayout();
	const currentState = navigationRef.getRootState();
	const isRHPOpen = currentState?.routes?.at(-1)?.name === NAVIGATORS.RIGHT_MODAL_NAVIGATOR;
	let shouldCloseRHP = false;
	if (!isNarrowLayout && isRHPOpen) {
	shouldCloseRHP = !willRouteNavigateToRHP(internalNewExpensifyPath as Route);
	}
	// There can be messages from Concierge with links to specific NewDot reports. Those URLs look like this:
	// https://www.expensify.com.dev/newdotreport?reportID=3429600449838908 and they have a target="_blank" attribute. This is so that when a user is on OldDot,
	// clicking on the link will open the chat in NewDot. However, when a user is in NewDot and clicks on the concierge link, the link needs to be handled differently.
	// Normally, the link would be sent to Link.openOldDotLink() and opened in a new tab, and that's jarring to the user. Since the intention is to link to a specific NewDot chat,
	// the reportID is extracted from the URL and then opened as an internal link, taking the user straight to the chat in the same tab.
	if (hasExpensifyOrigin && href.indexOf('newdotreport?reportID=') > -1) {
	const reportID = href.split('newdotreport?reportID=').pop();
	const reportRoute = ROUTES.REPORT_WITH_ID.getRoute(reportID);
	if (shouldCloseRHP) {
	Navigation.closeRHPFlow();
	}
	Navigation.navigate(reportRoute);
	return;
	}
	// If we are handling a New Expensify link then we will assume this should be opened by the app internally. This ensures that the links are opened internally via react-navigation
	// instead of in a new tab or with a page refresh (which is the default behavior of an anchor tag)
	if (internalNewExpensifyPath && hasSameOrigin) {

That would harden cross-environment New Expensify links, but it does not explain the production repro because production https://new.expensify.com/settings/wallet already satisfies that origin check. The actual production bug is caused by the native Text receiving href while JS onPress should handle the internal navigation.

[Abdulloh0109]

Proposal

Please re-state the problem that we are trying to solve in this issue.
After a SmartScan, Concierge sends a chat message containing https://new.expensify.com/settings/wallet. Tapping that link on iOS should open the in-app Wallet screen. Instead, it opens new.expensify.com in the system browser (Safari / mWeb). Reproducible in both production and staging.

What is the root cause of that problem?
There are two separate layers:

Primary (causes the production repro on iOS)

In BaseAnchorForCommentsOnly.tsx:56:

const linkHref = !linkHasImage ? href : undefined;
linkHref is always set to the full URL for non-image links, regardless of whether a JS onPress handler is also present. This value is then spread onto the inner at line 100.

On iOS, React Native's Text component natively opens URLs when given an href prop — this fires at the native level, before (and regardless of) the JS press handler.

Full data flow:

AnchorRenderer.tsx:38–54 — getInternalNewExpensifyPath("https://new.expensify.com/settings/wallet") returns "settings/wallet", so onLinkPress = () => openLink(...) is set and passed as onPress.
index.native.tsx:6–13 — onLinkPress wraps it and passes onPress to BaseAnchorForCommentsOnly. On native, onPress is always non-null.
BaseAnchorForCommentsOnly.tsx:49–53 — since onPress is set, linkProps.href is correctly left unset.
BaseAnchorForCommentsOnly.tsx:56 — but linkHref = href is still set unconditionally.
BaseAnchorForCommentsOnly.tsx:100 — → iOS native URL handler fires, opening Safari, bypassing the JS onPress chain entirely.
Secondary (staging/dev environments only)

In Link.ts:203:

if (internalNewExpensifyPath && hasSameOrigin) {
hasSameOrigin compares the link's host against environmentURL (the current build's URL). On staging, environmentURL differs from new.expensify.com, so even if JS onPress fires, openLink skips Navigation.navigate and falls through to openExternalLink. In production, hasSameOrigin is true, so this layer isn't the production-repro cause — that's the native Text href issue above.

What changes do you think we should make in order to solve the problem?
Change 1 — Suppress native Text href when JS owns the press (BaseAnchorForCommentsOnly.tsx:56):

// Before
const linkHref = !linkHasImage ? href : undefined;

// After
const linkHref = !linkHasImage && (Platform.OS === 'web' || !onPress) ? href : undefined;
Native: linkHref is undefined whenever onPress is set — the inner Text gets no href, so iOS doesn't invoke its native URL handler. Since index.native.tsx always injects onPress, this covers all native link taps. External links remain unbroken: the index.native.tsx wrapper falls back to Linking.openURL(href) when the original onPress is absent.
Web: linkHref is always preserved, keeping browser affordances — tooltip showing the URL, right-click "Copy Link Address", middle-click open in new tab.
Platform is already imported from react-native in the file.
Change 2 (optional, for staging/dev consistency) — Remove the redundant hasSameOrigin guard (Link.ts:203):

// Before
if (internalNewExpensifyPath && hasSameOrigin) {

// After
if (internalNewExpensifyPath) {
getInternalNewExpensifyPath already checks the origin against production, staging, and dev new.expensify.com hosts — the hasSameOrigin guard is redundant and causes staging/adhoc builds to treat internal links as external.

What alternative solutions did you explore? (Optional)
MelvinBot's simpler change — const linkHref = !linkHasImage && !onPress ? href : undefined; (no Platform check). Fixes native, but also removes href from internal links on web, breaking the tooltip and right-click "Copy Link Address" affordances that are currently working and useful.

Remove only the hasSameOrigin guard in openLink (yusufdeveloper2903's proposal). This doesn't address the production repro: in production hasSameOrigin is already true, so the navigation code is reached — but the native iOS Text href fires before JS gets to call openLink at all.

Harden adjustExpensifyLinksForEnv (rewrite link hosts to the current environment before rendering). An indirect band-aid — it still leaves the native Text href race condition in place and only partially covers link sources that run the rewrite.