diff --git a/packages/react/src/reactrouter-compat-utils/index.ts b/packages/react/src/reactrouter-compat-utils/index.ts
index c2b56ec446fb..bb91ba8d3072 100644
--- a/packages/react/src/reactrouter-compat-utils/index.ts
+++ b/packages/react/src/reactrouter-compat-utils/index.ts
@@ -25,6 +25,7 @@ export {
   pathEndsWithWildcard,
   pathIsWildcardAndHasChildren,
   getNumberOfUrlSegments,
+  transactionNameHasWildcard,
 } from './utils';
 
 // Lazy route exports
diff --git a/packages/react/src/reactrouter-compat-utils/instrumentation.tsx b/packages/react/src/reactrouter-compat-utils/instrumentation.tsx
index a6e55f1a967c..cb87d8394764 100644
--- a/packages/react/src/reactrouter-compat-utils/instrumentation.tsx
+++ b/packages/react/src/reactrouter-compat-utils/instrumentation.tsx
@@ -41,7 +41,7 @@ import type {
   UseRoutes,
 } from '../types';
 import { checkRouteForAsyncHandler } from './lazy-routes';
-import { initializeRouterUtils, resolveRouteNameAndSource } from './utils';
+import { initializeRouterUtils, resolveRouteNameAndSource, transactionNameHasWildcard } from './utils';
 
 let _useEffect: UseEffect;
 let _useLocation: UseLocation;
@@ -52,6 +52,9 @@ let _enableAsyncRouteHandlers: boolean = false;
 
 const CLIENTS_WITH_INSTRUMENT_NAVIGATION = new WeakSet<Client>();
 
+// Maximum time (ms) to wait for lazy routes (configured in setup(), default: idleTimeout * 3)
+let _maxLazyRouteWaitMs = 3000;
+
 /**
  * Adds resolved routes as children to the parent route.
  * Prevents duplicate routes by checking if they already exist.
@@ -94,6 +97,15 @@ export interface ReactRouterOptions {
    * @default false
    */
   enableAsyncRouteHandlers?: boolean;
+
+  /**
+   * Maximum time (in milliseconds) to wait for lazy routes to load before finalizing span names.
+   *
+   * Defaults to 3× the configured `idleTimeout`. Set to `0` to not wait at all.
+   *
+   * Default: idleTimeout * 3
+   */
+  maxLazyRouteWaitMs?: number;
 }
 
 type V6CompatibleVersion = '6' | '7';
@@ -102,6 +114,27 @@ type V6CompatibleVersion = '6' | '7';
 // only exported for testing purposes
 export const allRoutes = new Set<RouteObject>();
 
+/** Tracks pending lazy route loads per span to wait before finalizing span names. */
+const pendingLazyRouteLoads = new WeakMap<Span, Set<Promise<unknown>>>();
+
+/** Registers a pending lazy route load promise for a span. */
+function trackLazyRouteLoad(span: Span, promise: Promise<unknown>): void {
+  let promises = pendingLazyRouteLoads.get(span);
+  if (!promises) {
+    promises = new Set();
+    pendingLazyRouteLoads.set(span, promises);
+  }
+  promises.add(promise);
+
+  // Clean up when promise resolves/rejects
+  promise.finally(() => {
+    const currentPromises = pendingLazyRouteLoads.get(span);
+    if (currentPromises) {
+      currentPromises.delete(promise);
+    }
+  });
+}
+
 /**
  * Processes resolved routes by adding them to allRoutes and checking for nested async handlers.
  */
@@ -166,12 +199,18 @@ export function updateNavigationSpan(
   forceUpdate = false,
   matchRoutes: MatchRoutes,
 ): void {
-  // Check if this span has already been named to avoid multiple updates
-  // But allow updates if this is a forced update (e.g., when lazy routes are loaded)
-  const hasBeenNamed =
-    !forceUpdate && (activeRootSpan as { __sentry_navigation_name_set__?: boolean })?.__sentry_navigation_name_set__;
+  const spanJson = spanToJSON(activeRootSpan);
+  const currentName = spanJson.description;
 
-  if (!hasBeenNamed) {
+  // Check if this span has already been named to avoid multiple updates
+  // But allow updates if:
+  // 1. This is a forced update (e.g., when lazy routes are loaded)
+  // 2. The current name has wildcards (incomplete parameterization)
+  const hasBeenNamed = (activeRootSpan as { __sentry_navigation_name_set__?: boolean })?.__sentry_navigation_name_set__;
+  const currentNameHasWildcard = currentName && transactionNameHasWildcard(currentName);
+  const shouldUpdate = forceUpdate || !hasBeenNamed || currentNameHasWildcard;
+
+  if (shouldUpdate && !spanJson.timestamp) {
     // Get fresh branches for the current location with all loaded routes
     const currentBranches = matchRoutes(allRoutes, location);
     const [name, source] = resolveRouteNameAndSource(
@@ -182,18 +221,27 @@ export function updateNavigationSpan(
       '',
     );
 
-    // Only update if we have a valid name and the span hasn't finished
-    const spanJson = spanToJSON(activeRootSpan);
-    if (name && !spanJson.timestamp) {
+    // Only update if we have a valid name and it's better than what we have
+    // Never downgrade from route source to url source
+    const currentSource = spanJson.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];
+    const isImprovement =
+      name &&
+      (!hasBeenNamed || // Span not finalized - accept any name
+        !currentName || // No current name - always set
+        (currentNameHasWildcard && source === 'route') || // Wildcard route → better route (MUST stay in route source)
+        (currentSource !== 'route' && source === 'route')); // URL → route upgrade
+    if (isImprovement) {
       activeRootSpan.updateName(name);
       activeRootSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, source);
 
-      // Mark this span as having its name set to prevent future updates
-      addNonEnumerableProperty(
-        activeRootSpan as { __sentry_navigation_name_set__?: boolean },
-        '__sentry_navigation_name_set__',
-        true,
-      );
+      // Only mark as finalized if the new name doesn't have wildcards
+      if (!transactionNameHasWildcard(name)) {
+        addNonEnumerableProperty(
+          activeRootSpan as { __sentry_navigation_name_set__?: boolean },
+          '__sentry_navigation_name_set__',
+          true,
+        );
+      }
     }
   }
 }
@@ -453,6 +501,7 @@ export function createReactRouterV6CompatibleTracingIntegration(
     enableAsyncRouteHandlers = false,
     instrumentPageLoad = true,
     instrumentNavigation = true,
+    maxLazyRouteWaitMs,
   } = options;
 
   return {
@@ -460,6 +509,31 @@ export function createReactRouterV6CompatibleTracingIntegration(
     setup(client) {
       integration.setup(client);
 
+      // Get idleTimeout from browserTracingIntegration options (passed through)
+      // idleTimeout from browserTracingIntegration (default: 1000ms)
+      // Note: options already contains idleTimeout if user passed it to browserTracingIntegration
+      // Calculate default: 3× idleTimeout, allow explicit override
+      const defaultMaxWait = (options.idleTimeout ?? 1000) * 3;
+      const configuredMaxWait = maxLazyRouteWaitMs ?? defaultMaxWait;
+
+      // Validate and set
+      if (Number.isNaN(configuredMaxWait)) {
+        DEBUG_BUILD &&
+          debug.warn('[React Router] maxLazyRouteWaitMs must be a number, falling back to default:', defaultMaxWait);
+        _maxLazyRouteWaitMs = defaultMaxWait;
+      } else if (configuredMaxWait < 0 && configuredMaxWait !== Infinity) {
+        DEBUG_BUILD &&
+          debug.warn(
+            '[React Router] maxLazyRouteWaitMs must be non-negative or Infinity, got:',
+            configuredMaxWait,
+            'falling back to:',
+            defaultMaxWait,
+          );
+        _maxLazyRouteWaitMs = defaultMaxWait;
+      } else {
+        _maxLazyRouteWaitMs = configuredMaxWait;
+      }
+
       _useEffect = useEffect;
       _useLocation = useLocation;
       _useNavigationType = useNavigationType;
@@ -568,6 +642,8 @@ function wrapPatchRoutesOnNavigation(
       // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
       const targetPath = (args as any)?.path;
 
+      const activeRootSpan = getActiveRootSpan();
+
       // For browser router, wrap the patch function to update span during patching
       if (!isMemoryRouter) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
@@ -576,10 +652,10 @@ function wrapPatchRoutesOnNavigation(
           // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
           (args as any).patch = (routeId: string, children: RouteObject[]) => {
             addRoutesToAllRoutes(children);
-            const activeRootSpan = getActiveRootSpan();
-            if (activeRootSpan && (spanToJSON(activeRootSpan) as { op?: string }).op === 'navigation') {
+            const currentActiveRootSpan = getActiveRootSpan();
+            if (currentActiveRootSpan && (spanToJSON(currentActiveRootSpan) as { op?: string }).op === 'navigation') {
               updateNavigationSpan(
-                activeRootSpan,
+                currentActiveRootSpan,
                 { pathname: targetPath, search: '', hash: '', state: null, key: 'default' },
                 Array.from(allRoutes),
                 true, // forceUpdate = true since we're loading lazy routes
@@ -591,33 +667,43 @@ function wrapPatchRoutesOnNavigation(
         }
       }
 
-      const result = await originalPatchRoutes(args);
+      // Create and track promise for this lazy load
+      const lazyLoadPromise = (async () => {
+        const result = await originalPatchRoutes(args);
+
+        // Update navigation span after routes are patched
+        const currentActiveRootSpan = getActiveRootSpan();
+        if (currentActiveRootSpan && (spanToJSON(currentActiveRootSpan) as { op?: string }).op === 'navigation') {
+          // Determine pathname based on router type
+          let pathname: string | undefined;
+          if (isMemoryRouter) {
+            // For memory routers, only use targetPath
+            pathname = targetPath;
+          } else {
+            // For browser routers, use targetPath or fall back to window.location
+            pathname = targetPath || WINDOW.location?.pathname;
+          }
 
-      // Update navigation span after routes are patched
-      const activeRootSpan = getActiveRootSpan();
-      if (activeRootSpan && (spanToJSON(activeRootSpan) as { op?: string }).op === 'navigation') {
-        // Determine pathname based on router type
-        let pathname: string | undefined;
-        if (isMemoryRouter) {
-          // For memory routers, only use targetPath
-          pathname = targetPath;
-        } else {
-          // For browser routers, use targetPath or fall back to window.location
-          pathname = targetPath || WINDOW.location?.pathname;
+          if (pathname) {
+            updateNavigationSpan(
+              currentActiveRootSpan,
+              { pathname, search: '', hash: '', state: null, key: 'default' },
+              Array.from(allRoutes),
+              false, // forceUpdate = false since this is after lazy routes are loaded
+              _matchRoutes,
+            );
+          }
         }
 
-        if (pathname) {
-          updateNavigationSpan(
-            activeRootSpan,
-            { pathname, search: '', hash: '', state: null, key: 'default' },
-            Array.from(allRoutes),
-            false, // forceUpdate = false since this is after lazy routes are loaded
-            _matchRoutes,
-          );
-        }
+        return result;
+      })();
+
+      // Track the promise if we have an active span
+      if (activeRootSpan) {
+        trackLazyRouteLoad(activeRootSpan, lazyLoadPromise);
       }
 
-      return result;
+      return lazyLoadPromise;
     },
   };
 }
@@ -658,9 +744,20 @@ export function handleNavigation(opts: {
     const activeSpan = getActiveSpan();
     const spanJson = activeSpan && spanToJSON(activeSpan);
     const isAlreadyInNavigationSpan = spanJson?.op === 'navigation';
+    const currentName = spanJson?.description;
 
-    // Cross usage can result in multiple navigation spans being created without this check
-    if (!isAlreadyInNavigationSpan) {
+    // If we're already in a navigation span, check if we should update its name
+    if (isAlreadyInNavigationSpan && activeSpan) {
+      // Only update if the new name is better (doesn't have wildcards or is more complete)
+      const shouldUpdate = currentName && transactionNameHasWildcard(currentName) && !transactionNameHasWildcard(name);
+
+      if (shouldUpdate) {
+        activeSpan.updateName(name);
+        activeSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, source as 'route' | 'url' | 'custom');
+        DEBUG_BUILD && debug.log(`[Tracing] Updated navigation span name from "${currentName}" to "${name}"`);
+      }
+    } else if (!isAlreadyInNavigationSpan) {
+      // Cross usage can result in multiple navigation spans being created without this check
       const navigationSpan = startBrowserTracingNavigationSpan(client, {
         name,
         attributes: {
@@ -741,6 +838,58 @@ function updatePageloadTransaction({
   }
 }
 
+/** Updates span name before end using latest route information. */
+function tryUpdateSpanNameBeforeEnd(
+  span: Span,
+  spanJson: ReturnType<typeof spanToJSON>,
+  currentName: string | undefined,
+  location: Location,
+  routes: RouteObject[],
+  basename: string | undefined,
+  spanType: 'pageload' | 'navigation',
+  allRoutes: Set<RouteObject>,
+): void {
+  try {
+    const currentSource = spanJson.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];
+    const hasWildcard = currentName && transactionNameHasWildcard(currentName);
+
+    // Only attempt update if source is not 'route' or if the name has wildcards
+    if (currentSource === 'route' && !hasWildcard) {
+      return;
+    }
+
+    const currentAllRoutes = Array.from(allRoutes);
+    const routesToUse = currentAllRoutes.length > 0 ? currentAllRoutes : routes;
+    const branches = _matchRoutes(routesToUse, location, basename) as unknown as RouteMatch[];
+
+    if (!branches) {
+      return;
+    }
+
+    const [name, source] = resolveRouteNameAndSource(location, routesToUse, routesToUse, branches, basename);
+
+    // Only update if we have a valid name and it's better than current
+    // Upgrade conditions:
+    // 1. No current name exists
+    // 2. Current name has wildcards and new source is also 'route' (never downgrade route→url)
+    // 3. Upgrading from non-route source to route source (e.g., URL -> parameterized route)
+    const isImprovement =
+      name &&
+      (!currentName || // No current name - always set
+        (hasWildcard && source === 'route') || // Wildcard route → better route (MUST stay in route source)
+        (currentSource !== 'route' && source === 'route')); // URL → route upgrade
+    const spanNotEnded = spanType === 'pageload' || !spanJson.timestamp;
+
+    if (isImprovement && spanNotEnded) {
+      span.updateName(name);
+      span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, source);
+    }
+  } catch (error) {
+    // Silently catch errors to ensure span.end() is always called
+    DEBUG_BUILD && debug.warn(`Error updating span details before ending: ${error}`);
+  }
+}
+
 /**
  * Patches the span.end() method to update the transaction name one last time before the span is sent.
  * This handles cases where the span is cancelled early (e.g., document.hidden) before lazy routes have finished loading.
@@ -762,42 +911,73 @@ function patchSpanEnd(
 
   const originalEnd = span.end.bind(span);
 
+  let endCalled = false;
+
   span.end = function patchedEnd(...args) {
-    try {
-      // Only update if the span source is not already 'route' (i.e., it hasn't been parameterized yet)
-      const spanJson = spanToJSON(span);
-      const currentSource = spanJson.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];
-      if (currentSource !== 'route') {
-        // Last chance to update the transaction name with the latest route info
-        // Use the live global allRoutes Set to include any lazy routes loaded after patching
-        const currentAllRoutes = Array.from(allRoutes);
-        const branches = _matchRoutes(
-          currentAllRoutes.length > 0 ? currentAllRoutes : routes,
+    // Prevent multiple calls to end()
+    if (endCalled) {
+      return;
+    }
+    endCalled = true;
+
+    const spanJson = spanToJSON(span);
+    const currentName = spanJson.description;
+
+    // If we have pending lazy route loads and the current name has wildcards,
+    // wait for promises to resolve (with timeout) before finalizing span
+    const pendingPromises = pendingLazyRouteLoads.get(span);
+    if (pendingPromises && pendingPromises.size > 0 && currentName && transactionNameHasWildcard(currentName)) {
+      // Special case: 0 means don't wait at all (legacy behavior)
+      if (_maxLazyRouteWaitMs === 0) {
+        // Don't wait - immediately update and end span
+        tryUpdateSpanNameBeforeEnd(
+          span,
+          spanToJSON(span),
+          spanToJSON(span).description,
           location,
+          routes,
           basename,
-        ) as unknown as RouteMatch[];
+          spanType,
+          allRoutes,
+        );
+        return originalEnd(...args);
+      }
 
-        if (branches) {
-          const [name, source] = resolveRouteNameAndSource(
+      // Take snapshot of current promises to wait for (prevents race conditions with new navigations)
+      const promiseArray = Array.from(pendingPromises);
+
+      // Wait for all lazy routes to settle (never rejects, safe for all outcomes)
+      const allSettled = Promise.allSettled(promiseArray).then(() => {});
+
+      // Race against timeout or wait indefinitely if Infinity
+      const waitPromise =
+        _maxLazyRouteWaitMs === Infinity
+          ? allSettled
+          : Promise.race([allSettled, new Promise<void>(r => setTimeout(r, _maxLazyRouteWaitMs))]);
+
+      // Update span name once routes are resolved or timeout expires
+      waitPromise
+        .then(() => {
+          tryUpdateSpanNameBeforeEnd(
+            span,
+            spanToJSON(span),
+            spanToJSON(span).description,
             location,
             routes,
-            currentAllRoutes.length > 0 ? currentAllRoutes : routes,
-            branches,
             basename,
+            spanType,
+            allRoutes,
           );
-
-          // Only update if we have a valid name
-          if (name && (spanType === 'pageload' || !spanJson.timestamp)) {
-            span.updateName(name);
-            span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, source);
-          }
-        }
-      }
-    } catch (error) {
-      // Silently catch errors to ensure span.end() is always called
-      DEBUG_BUILD && debug.warn(`Error updating span details before ending: ${error}`);
+          originalEnd(...args);
+        })
+        .catch(() => {
+          // Defensive: should never happen with allSettled, but satisfy ESLint
+          originalEnd(...args);
+        });
+      return;
     }
 
+    tryUpdateSpanNameBeforeEnd(span, spanJson, currentName, location, routes, basename, spanType, allRoutes);
     return originalEnd(...args);
   };
 
diff --git a/packages/react/src/reactrouter-compat-utils/utils.ts b/packages/react/src/reactrouter-compat-utils/utils.ts
index d6501d0e4dbf..9de0cfe88d38 100644
--- a/packages/react/src/reactrouter-compat-utils/utils.ts
+++ b/packages/react/src/reactrouter-compat-utils/utils.ts
@@ -38,6 +38,11 @@ export function pathEndsWithWildcard(path: string): boolean {
   return path.endsWith('*');
 }
 
+/** Checks if transaction name has wildcard (/* or * or ends with *). */
+export function transactionNameHasWildcard(name: string): boolean {
+  return name.includes('/*') || name === '*' || name.endsWith('*');
+}
+
 /**
  * Checks if a path is a wildcard and has child routes.
  */
diff --git a/packages/react/test/reactrouter-compat-utils/instrumentation.test.tsx b/packages/react/test/reactrouter-compat-utils/instrumentation.test.tsx
index bad264d3d6b5..c1626637daee 100644
--- a/packages/react/test/reactrouter-compat-utils/instrumentation.test.tsx
+++ b/packages/react/test/reactrouter-compat-utils/instrumentation.test.tsx
@@ -2,7 +2,7 @@
  * @vitest-environment jsdom
  */
 import type { Client, Span } from '@sentry/core';
-import { addNonEnumerableProperty } from '@sentry/core';
+import { addNonEnumerableProperty, spanToJSON } from '@sentry/core';
 import * as React from 'react';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import {
@@ -11,6 +11,7 @@ import {
   updateNavigationSpan,
 } from '../../src/reactrouter-compat-utils';
 import { addRoutesToAllRoutes, allRoutes } from '../../src/reactrouter-compat-utils/instrumentation';
+import { resolveRouteNameAndSource, transactionNameHasWildcard } from '../../src/reactrouter-compat-utils/utils';
 import type { Location, RouteObject } from '../../src/types';
 
 const mockUpdateName = vi.fn();
@@ -49,6 +50,9 @@ vi.mock('../../src/reactrouter-compat-utils/utils', () => ({
   getGlobalLocation: vi.fn(() => ({ pathname: '/test', search: '', hash: '' })),
   getGlobalPathname: vi.fn(() => '/test'),
   routeIsDescendant: vi.fn(() => false),
+  transactionNameHasWildcard: vi.fn((name: string) => {
+    return name.includes('/*') || name === '*' || name.endsWith('*');
+  }),
 }));
 
 vi.mock('../../src/reactrouter-compat-utils/lazy-routes', () => ({
@@ -370,3 +374,255 @@ describe('addRoutesToAllRoutes', () => {
     expect(firstCount).toBe(secondCount);
   });
 });
+
+describe('updateNavigationSpan with wildcard detection', () => {
+  const sampleLocation: Location = {
+    pathname: '/test',
+    search: '',
+    hash: '',
+    state: null,
+    key: 'default',
+  };
+
+  const sampleRoutes: RouteObject[] = [
+    { path: '/', element: <div>Home</div> },
+    { path: '/about', element: <div>About</div> },
+  ];
+
+  const mockMatchRoutes = vi.fn(() => []);
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should call updateName when provided with valid routes', () => {
+    const testSpan = { ...mockSpan };
+    updateNavigationSpan(testSpan, sampleLocation, sampleRoutes, false, mockMatchRoutes);
+
+    expect(mockUpdateName).toHaveBeenCalledWith('Test Route');
+    expect(mockSetAttribute).toHaveBeenCalledWith('sentry.source', 'route');
+  });
+
+  it('should handle forced updates', () => {
+    const testSpan = { ...mockSpan, __sentry_navigation_name_set__: true };
+    updateNavigationSpan(testSpan, sampleLocation, sampleRoutes, true, mockMatchRoutes);
+
+    // Should update even though already named because forceUpdate=true
+    expect(mockUpdateName).toHaveBeenCalledWith('Test Route');
+  });
+});
+
+describe('tryUpdateSpanNameBeforeEnd - source upgrade logic', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should upgrade from URL source to route source (regression fix)', async () => {
+    // Setup: Current span has URL source and non-parameterized name
+    vi.mocked(spanToJSON).mockReturnValue({
+      op: 'navigation',
+      description: '/users/123',
+      data: { 'sentry.source': 'url' },
+    } as any);
+
+    // Target: Resolves to route source with parameterized name
+    vi.mocked(resolveRouteNameAndSource).mockReturnValue(['/users/:id', 'route']);
+
+    const mockUpdateName = vi.fn();
+    const mockSetAttribute = vi.fn();
+    const testSpan = {
+      updateName: mockUpdateName,
+      setAttribute: mockSetAttribute,
+      end: vi.fn(),
+    } as unknown as Span;
+
+    // Simulate patchSpanEnd calling tryUpdateSpanNameBeforeEnd
+    // by updating the span name during a navigation
+    updateNavigationSpan(
+      testSpan,
+      { pathname: '/users/123', search: '', hash: '', state: null, key: 'test' },
+      [{ path: '/users/:id', element: <div /> }],
+      false,
+      vi.fn(() => [{ route: { path: '/users/:id' } }]),
+    );
+
+    // Should upgrade from URL to route source
+    expect(mockUpdateName).toHaveBeenCalledWith('/users/:id');
+    expect(mockSetAttribute).toHaveBeenCalledWith('sentry.source', 'route');
+  });
+
+  it('should not downgrade from route source to URL source', async () => {
+    // Setup: Current span has route source with parameterized name (no wildcard)
+    vi.mocked(spanToJSON).mockReturnValue({
+      op: 'navigation',
+      description: '/users/:id',
+      data: { 'sentry.source': 'route' },
+    } as any);
+
+    // Target: Would resolve to URL source (downgrade attempt)
+    vi.mocked(resolveRouteNameAndSource).mockReturnValue(['/users/456', 'url']);
+
+    const mockUpdateName = vi.fn();
+    const mockSetAttribute = vi.fn();
+    const testSpan = {
+      updateName: mockUpdateName,
+      setAttribute: mockSetAttribute,
+      end: vi.fn(),
+      __sentry_navigation_name_set__: true, // Mark as already named
+    } as unknown as Span;
+
+    updateNavigationSpan(
+      testSpan,
+      { pathname: '/users/456', search: '', hash: '', state: null, key: 'test' },
+      [{ path: '/users/:id', element: <div /> }],
+      false,
+      vi.fn(() => [{ route: { path: '/users/:id' } }]),
+    );
+
+    // Should not update because span is already named
+    // The early return in tryUpdateSpanNameBeforeEnd (line 815) protects against downgrades
+    // This test verifies that route->url downgrades are blocked
+    expect(mockUpdateName).not.toHaveBeenCalled();
+    expect(mockSetAttribute).not.toHaveBeenCalled();
+  });
+
+  it('should upgrade wildcard names to specific routes', async () => {
+    // Setup: Current span has route source with wildcard
+    vi.mocked(spanToJSON).mockReturnValue({
+      op: 'navigation',
+      description: '/users/*',
+      data: { 'sentry.source': 'route' },
+    } as any);
+
+    // Mock wildcard detection: current name has wildcard, new name doesn't
+    vi.mocked(transactionNameHasWildcard).mockImplementation((name: string) => {
+      return name === '/users/*'; // Only the current name has wildcard
+    });
+
+    // Target: Resolves to specific parameterized route
+    vi.mocked(resolveRouteNameAndSource).mockReturnValue(['/users/:id', 'route']);
+
+    const mockUpdateName = vi.fn();
+    const mockSetAttribute = vi.fn();
+    const testSpan = {
+      updateName: mockUpdateName,
+      setAttribute: mockSetAttribute,
+      end: vi.fn(),
+    } as unknown as Span;
+
+    updateNavigationSpan(
+      testSpan,
+      { pathname: '/users/123', search: '', hash: '', state: null, key: 'test' },
+      [{ path: '/users/:id', element: <div /> }],
+      false,
+      vi.fn(() => [{ route: { path: '/users/:id' } }]),
+    );
+
+    // Should upgrade from wildcard to specific
+    expect(mockUpdateName).toHaveBeenCalledWith('/users/:id');
+    expect(mockSetAttribute).toHaveBeenCalledWith('sentry.source', 'route');
+  });
+
+  it('should not downgrade from wildcard route to URL', async () => {
+    // Setup: Current span has route source with wildcard
+    vi.mocked(spanToJSON).mockReturnValue({
+      op: 'navigation',
+      description: '/users/*',
+      data: { 'sentry.source': 'route' },
+    } as any);
+
+    // Mock wildcard detection: current name has wildcard, new name doesn't
+    vi.mocked(transactionNameHasWildcard).mockImplementation((name: string) => {
+      return name === '/users/*'; // Only the current wildcard name returns true
+    });
+
+    // Target: After timeout, resolves to URL (lazy route didn't finish loading)
+    vi.mocked(resolveRouteNameAndSource).mockReturnValue(['/users/123', 'url']);
+
+    const mockUpdateName = vi.fn();
+    const mockSetAttribute = vi.fn();
+    const testSpan = {
+      updateName: mockUpdateName,
+      setAttribute: mockSetAttribute,
+      end: vi.fn(),
+      __sentry_navigation_name_set__: true, // Mark span as already named/finalized
+    } as unknown as Span;
+
+    updateNavigationSpan(
+      testSpan,
+      { pathname: '/users/123', search: '', hash: '', state: null, key: 'test' },
+      [{ path: '/users/*', element: <div /> }],
+      false,
+      vi.fn(() => [{ route: { path: '/users/*' } }]),
+    );
+
+    // Should not update - keep wildcard route instead of downgrading to URL
+    // Wildcard routes are better than URLs for aggregation in performance monitoring
+    expect(mockUpdateName).not.toHaveBeenCalled();
+    expect(mockSetAttribute).not.toHaveBeenCalled();
+  });
+
+  it('should set name when no current name exists', async () => {
+    // Setup: Current span has no name (undefined)
+    vi.mocked(spanToJSON).mockReturnValue({
+      op: 'navigation',
+      description: undefined,
+    } as any);
+
+    // Target: Resolves to route
+    vi.mocked(resolveRouteNameAndSource).mockReturnValue(['/users/:id', 'route']);
+
+    const mockUpdateName = vi.fn();
+    const mockSetAttribute = vi.fn();
+    const testSpan = {
+      updateName: mockUpdateName,
+      setAttribute: mockSetAttribute,
+      end: vi.fn(),
+    } as unknown as Span;
+
+    updateNavigationSpan(
+      testSpan,
+      { pathname: '/users/123', search: '', hash: '', state: null, key: 'test' },
+      [{ path: '/users/:id', element: <div /> }],
+      false,
+      vi.fn(() => [{ route: { path: '/users/:id' } }]),
+    );
+
+    // Should set initial name
+    expect(mockUpdateName).toHaveBeenCalledWith('/users/:id');
+    expect(mockSetAttribute).toHaveBeenCalledWith('sentry.source', 'route');
+  });
+
+  it('should not update when same source and no improvement', async () => {
+    // Setup: Current span has URL source
+    vi.mocked(spanToJSON).mockReturnValue({
+      op: 'navigation',
+      description: '/users/123',
+      data: { 'sentry.source': 'url' },
+    } as any);
+
+    // Target: Resolves to same URL source (no improvement)
+    vi.mocked(resolveRouteNameAndSource).mockReturnValue(['/users/123', 'url']);
+
+    const mockUpdateName = vi.fn();
+    const mockSetAttribute = vi.fn();
+    const testSpan = {
+      updateName: mockUpdateName,
+      setAttribute: mockSetAttribute,
+      end: vi.fn(),
+    } as unknown as Span;
+
+    updateNavigationSpan(
+      testSpan,
+      { pathname: '/users/123', search: '', hash: '', state: null, key: 'test' },
+      [{ path: '/users/:id', element: <div /> }],
+      false,
+      vi.fn(() => [{ route: { path: '/users/:id' } }]),
+    );
+
+    // Note: updateNavigationSpan always updates if not already named
+    // This test validates that the isImprovement logic works correctly in tryUpdateSpanNameBeforeEnd
+    // which is called during span.end() patching
+    expect(mockUpdateName).toHaveBeenCalled(); // Initial set is allowed
+  });
+});
diff --git a/packages/react/test/reactrouter-compat-utils/utils.test.ts b/packages/react/test/reactrouter-compat-utils/utils.test.ts
index 9ff48e7450bc..438b026104bd 100644
--- a/packages/react/test/reactrouter-compat-utils/utils.test.ts
+++ b/packages/react/test/reactrouter-compat-utils/utils.test.ts
@@ -9,6 +9,7 @@ import {
   prefixWithSlash,
   rebuildRoutePathFromAllRoutes,
   resolveRouteNameAndSource,
+  transactionNameHasWildcard,
 } from '../../src/reactrouter-compat-utils';
 import type { Location, MatchRoutes, RouteMatch, RouteObject } from '../../src/types';
 
@@ -629,4 +630,38 @@ describe('reactrouter-compat-utils/utils', () => {
       expect(result).toEqual(['/unknown', 'url']);
     });
   });
+
+  describe('transactionNameHasWildcard', () => {
+    it('should detect wildcard at the end of path', () => {
+      expect(transactionNameHasWildcard('/lazy/*')).toBe(true);
+      expect(transactionNameHasWildcard('/users/:id/*')).toBe(true);
+      expect(transactionNameHasWildcard('/products/:category/*')).toBe(true);
+    });
+
+    it('should detect standalone wildcard', () => {
+      expect(transactionNameHasWildcard('*')).toBe(true);
+    });
+
+    it('should detect wildcard in the middle of path', () => {
+      expect(transactionNameHasWildcard('/lazy/*/nested')).toBe(true);
+      expect(transactionNameHasWildcard('/a/*/b/*/c')).toBe(true);
+    });
+
+    it('should not detect wildcards in parameterized routes', () => {
+      expect(transactionNameHasWildcard('/users/:id')).toBe(false);
+      expect(transactionNameHasWildcard('/products/:category/:id')).toBe(false);
+      expect(transactionNameHasWildcard('/items/:itemId/details')).toBe(false);
+    });
+
+    it('should not detect wildcards in static routes', () => {
+      expect(transactionNameHasWildcard('/')).toBe(false);
+      expect(transactionNameHasWildcard('/about')).toBe(false);
+      expect(transactionNameHasWildcard('/users/profile')).toBe(false);
+    });
+
+    it('should handle edge cases', () => {
+      expect(transactionNameHasWildcard('')).toBe(false);
+      expect(transactionNameHasWildcard('/path/to/asterisk')).toBe(false); // 'asterisk' contains 'isk' but not '*'
+    });
+  });
 });