@sentry/react 10.53.1 → 10.55.0

package/build/cjs/reactrouter-compat-utils/instrumentation.js

@@ -8,52 +8,26 @@ const hoistNonReactStatics = require('../hoist-non-react-statics.js');
 const lazyRoutes = require('./lazy-routes.js');
 const utils = require('./utils.js');
 
-/* eslint-disable max-lines */
-// Inspired from Donnie McNeal's solution:
-// https://gist.github.com/wontondon/e8c4bdf2888875e4c755712e99279536
-
-
 let _useEffect;
 let _useLocation;
 let _useNavigationType;
 let _createRoutesFromChildren;
 let _matchRoutes;
-
 let _enableAsyncRouteHandlers = false;
-let _lazyRouteTimeout = 3000;
+let _lazyRouteTimeout = 3e3;
 let _lazyRouteManifest;
-let _basename = '';
-
-const CLIENTS_WITH_INSTRUMENT_NAVIGATION = new WeakSet();
-
-// Prevents duplicate spans when router.subscribe fires multiple times
-const activeNavigationSpans = new WeakMap
-
-();
-
-// Exported for testing only
-const allRoutes = new Set();
-
-// Tracks lazy route loads to wait before finalizing span names
-const pendingLazyRouteLoads = new WeakMap();
-
-// Tracks deferred lazy route promises that can be resolved when patchRoutesOnNavigation is called
-const deferredLazyRouteResolvers = new WeakMap();
-
-/**
- * Schedules a callback using requestAnimationFrame when available (browser),
- * or falls back to setTimeout for SSR environments (Node.js, createMemoryRouter tests).
- */
+let _basename = "";
+const CLIENTS_WITH_INSTRUMENT_NAVIGATION = /* @__PURE__ */ new WeakSet();
+const activeNavigationSpans = /* @__PURE__ */ new WeakMap();
+const allRoutes = /* @__PURE__ */ new Set();
+const pendingLazyRouteLoads = /* @__PURE__ */ new WeakMap();
+const deferredLazyRouteResolvers = /* @__PURE__ */ new WeakMap();
 function scheduleCallback(callback) {
   if (browser.WINDOW?.requestAnimationFrame) {
     return browser.WINDOW.requestAnimationFrame(callback);
   }
-  return setTimeout(callback, 0) ;
+  return setTimeout(callback, 0);
 }
-
-/**
- * Cancels a scheduled callback, handling both RAF (browser) and timeout (SSR) IDs.
- */
 function cancelScheduledCallback(id) {
   if (browser.WINDOW?.cancelAnimationFrame) {
     browser.WINDOW.cancelAnimationFrame(id);
@@ -61,103 +35,48 @@ function cancelScheduledCallback(id) {
     clearTimeout(id);
   }
 }
-
-/**
- * Computes location key for duplicate detection. Normalizes undefined/null to empty strings.
- * Exported for testing.
- */
 function computeLocationKey(location) {
-  return `${location.pathname}${location.search || ''}${location.hash || ''}`;
+  return `${location.pathname}${location.search || ""}${location.hash || ""}`;
 }
-
-/**
- * Checks if a route name is parameterized (contains route parameters like :id or wildcards like *)
- * vs a raw URL path.
- */
 function isParameterizedRoute(routeName) {
-  return routeName.includes(':') || routeName.includes('*');
+  return routeName.includes(":") || routeName.includes("*");
 }
-
-/**
- * Determines if a navigation should be skipped as a duplicate, and if an existing span should be updated.
- * Exported for testing.
- *
- * @returns An object with:
- *   - skip: boolean - Whether to skip creating a new span
- *   - shouldUpdate: boolean - Whether to update the existing span name (wildcard upgrade)
- */
-function shouldSkipNavigation(
-  trackedNav
-
-,
-  locationKey,
-  proposedName,
-  spanHasEnded,
-) {
+function shouldSkipNavigation(trackedNav, locationKey, proposedName, spanHasEnded) {
   if (!trackedNav) {
     return { skip: false, shouldUpdate: false };
   }
-
-  // Check if this is a duplicate navigation (same location)
-  // 1. If it's a placeholder, it's always a duplicate (we're waiting for the real one)
-  // 2. If it's a real span, it's a duplicate only if it hasn't ended yet
   const isDuplicate = trackedNav.locationKey === locationKey && (trackedNav.isPlaceholder || !spanHasEnded);
-
   if (isDuplicate) {
-    // Check if we should update the span name with a better route
-    // Allow updates if:
-    // 1. Current has wildcard and new doesn't (wildcard → parameterized upgrade)
-    // 2. Current is raw path and new is parameterized (raw → parameterized upgrade)
-    // 3. New name is different and more specific (longer, indicating nested routes resolved)
     const currentHasWildcard = !!trackedNav.routeName && utils.transactionNameHasWildcard(trackedNav.routeName);
     const proposedHasWildcard = utils.transactionNameHasWildcard(proposedName);
     const currentIsParameterized = !!trackedNav.routeName && isParameterizedRoute(trackedNav.routeName);
     const proposedIsParameterized = isParameterizedRoute(proposedName);
-
     const isWildcardUpgrade = currentHasWildcard && !proposedHasWildcard;
     const isRawToParameterized = !currentIsParameterized && proposedIsParameterized;
-    const isMoreSpecific =
-      proposedName !== trackedNav.routeName &&
-      proposedName.length > (trackedNav.routeName?.length || 0) &&
-      !proposedHasWildcard;
-
+    const isMoreSpecific = proposedName !== trackedNav.routeName && proposedName.length > (trackedNav.routeName?.length || 0) && !proposedHasWildcard;
     const shouldUpdate = !!(trackedNav.routeName && (isWildcardUpgrade || isRawToParameterized || isMoreSpecific));
-
     return { skip: true, shouldUpdate };
   }
-
   return { skip: false, shouldUpdate: false };
 }
-
 function addResolvedRoutesToParent(resolvedRoutes, parentRoute) {
   const existingChildren = parentRoute.children || [];
-
   const newRoutes = resolvedRoutes.filter(
-    newRoute =>
-      !existingChildren.some(
-        existing =>
-          existing === newRoute ||
-          (newRoute.path && existing.path === newRoute.path) ||
-          (newRoute.id && existing.id === newRoute.id),
-      ),
+    (newRoute) => !existingChildren.some(
+      (existing) => existing === newRoute || newRoute.path && existing.path === newRoute.path || newRoute.id && existing.id === newRoute.id
+    )
   );
-
   if (newRoutes.length > 0) {
     parentRoute.children = [...existingChildren, ...newRoutes];
   }
 }
-
-/** Registers a pending lazy route load promise for a span. */
 function trackLazyRouteLoad(span, promise) {
   let promises = pendingLazyRouteLoads.get(span);
   if (!promises) {
-    promises = new Set();
+    promises = /* @__PURE__ */ new Set();
     pendingLazyRouteLoads.set(span, promises);
   }
   promises.add(promise);
-
-  // Clean up when promise resolves/rejects
-  // oxlint-disable-next-line typescript/no-floating-promises
   promise.finally(() => {
     const currentPromises = pendingLazyRouteLoads.get(span);
     if (currentPromises) {
@@ -165,192 +84,122 @@ function trackLazyRouteLoad(span, promise) {
     }
   });
 }
-
-/**
- * Creates a deferred promise for a span that will be resolved when patchRoutesOnNavigation is called.
- * This ensures that patchedEnd waits for patchRoutesOnNavigation to be called before ending the span.
- */
 function createDeferredLazyRoutePromise(span) {
-  const deferredPromise = new Promise(resolve => {
+  const deferredPromise = new Promise((resolve) => {
     deferredLazyRouteResolvers.set(span, resolve);
   });
-
   trackLazyRouteLoad(span, deferredPromise);
 }
-
-/**
- * Resolves the deferred lazy route promise for a span.
- * Called when patchRoutesOnNavigation is invoked.
- */
 function resolveDeferredLazyRoutePromise(span) {
   const resolver = deferredLazyRouteResolvers.get(span);
   if (resolver) {
     resolver();
     deferredLazyRouteResolvers.delete(span);
-    // Clear the flag so patchSpanEnd doesn't wait unnecessarily for routes that have already loaded
-    if ((span ).__sentry_may_have_lazy_routes__) {
-      (span ).__sentry_may_have_lazy_routes__ = false;
+    if (span.__sentry_may_have_lazy_routes__) {
+      span.__sentry_may_have_lazy_routes__ = false;
     }
   }
 }
-
-/**
- * Processes resolved routes by adding them to allRoutes and checking for nested async handlers.
- * When capturedSpan is provided, updates that specific span instead of the current active span.
- * This prevents race conditions where a lazy handler resolves after the user has navigated away.
- */
-function processResolvedRoutes(
-  resolvedRoutes,
-  parentRoute,
-  currentLocation = null,
-  capturedSpan,
-) {
-  resolvedRoutes.forEach(child => {
+function processResolvedRoutes(resolvedRoutes, parentRoute, currentLocation = null, capturedSpan) {
+  resolvedRoutes.forEach((child) => {
     allRoutes.add(child);
-    // Only check for async handlers if the feature is enabled
     if (_enableAsyncRouteHandlers) {
       lazyRoutes.checkRouteForAsyncHandler(child, processResolvedRoutes);
     }
   });
-
   if (parentRoute) {
-    // If a parent route is provided, add the resolved routes as children to the parent route
     addResolvedRoutesToParent(resolvedRoutes, parentRoute);
   }
-
-  // Use captured span if provided, otherwise fall back to current active span
   const targetSpan = capturedSpan ?? utils.getActiveRootSpan();
   if (targetSpan) {
     const spanJson = core.spanToJSON(targetSpan);
-
-    // Skip update if span has already ended (timestamp is set when span.end() is called)
     if (spanJson.timestamp) {
-      debugBuild.DEBUG_BUILD && core.debug.warn('[React Router] Lazy handler resolved after span ended - skipping update');
+      debugBuild.DEBUG_BUILD && core.debug.warn("[React Router] Lazy handler resolved after span ended - skipping update");
       return;
     }
-
     const spanOp = spanJson.op;
-
-    // Use captured location for route matching (ensures we match against the correct route)
-    // Fall back to window.location only if no captured location and no captured span
-    // (i.e., this is not from an async handler)
     let location = currentLocation;
     if (!location && !capturedSpan) {
-      if (typeof browser.WINDOW !== 'undefined') {
+      if (typeof browser.WINDOW !== "undefined") {
         const globalLocation = browser.WINDOW.location;
         if (globalLocation?.pathname) {
           location = { pathname: globalLocation.pathname };
         }
       }
     }
-
     if (location) {
-      if (spanOp === 'pageload') {
-        // Re-run the pageload transaction update with the newly loaded routes
+      if (spanOp === "pageload") {
         updatePageloadTransaction({
           activeRootSpan: targetSpan,
           location: { pathname: location.pathname },
           routes: Array.from(allRoutes),
-          allRoutes: Array.from(allRoutes),
+          allRoutes: Array.from(allRoutes)
         });
-      } else if (spanOp === 'navigation') {
-        // For navigation spans, update the name with the newly loaded routes
+      } else if (spanOp === "navigation") {
         updateNavigationSpan(targetSpan, location, Array.from(allRoutes), false, _matchRoutes);
       }
     }
   }
 }
-
-/**
- * Updates a navigation span with the correct route name after lazy routes have been loaded.
- */
-function updateNavigationSpan(
-  activeRootSpan,
-  location,
-  allRoutes,
-  forceUpdate = false,
-  matchRoutes,
-) {
+function updateNavigationSpan(activeRootSpan, location, allRoutes2, forceUpdate = false, matchRoutes) {
   const spanJson = core.spanToJSON(activeRootSpan);
   const currentName = spanJson.description;
-
-  const hasBeenNamed = (activeRootSpan )?.__sentry_navigation_name_set__;
+  const hasBeenNamed = activeRootSpan?.__sentry_navigation_name_set__;
   const currentNameHasWildcard = currentName && utils.transactionNameHasWildcard(currentName);
   const shouldUpdate = !hasBeenNamed || forceUpdate || currentNameHasWildcard;
-
   if (shouldUpdate && !spanJson.timestamp) {
-    const currentBranches = matchRoutes(allRoutes, location);
+    const currentBranches = matchRoutes(allRoutes2, location);
     const [name, source] = utils.resolveRouteNameAndSource(
       location,
-      allRoutes,
-      allRoutes,
-      (currentBranches ) || [],
+      allRoutes2,
+      allRoutes2,
+      currentBranches || [],
       _basename,
       _lazyRouteManifest,
-      _enableAsyncRouteHandlers,
+      _enableAsyncRouteHandlers
     );
-
     const currentSource = spanJson.data?.[core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];
-    const isImprovement =
-      name &&
-      (!currentName || // No current name - always set
-        (!hasBeenNamed && (currentSource !== 'route' || source === 'route')) || // Not finalized - allow unless downgrading route→url
-        (currentSource !== 'route' && source === 'route') || // URL → route upgrade
-        (currentSource === 'route' && source === 'route' && currentNameHasWildcard)); // Route → better route (only if current has wildcard)
+    const isImprovement = name && (!currentName || // No current name - always set
+    !hasBeenNamed && (currentSource !== "route" || source === "route") || // Not finalized - allow unless downgrading route→url
+    currentSource !== "route" && source === "route" || // URL → route upgrade
+    currentSource === "route" && source === "route" && currentNameHasWildcard);
     if (isImprovement) {
       activeRootSpan.updateName(name);
       activeRootSpan.setAttribute(core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, source);
-
-      // Only mark as finalized for non-wildcard route names (allows URL→route upgrades).
-      if (!utils.transactionNameHasWildcard(name) && source === 'route') {
+      if (!utils.transactionNameHasWildcard(name) && source === "route") {
         core.addNonEnumerableProperty(
-          activeRootSpan ,
-          '__sentry_navigation_name_set__',
-          true,
+          activeRootSpan,
+          "__sentry_navigation_name_set__",
+          true
         );
       }
     }
   }
 }
-
-function setupRouterSubscription(
-  router,
-  routes,
-  version,
-  basename,
-  activeRootSpan,
-) {
+function setupRouterSubscription(router, routes, version, basename, activeRootSpan) {
   let isInitialPageloadComplete = false;
-  let hasSeenPageloadSpan = !!activeRootSpan && core.spanToJSON(activeRootSpan).op === 'pageload';
+  let hasSeenPageloadSpan = !!activeRootSpan && core.spanToJSON(activeRootSpan).op === "pageload";
   let hasSeenPopAfterPageload = false;
   let scheduledNavigationHandler = null;
   let lastHandledPathname = null;
-
   router.subscribe((state) => {
     if (!isInitialPageloadComplete) {
       const currentRootSpan = utils.getActiveRootSpan();
-      const isCurrentlyInPageload = currentRootSpan && core.spanToJSON(currentRootSpan).op === 'pageload';
-
+      const isCurrentlyInPageload = currentRootSpan && core.spanToJSON(currentRootSpan).op === "pageload";
       if (isCurrentlyInPageload) {
         hasSeenPageloadSpan = true;
       } else if (hasSeenPageloadSpan) {
-        if (state.historyAction === 'POP' && !hasSeenPopAfterPageload) {
+        if (state.historyAction === "POP" && !hasSeenPopAfterPageload) {
           hasSeenPopAfterPageload = true;
         } else {
           isInitialPageloadComplete = true;
         }
       }
     }
-
-    const shouldHandleNavigation =
-      state.historyAction === 'PUSH' || (state.historyAction === 'POP' && isInitialPageloadComplete);
-
+    const shouldHandleNavigation = state.historyAction === "PUSH" || state.historyAction === "POP" && isInitialPageloadComplete;
     if (shouldHandleNavigation) {
-      // Include search and hash to allow query/hash-only navigations
-      // Use computeLocationKey() to ensure undefined/null values are normalized to empty strings
       const currentLocationKey = computeLocationKey(state.location);
       const navigationHandler = () => {
-        // Prevent multiple calls for the same location within the same navigation cycle
         if (lastHandledPathname === currentLocationKey) {
           return;
         }
@@ -362,207 +211,119 @@ function setupRouterSubscription(
           navigationType: state.historyAction,
           version,
           basename,
-          allRoutes: Array.from(allRoutes),
+          allRoutes: Array.from(allRoutes)
         });
       };
-
-      if (state.navigation.state !== 'idle') {
-        // Navigation in progress - reset if location changed
+      if (state.navigation.state !== "idle") {
         if (lastHandledPathname !== currentLocationKey) {
           lastHandledPathname = null;
         }
-        // Cancel any previously scheduled handler to avoid duplicates
         if (scheduledNavigationHandler !== null) {
           cancelScheduledCallback(scheduledNavigationHandler);
         }
         scheduledNavigationHandler = scheduleCallback(navigationHandler);
       } else {
-        // Navigation completed - cancel scheduled handler if any, then call immediately
         if (scheduledNavigationHandler !== null) {
           cancelScheduledCallback(scheduledNavigationHandler);
           scheduledNavigationHandler = null;
         }
         navigationHandler();
-        // Don't reset - next navigation cycle resets to prevent duplicates within same cycle.
       }
     }
   });
 }
-
-/**
- * Creates a wrapCreateBrowserRouter function that can be used with all React Router v6 compatible versions.
- */
-function createV6CompatibleWrapCreateBrowserRouter
-
-(
-  createRouterFunction,
-  version,
-) {
+function createV6CompatibleWrapCreateBrowserRouter(createRouterFunction, version) {
   if (!_useEffect || !_useLocation || !_useNavigationType || !_matchRoutes) {
-    debugBuild.DEBUG_BUILD &&
-      core.debug.warn(
-        `reactRouterV${version}Instrumentation was unable to wrap the \`createRouter\` function because of one or more missing parameters.`,
-      );
-
+    debugBuild.DEBUG_BUILD && core.debug.warn(
+      `reactRouterV${version}Instrumentation was unable to wrap the \`createRouter\` function because of one or more missing parameters.`
+    );
     return createRouterFunction;
   }
-
-  return function (routes, opts) {
+  return function(routes, opts) {
     addRoutesToAllRoutes(routes);
-
     if (_enableAsyncRouteHandlers) {
       for (const route of routes) {
         lazyRoutes.checkRouteForAsyncHandler(route, processResolvedRoutes);
       }
     }
-
-    // Capture the active span BEFORE creating the router.
-    // This is important because the span might end (due to idle timeout) before
-    // patchRoutesOnNavigation is called by React Router.
     const activeRootSpan = utils.getActiveRootSpan();
-
-    // If patchRoutesOnNavigation is provided and we have an active span,
-    // mark the span as having potential lazy routes and create a deferred promise.
-    const hasPatchRoutesOnNavigation =
-      opts && 'patchRoutesOnNavigation' in opts && typeof opts.patchRoutesOnNavigation === 'function';
+    const hasPatchRoutesOnNavigation = opts && "patchRoutesOnNavigation" in opts && typeof opts.patchRoutesOnNavigation === "function";
     if (hasPatchRoutesOnNavigation && activeRootSpan) {
-      // Mark the span as potentially having lazy routes
       core.addNonEnumerableProperty(
-        activeRootSpan ,
-        '__sentry_may_have_lazy_routes__',
-        true,
+        activeRootSpan,
+        "__sentry_may_have_lazy_routes__",
+        true
       );
       createDeferredLazyRoutePromise(activeRootSpan);
     }
-
-    // Pass the captured span to wrapPatchRoutesOnNavigation so it uses the same span
-    // even if the span has ended by the time patchRoutesOnNavigation is called.
     const wrappedOpts = wrapPatchRoutesOnNavigation(opts, false, activeRootSpan);
     const router = createRouterFunction(routes, wrappedOpts);
     const basename = opts?.basename;
-
-    if (router.state.historyAction === 'POP' && activeRootSpan) {
+    if (router.state.historyAction === "POP" && activeRootSpan) {
       updatePageloadTransaction({
         activeRootSpan,
         location: router.state.location,
         routes,
         basename,
-        allRoutes: Array.from(allRoutes),
+        allRoutes: Array.from(allRoutes)
       });
     }
-
-    // Store basename for use in updateNavigationSpan
-    _basename = basename || '';
-
+    _basename = basename || "";
     setupRouterSubscription(router, routes, version, basename, activeRootSpan);
-
     return router;
   };
 }
-
-/**
- * Creates a wrapCreateMemoryRouter function that can be used with all React Router v6 compatible versions.
- */
-function createV6CompatibleWrapCreateMemoryRouter
-
-(
-  createRouterFunction,
-  version,
-) {
+function createV6CompatibleWrapCreateMemoryRouter(createRouterFunction, version) {
   if (!_useEffect || !_useLocation || !_useNavigationType || !_matchRoutes) {
-    debugBuild.DEBUG_BUILD &&
-      core.debug.warn(
-        `reactRouterV${version}Instrumentation was unable to wrap the \`createMemoryRouter\` function because of one or more missing parameters.`,
-      );
-
+    debugBuild.DEBUG_BUILD && core.debug.warn(
+      `reactRouterV${version}Instrumentation was unable to wrap the \`createMemoryRouter\` function because of one or more missing parameters.`
+    );
     return createRouterFunction;
   }
-
-  return function (
-    routes,
-    opts
-
-,
-  ) {
+  return function(routes, opts) {
     addRoutesToAllRoutes(routes);
-
     if (_enableAsyncRouteHandlers) {
       for (const route of routes) {
         lazyRoutes.checkRouteForAsyncHandler(route, processResolvedRoutes);
       }
     }
-
-    // Capture the active span BEFORE creating the router (same as browser router)
     const memoryActiveRootSpanEarly = utils.getActiveRootSpan();
-
-    // If patchRoutesOnNavigation is provided and we have an active span,
-    // mark the span as having potential lazy routes and create a deferred promise.
-    const hasPatchRoutesOnNavigation =
-      opts && 'patchRoutesOnNavigation' in opts && typeof opts.patchRoutesOnNavigation === 'function';
+    const hasPatchRoutesOnNavigation = opts && "patchRoutesOnNavigation" in opts && typeof opts.patchRoutesOnNavigation === "function";
     if (hasPatchRoutesOnNavigation && memoryActiveRootSpanEarly) {
       core.addNonEnumerableProperty(
-        memoryActiveRootSpanEarly ,
-        '__sentry_may_have_lazy_routes__',
-        true,
+        memoryActiveRootSpanEarly,
+        "__sentry_may_have_lazy_routes__",
+        true
       );
       createDeferredLazyRoutePromise(memoryActiveRootSpanEarly);
     }
-
     const wrappedOpts = wrapPatchRoutesOnNavigation(opts, true, memoryActiveRootSpanEarly);
-
     const router = createRouterFunction(routes, wrappedOpts);
     const basename = opts?.basename;
-
-    let initialEntry = undefined;
-
+    let initialEntry = void 0;
     const initialEntries = opts?.initialEntries;
     const initialIndex = opts?.initialIndex;
-
     const hasOnlyOneInitialEntry = initialEntries?.length === 1;
-    const hasIndexedEntry = initialIndex !== undefined && initialEntries?.[initialIndex];
-
-    initialEntry = hasOnlyOneInitialEntry
-      ? initialEntries[0]
-      : hasIndexedEntry
-        ? initialEntries[initialIndex]
-        : undefined;
-
-    const location = initialEntry
-      ? typeof initialEntry === 'string'
-        ? { pathname: initialEntry }
-        : initialEntry
-      : router.state.location;
-
+    const hasIndexedEntry = initialIndex !== void 0 && initialEntries?.[initialIndex];
+    initialEntry = hasOnlyOneInitialEntry ? initialEntries[0] : hasIndexedEntry ? initialEntries[initialIndex] : void 0;
+    const location = initialEntry ? typeof initialEntry === "string" ? { pathname: initialEntry } : initialEntry : router.state.location;
     const memoryActiveRootSpan = utils.getActiveRootSpan();
-
-    if (router.state.historyAction === 'POP' && memoryActiveRootSpan) {
+    if (router.state.historyAction === "POP" && memoryActiveRootSpan) {
       updatePageloadTransaction({
         activeRootSpan: memoryActiveRootSpan,
         location,
         routes,
         basename,
-        allRoutes: Array.from(allRoutes),
+        allRoutes: Array.from(allRoutes)
       });
     }
-
-    // Store basename for use in updateNavigationSpan
-    _basename = basename || '';
-
+    _basename = basename || "";
     setupRouterSubscription(router, routes, version, basename, memoryActiveRootSpan);
-
     return router;
   };
 }
-
-/**
- * Creates a browser tracing integration that can be used with all React Router v6 compatible versions.
- */
-function createReactRouterV6CompatibleTracingIntegration(
-  options,
-  version,
-) {
+function createReactRouterV6CompatibleTracingIntegration(options, version) {
   const integration = browser.browserTracingIntegration({ ...options, instrumentPageLoad: false, instrumentNavigation: false });
-
   const {
     useEffect,
     useLocation,
@@ -574,44 +335,36 @@ function createReactRouterV6CompatibleTracingIntegration(
     instrumentPageLoad = true,
     instrumentNavigation = true,
     lazyRouteTimeout,
-    lazyRouteManifest,
+    lazyRouteManifest
   } = options;
-
   return {
     ...integration,
     setup(client) {
       integration.setup(client);
-
-      const finalTimeout = options.finalTimeout ?? 30000;
-      const defaultMaxWait = (options.idleTimeout ?? 1000) * 3;
+      const finalTimeout = options.finalTimeout ?? 3e4;
+      const defaultMaxWait = (options.idleTimeout ?? 1e3) * 3;
       const configuredMaxWait = lazyRouteTimeout ?? defaultMaxWait;
-
-      // Cap Infinity at finalTimeout to prevent indefinite hangs
       if (configuredMaxWait === Infinity) {
         _lazyRouteTimeout = finalTimeout;
-        debugBuild.DEBUG_BUILD &&
-          core.debug.log(
-            '[React Router] lazyRouteTimeout set to Infinity, capping at finalTimeout:',
-            finalTimeout,
-            'ms to prevent indefinite hangs',
-          );
+        debugBuild.DEBUG_BUILD && core.debug.log(
+          "[React Router] lazyRouteTimeout set to Infinity, capping at finalTimeout:",
+          finalTimeout,
+          "ms to prevent indefinite hangs"
+        );
       } else if (Number.isNaN(configuredMaxWait)) {
-        debugBuild.DEBUG_BUILD &&
-          core.debug.warn('[React Router] lazyRouteTimeout must be a number, falling back to default:', defaultMaxWait);
+        debugBuild.DEBUG_BUILD && core.debug.warn("[React Router] lazyRouteTimeout must be a number, falling back to default:", defaultMaxWait);
         _lazyRouteTimeout = defaultMaxWait;
       } else if (configuredMaxWait < 0) {
-        debugBuild.DEBUG_BUILD &&
-          core.debug.warn(
-            '[React Router] lazyRouteTimeout must be non-negative or Infinity, got:',
-            configuredMaxWait,
-            'falling back to:',
-            defaultMaxWait,
-          );
+        debugBuild.DEBUG_BUILD && core.debug.warn(
+          "[React Router] lazyRouteTimeout must be non-negative or Infinity, got:",
+          configuredMaxWait,
+          "falling back to:",
+          defaultMaxWait
+        );
         _lazyRouteTimeout = defaultMaxWait;
       } else {
         _lazyRouteTimeout = configuredMaxWait;
       }
-
       _useEffect = useEffect;
       _useLocation = useLocation;
       _useNavigationType = useNavigationType;
@@ -619,278 +372,188 @@ function createReactRouterV6CompatibleTracingIntegration(
       _createRoutesFromChildren = createRoutesFromChildren;
       _enableAsyncRouteHandlers = enableAsyncRouteHandlers;
       _lazyRouteManifest = lazyRouteManifest;
-
-      // Initialize the router utils with the required dependencies
       utils.initializeRouterUtils(matchRoutes, stripBasename || false);
     },
     afterAllSetup(client) {
       integration.afterAllSetup(client);
-
       const initPathName = browser.WINDOW.location?.pathname;
       if (instrumentPageLoad && initPathName) {
         browser.startBrowserTracingPageLoadSpan(client, {
           name: initPathName,
           attributes: {
-            [core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',
-            [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'pageload',
-            [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: `auto.pageload.react.reactrouter_v${version}`,
-          },
+            [core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: "url",
+            [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: "pageload",
+            [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: `auto.pageload.react.reactrouter_v${version}`
+          }
         });
       }
-
       if (instrumentNavigation) {
         CLIENTS_WITH_INSTRUMENT_NAVIGATION.add(client);
       }
-    },
+    }
   };
 }
-
 function createV6CompatibleWrapUseRoutes(origUseRoutes, version) {
   if (!_useEffect || !_useLocation || !_useNavigationType || !_matchRoutes) {
-    debugBuild.DEBUG_BUILD &&
-      core.debug.warn(
-        'reactRouterV6Instrumentation was unable to wrap `useRoutes` because of one or more missing parameters.',
-      );
-
+    debugBuild.DEBUG_BUILD && core.debug.warn(
+      "reactRouterV6Instrumentation was unable to wrap `useRoutes` because of one or more missing parameters."
+    );
     return origUseRoutes;
   }
-
-  const SentryRoutes
-
- = (props) => {
+  const SentryRoutes = (props) => {
     const isMountRenderPass = React.useRef(true);
     const { routes, locationArg } = props;
-
     const Routes = origUseRoutes(routes, locationArg);
-
     const location = _useLocation();
     const navigationType = _useNavigationType();
-
-    // A value with stable identity to either pick `locationArg` if available or `location` if not
-    const stableLocationParam =
-      typeof locationArg === 'string' || locationArg?.pathname ? (locationArg ) : location;
-
+    const stableLocationParam = typeof locationArg === "string" || locationArg?.pathname ? locationArg : location;
     _useEffect(() => {
-      const normalizedLocation =
-        typeof stableLocationParam === 'string' ? { pathname: stableLocationParam } : stableLocationParam;
-
+      const normalizedLocation = typeof stableLocationParam === "string" ? { pathname: stableLocationParam } : stableLocationParam;
       if (isMountRenderPass.current) {
         addRoutesToAllRoutes(routes);
-
         updatePageloadTransaction({
           activeRootSpan: utils.getActiveRootSpan(),
           location: normalizedLocation,
           routes,
-          allRoutes: Array.from(allRoutes),
+          allRoutes: Array.from(allRoutes)
         });
         isMountRenderPass.current = false;
       } else {
-        // Note: Component-based routes don't support lazy route tracking via lazyRouteTimeout
-        // because React.lazy() loads happen at the component level, not the router level.
-        // Use createBrowserRouter with patchRoutesOnNavigation for lazy route tracking.
         handleNavigation({
           location: normalizedLocation,
           routes,
           navigationType,
           version,
-          allRoutes: Array.from(allRoutes),
+          allRoutes: Array.from(allRoutes)
         });
       }
     }, [navigationType, stableLocationParam]);
-
     return Routes;
   };
-
-  // eslint-disable-next-line react/display-name
   return (routes, locationArg) => {
-    return React.createElement(SentryRoutes, { routes: routes, locationArg: locationArg,} );
+    return /* @__PURE__ */ React.createElement(SentryRoutes, { routes, locationArg });
   };
 }
-function wrapPatchRoutesOnNavigation(
-  opts,
-  isMemoryRouter = false,
-  capturedSpan,
-) {
-  if (!opts || !('patchRoutesOnNavigation' in opts) || typeof opts.patchRoutesOnNavigation !== 'function') {
+function wrapPatchRoutesOnNavigation(opts, isMemoryRouter = false, capturedSpan) {
+  if (!opts || !("patchRoutesOnNavigation" in opts) || typeof opts.patchRoutesOnNavigation !== "function") {
     return opts || {};
   }
-
   const originalPatchRoutes = opts.patchRoutesOnNavigation;
   return {
     ...opts,
     patchRoutesOnNavigation: async (args) => {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-      const targetPath = (args )?.path;
-
-      // Use current active span if available, otherwise fall back to captured span (from router creation time).
-      // This ensures navigation spans use their own span (not the stale pageload span), while still
-      // supporting pageload spans that may have ended before patchRoutesOnNavigation is called.
+      const targetPath = args?.path;
       const activeRootSpan = utils.getActiveRootSpan() ?? capturedSpan;
-
       if (!isMemoryRouter) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-        const originalPatch = (args )?.patch;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-        const matches = (args )?.matches ;
+        const originalPatch = args?.patch;
+        const matches = args?.matches;
         if (originalPatch) {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-          (args ).patch = (routeId, children) => {
+          args.patch = (routeId, children) => {
             addRoutesToAllRoutes(children);
-
-            // Find the parent route from matches and attach children to it in allRoutes.
-            // React Router's patch attaches children to its internal route copies, but we need
-            // to update the route objects in our allRoutes Set for proper route matching.
             if (matches && matches.length > 0) {
               const leafMatch = matches[matches.length - 1];
               const leafRoute = leafMatch?.route;
               if (leafRoute) {
-                // Find the matching route in allRoutes by id, reference, or path
-                const matchingRoute = Array.from(allRoutes).find(route => {
-                  const idMatches = route.id !== undefined && route.id === routeId;
+                const matchingRoute = Array.from(allRoutes).find((route) => {
+                  const idMatches = route.id !== void 0 && route.id === routeId;
                   const referenceMatches = route === leafRoute;
-                  const pathMatches =
-                    route.path !== undefined && leafRoute.path !== undefined && route.path === leafRoute.path;
-
+                  const pathMatches = route.path !== void 0 && leafRoute.path !== void 0 && route.path === leafRoute.path;
                   return idMatches || referenceMatches || pathMatches;
                 });
-
                 if (matchingRoute) {
                   addResolvedRoutesToParent(children, matchingRoute);
                 }
               }
             }
-
-            // Use the captured activeRootSpan instead of getActiveRootSpan() to avoid race conditions
-            // where user navigates away during lazy route loading and we'd update the wrong span
-            const spanJson = activeRootSpan ? core.spanToJSON(activeRootSpan) : undefined;
-            // Only update if we have a valid targetPath (patchRoutesOnNavigation can be called without path),
-            // the captured span exists, hasn't ended, and is a navigation span
-            if (
-              targetPath &&
-              activeRootSpan &&
-              spanJson &&
-              !spanJson.timestamp && // Span hasn't ended yet
-              spanJson.op === 'navigation'
-            ) {
+            const spanJson = activeRootSpan ? core.spanToJSON(activeRootSpan) : void 0;
+            if (targetPath && activeRootSpan && spanJson && !spanJson.timestamp && // Span hasn't ended yet
+            spanJson.op === "navigation") {
               updateNavigationSpan(
                 activeRootSpan,
-                { pathname: targetPath, search: '', hash: '', state: null, key: 'default' },
+                { pathname: targetPath, search: "", hash: "", state: null, key: "default" },
                 Array.from(allRoutes),
                 true,
-                _matchRoutes,
+                _matchRoutes
               );
             }
             return originalPatch(routeId, children);
           };
         }
       }
-
       const lazyLoadPromise = (async () => {
-        // Set context so async handlers can access correct targetPath and span
         const contextToken = utils.setNavigationContext(targetPath, activeRootSpan);
         let result;
         try {
           result = await originalPatchRoutes(args);
         } finally {
           utils.clearNavigationContext(contextToken);
-          // Resolve the deferred promise now that patchRoutesOnNavigation has completed.
-          // This ensures patchedEnd has waited long enough for the lazy routes to load.
           if (activeRootSpan) {
             resolveDeferredLazyRoutePromise(activeRootSpan);
           }
         }
-
-        // Use the captured activeRootSpan instead of getActiveRootSpan() to avoid race conditions
-        // where user navigates away during lazy route loading and we'd update the wrong span
-        const spanJson = activeRootSpan ? core.spanToJSON(activeRootSpan) : undefined;
-        if (
-          activeRootSpan &&
-          spanJson &&
-          !spanJson.timestamp && // Span hasn't ended yet
-          spanJson.op === 'navigation'
-        ) {
-          // Use targetPath consistently - don't fall back to WINDOW.location which may have changed
-          // if the user navigated away during async loading
+        const spanJson = activeRootSpan ? core.spanToJSON(activeRootSpan) : void 0;
+        if (activeRootSpan && spanJson && !spanJson.timestamp && // Span hasn't ended yet
+        spanJson.op === "navigation") {
           const pathname = targetPath;
-
           if (pathname) {
             updateNavigationSpan(
               activeRootSpan,
-              { pathname, search: '', hash: '', state: null, key: 'default' },
+              { pathname, search: "", hash: "", state: null, key: "default" },
               Array.from(allRoutes),
               false,
-              _matchRoutes,
+              _matchRoutes
             );
           }
         }
-
         return result;
       })();
-
       if (activeRootSpan) {
         trackLazyRouteLoad(activeRootSpan, lazyLoadPromise);
       }
-
       return lazyLoadPromise;
-    },
+    }
   };
 }
-
-// eslint-disable-next-line complexity
-function handleNavigation(opts
-
-) {
-  const { location, routes, navigationType, version, matches, basename, allRoutes } = opts;
-  const branches = Array.isArray(matches) ? matches : _matchRoutes(allRoutes || routes, location, basename);
-
+function handleNavigation(opts) {
+  const { location, routes, navigationType, version, matches, basename, allRoutes: allRoutes2 } = opts;
+  const branches = Array.isArray(matches) ? matches : _matchRoutes(allRoutes2 || routes, location, basename);
   const client = core.getClient();
   if (!client || !CLIENTS_WITH_INSTRUMENT_NAVIGATION.has(client)) {
     return;
   }
-
   const activeRootSpan = utils.getActiveRootSpan();
-  if (activeRootSpan && core.spanToJSON(activeRootSpan).op === 'pageload' && navigationType === 'POP') {
+  if (activeRootSpan && core.spanToJSON(activeRootSpan).op === "pageload" && navigationType === "POP") {
     return;
   }
-
-  if ((navigationType === 'PUSH' || navigationType === 'POP') && branches) {
+  if ((navigationType === "PUSH" || navigationType === "POP") && branches) {
     const [name, source] = utils.resolveRouteNameAndSource(
       location,
-      allRoutes || routes,
-      allRoutes || routes,
-      branches ,
+      allRoutes2 || routes,
+      allRoutes2 || routes,
+      branches,
       basename,
       _lazyRouteManifest,
-      _enableAsyncRouteHandlers,
+      _enableAsyncRouteHandlers
     );
-
     const locationKey = computeLocationKey(location);
     const trackedNav = activeNavigationSpans.get(client);
-
-    // Determine if this navigation should be skipped as a duplicate
-    const trackedSpanHasEnded =
-      trackedNav && !trackedNav.isPlaceholder ? !!core.spanToJSON(trackedNav.span).timestamp : false;
+    const trackedSpanHasEnded = trackedNav && !trackedNav.isPlaceholder ? !!core.spanToJSON(trackedNav.span).timestamp : false;
     const { skip, shouldUpdate } = shouldSkipNavigation(trackedNav, locationKey, name, trackedSpanHasEnded);
-
     if (skip) {
       if (shouldUpdate && trackedNav) {
         const oldName = trackedNav.routeName;
-
         if (trackedNav.isPlaceholder) {
-          // Update placeholder's route name - the real span will be created with this name
           trackedNav.routeName = name;
-          debugBuild.DEBUG_BUILD &&
-            core.debug.log(
-              `[Tracing] Updated placeholder navigation name from "${oldName}" to "${name}" (will apply to real span)`,
-            );
+          debugBuild.DEBUG_BUILD && core.debug.log(
+            `[Tracing] Updated placeholder navigation name from "${oldName}" to "${name}" (will apply to real span)`
+          );
         } else {
-          // Update existing real span from wildcard to parameterized route name
           trackedNav.span.updateName(name);
-          trackedNav.span.setAttribute(core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, source );
+          trackedNav.span.setAttribute(core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, source);
           core.addNonEnumerableProperty(
-            trackedNav.span ,
-            '__sentry_navigation_name_set__',
-            true,
+            trackedNav.span,
+            "__sentry_navigation_name_set__",
+            true
           );
           trackedNav.routeName = name;
           debugBuild.DEBUG_BUILD && core.debug.log(`[Tracing] Updated navigation span name from "${oldName}" to "${name}"`);
@@ -900,191 +563,124 @@ function handleNavigation(opts
       }
       return;
     }
-
-    // Create new navigation span (first navigation or legitimate new navigation)
-    // Reserve the spot in the map first to prevent race conditions
-    // Mark as placeholder to prevent concurrent handleNavigation calls from creating duplicates
-    const placeholderSpan = { end: () => {} } ;
+    const placeholderSpan = { end: () => {
+    } };
     const placeholderEntry = {
       span: placeholderSpan,
       routeName: name,
       pathname: location.pathname,
       locationKey,
-      isPlaceholder: true ,
+      isPlaceholder: true
     };
     activeNavigationSpans.set(client, placeholderEntry);
-
     let navigationSpan;
     try {
       navigationSpan = browser.startBrowserTracingNavigationSpan(client, {
-        name: placeholderEntry.routeName, // Use placeholder's routeName in case it was updated
+        name: placeholderEntry.routeName,
+        // Use placeholder's routeName in case it was updated
         attributes: {
           [core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: source,
-          [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'navigation',
-          [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: `auto.navigation.react.reactrouter_v${version}`,
-        },
+          [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: "navigation",
+          [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: `auto.navigation.react.reactrouter_v${version}`
+        }
       });
     } catch (e) {
-      // If span creation fails, remove the placeholder so we don't block future navigations
       activeNavigationSpans.delete(client);
       throw e;
     }
-
     if (navigationSpan) {
-      // Update the map with the real span (isPlaceholder omitted, defaults to false)
       activeNavigationSpans.set(client, {
         span: navigationSpan,
-        routeName: placeholderEntry.routeName, // Use the (potentially updated) placeholder routeName
+        routeName: placeholderEntry.routeName,
+        // Use the (potentially updated) placeholder routeName
         pathname: location.pathname,
-        locationKey,
+        locationKey
       });
-      patchSpanEnd(navigationSpan, location, routes, basename, 'navigation');
+      patchSpanEnd(navigationSpan, location, routes, basename, "navigation");
     } else {
-      // If no span was created, remove the placeholder
       activeNavigationSpans.delete(client);
     }
   }
 }
-
-/* Only exported for testing purposes */
 function addRoutesToAllRoutes(routes) {
-  routes.forEach(route => {
+  routes.forEach((route) => {
     const extractedChildRoutes = getChildRoutesRecursively(route);
-
-    extractedChildRoutes.forEach(r => {
+    extractedChildRoutes.forEach((r) => {
       allRoutes.add(r);
     });
   });
 }
-
-function getChildRoutesRecursively(route, allRoutes = new Set()) {
-  if (!allRoutes.has(route)) {
-    allRoutes.add(route);
-
+function getChildRoutesRecursively(route, allRoutes2 = /* @__PURE__ */ new Set()) {
+  if (!allRoutes2.has(route)) {
+    allRoutes2.add(route);
     if (route.children && !route.index) {
-      route.children.forEach(child => {
-        const childRoutes = getChildRoutesRecursively(child, allRoutes);
-
-        childRoutes.forEach(r => {
-          allRoutes.add(r);
+      route.children.forEach((child) => {
+        const childRoutes = getChildRoutesRecursively(child, allRoutes2);
+        childRoutes.forEach((r) => {
+          allRoutes2.add(r);
         });
       });
     }
   }
-
-  return allRoutes;
+  return allRoutes2;
 }
-
 function updatePageloadTransaction({
   activeRootSpan,
   location,
   routes,
   matches,
   basename,
-  allRoutes,
-}
-
-) {
-  const branches = Array.isArray(matches)
-    ? matches
-    : (_matchRoutes(allRoutes || routes, location, basename) );
-
+  allRoutes: allRoutes2
+}) {
+  const branches = Array.isArray(matches) ? matches : _matchRoutes(allRoutes2 || routes, location, basename);
   if (branches) {
     const [name, source] = utils.resolveRouteNameAndSource(
       location,
-      allRoutes || routes,
-      allRoutes || routes,
+      allRoutes2 || routes,
+      allRoutes2 || routes,
       branches,
       basename,
       _lazyRouteManifest,
-      _enableAsyncRouteHandlers,
+      _enableAsyncRouteHandlers
     );
-
-    core.getCurrentScope().setTransactionName(name || '/');
-
+    core.getCurrentScope().setTransactionName(name || "/");
     if (activeRootSpan) {
       activeRootSpan.updateName(name);
       activeRootSpan.setAttribute(core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, source);
-
-      // Patch span.end() to ensure we update the name one last time before the span is sent
-      patchSpanEnd(activeRootSpan, location, routes, basename, 'pageload');
+      patchSpanEnd(activeRootSpan, location, routes, basename, "pageload");
     }
   } else if (activeRootSpan) {
-    // Even if branches is null (can happen when lazy routes haven't loaded yet),
-    // we still need to patch span.end() so that when lazy routes load and the span ends,
-    // we can update the transaction name correctly.
-    patchSpanEnd(activeRootSpan, location, routes, basename, 'pageload');
+    patchSpanEnd(activeRootSpan, location, routes, basename, "pageload");
   }
 }
-
-/**
- * Determines if a span name should be updated during wildcard route resolution.
- *
- * Update conditions (in priority order):
- * 1. No current name + allowNoCurrentName: true → always update (pageload spans)
- * 2. Current name has wildcard + new is route without wildcard → upgrade (e.g., "/users/*" → "/users/:id")
- * 3. Current source is not 'route' + new source is 'route' → upgrade (e.g., URL → parameterized route)
- *
- * @param currentName - The current span name (may be undefined)
- * @param currentSource - The current span source ('route', 'url', or undefined)
- * @param newName - The proposed new span name
- * @param newSource - The proposed new span source
- * @param allowNoCurrentName - If true, allow updates when there's no current name (for pageload spans)
- * @returns true if the span name should be updated
- */
-function shouldUpdateWildcardSpanName(
-  currentName,
-  currentSource,
-  newName,
-  newSource,
-  allowNoCurrentName = false,
-) {
+function shouldUpdateWildcardSpanName(currentName, currentSource, newName, newSource, allowNoCurrentName = false) {
   if (!newName) {
     return false;
   }
-
   if (!currentName && allowNoCurrentName) {
     return true;
   }
-
   const hasWildcard = currentName && utils.transactionNameHasWildcard(currentName);
-
-  if (hasWildcard && newSource === 'route' && !utils.transactionNameHasWildcard(newName)) {
+  if (hasWildcard && newSource === "route" && !utils.transactionNameHasWildcard(newName)) {
     return true;
   }
-
-  if (currentSource !== 'route' && newSource === 'route') {
+  if (currentSource !== "route" && newSource === "route") {
     return true;
   }
-
   return false;
 }
-
-function tryUpdateSpanNameBeforeEnd(
-  span,
-  spanJson,
-  currentName,
-  location,
-  routes,
-  basename,
-  spanType,
-  allRoutes,
-) {
+function tryUpdateSpanNameBeforeEnd(span, spanJson, currentName, location, routes, basename, spanType, allRoutes2) {
   try {
     const currentSource = spanJson.data?.[core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];
-
-    if (currentSource === 'route' && currentName && !utils.transactionNameHasWildcard(currentName)) {
+    if (currentSource === "route" && currentName && !utils.transactionNameHasWildcard(currentName)) {
       return;
     }
-
-    const currentAllRoutes = Array.from(allRoutes);
+    const currentAllRoutes = Array.from(allRoutes2);
     const routesToUse = currentAllRoutes.length > 0 ? currentAllRoutes : routes;
-    const branches = _matchRoutes(routesToUse, location, basename) ;
-
+    const branches = _matchRoutes(routesToUse, location, basename);
     if (!branches) {
       return;
     }
-
     const [name, source] = utils.resolveRouteNameAndSource(
       location,
       routesToUse,
@@ -1092,12 +688,10 @@ function tryUpdateSpanNameBeforeEnd(
       branches,
       basename,
       _lazyRouteManifest,
-      _enableAsyncRouteHandlers,
+      _enableAsyncRouteHandlers
     );
-
     const isImprovement = shouldUpdateWildcardSpanName(currentName, currentSource, name, source, true);
-    const spanNotEnded = spanType === 'pageload' || !spanJson.timestamp;
-
+    const spanNotEnded = spanType === "pageload" || !spanJson.timestamp;
     if (isImprovement && spanNotEnded) {
       span.updateName(name);
       span.setAttribute(core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, source);
@@ -1106,68 +700,36 @@ function tryUpdateSpanNameBeforeEnd(
     debugBuild.DEBUG_BUILD && core.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.
- */
-function patchSpanEnd(
-  span,
-  location,
-  routes,
-  basename,
-  spanType,
-) {
-  const patchedPropertyName = `__sentry_${spanType}_end_patched__` ;
-  const hasEndBeenPatched = (span )?.[patchedPropertyName];
-
+function patchSpanEnd(span, location, routes, basename, spanType) {
+  const patchedPropertyName = `__sentry_${spanType}_end_patched__`;
+  const hasEndBeenPatched = span?.[patchedPropertyName];
   if (hasEndBeenPatched || !span.end) {
     return;
   }
-
-  // Uses global allRoutes to access lazy-loaded routes added after this function was called.
-
   const originalEnd = span.end.bind(span);
   let endCalled = false;
-
   span.end = function patchedEnd(...args) {
     if (endCalled) {
       return;
     }
     endCalled = true;
-
-    // Capture timestamp immediately to avoid delay from async operations
-    // If no timestamp was provided, capture the current time now
-    const endTimestamp = args.length > 0 ? args[0] : Date.now() / 1000;
-
+    const endTimestamp = args.length > 0 ? args[0] : Date.now() / 1e3;
     const spanJson = core.spanToJSON(span);
     const currentName = spanJson.description;
     const currentSource = spanJson.data?.[core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];
-
-    // Helper to clean up activeNavigationSpans after span ends
     const cleanupNavigationSpan = () => {
       const client = core.getClient();
-      if (client && spanType === 'navigation') {
+      if (client && spanType === "navigation") {
         const trackedNav = activeNavigationSpans.get(client);
         if (trackedNav && trackedNav.span === span) {
           activeNavigationSpans.delete(client);
         }
       }
     };
-
     const pendingPromises = pendingLazyRouteLoads.get(span);
-    const mayHaveLazyRoutes = (span ).__sentry_may_have_lazy_routes__;
-
-    // Wait for lazy routes if:
-    // 1. (There are pending promises OR the span was marked as potentially having lazy routes) AND
-    // 2. Current name exists AND
-    // 3. Either the name has a wildcard OR the source is not 'route' (URL-based names)
-    const hasPendingOrMayHaveLazyRoutes = (pendingPromises && pendingPromises.size > 0) || mayHaveLazyRoutes;
-    const shouldWaitForLazyRoutes =
-      hasPendingOrMayHaveLazyRoutes &&
-      currentName &&
-      (utils.transactionNameHasWildcard(currentName) || currentSource !== 'route');
-
+    const mayHaveLazyRoutes = span.__sentry_may_have_lazy_routes__;
+    const hasPendingOrMayHaveLazyRoutes = pendingPromises && pendingPromises.size > 0 || mayHaveLazyRoutes;
+    const shouldWaitForLazyRoutes = hasPendingOrMayHaveLazyRoutes && currentName && (utils.transactionNameHasWildcard(currentName) || currentSource !== "route");
     if (shouldWaitForLazyRoutes) {
       if (_lazyRouteTimeout === 0) {
         tryUpdateSpanNameBeforeEnd(span, spanJson, currentName, location, routes, basename, spanType, allRoutes);
@@ -1175,107 +737,74 @@ function patchSpanEnd(
         originalEnd(endTimestamp);
         return;
       }
-
-      // If we have pending promises, wait for them. Otherwise, just wait for the timeout.
-      // This handles the case where we know lazy routes might load but patchRoutesOnNavigation
-      // hasn't been called yet.
-      const timeoutPromise = new Promise(r => setTimeout(r, _lazyRouteTimeout));
+      const timeoutPromise = new Promise((r) => setTimeout(r, _lazyRouteTimeout));
       let waitPromise;
-
       if (pendingPromises && pendingPromises.size > 0) {
-        const allSettled = Promise.allSettled(pendingPromises).then(() => {});
+        const allSettled = Promise.allSettled(pendingPromises).then(() => {
+        });
         waitPromise = _lazyRouteTimeout === Infinity ? allSettled : Promise.race([allSettled, timeoutPromise]);
       } else {
-        // No pending promises yet, but we know lazy routes might load
-        // Wait for the timeout to give React Router time to call patchRoutesOnNavigation
         waitPromise = timeoutPromise;
       }
-
-      waitPromise
-        .then(() => {
-          const updatedSpanJson = core.spanToJSON(span);
-          tryUpdateSpanNameBeforeEnd(
-            span,
-            updatedSpanJson,
-            updatedSpanJson.description,
-            location,
-            routes,
-            basename,
-            spanType,
-            allRoutes,
-          );
-          cleanupNavigationSpan();
-          originalEnd(endTimestamp);
-        })
-        .catch(() => {
-          cleanupNavigationSpan();
-          originalEnd(endTimestamp);
-        });
+      waitPromise.then(() => {
+        const updatedSpanJson = core.spanToJSON(span);
+        tryUpdateSpanNameBeforeEnd(
+          span,
+          updatedSpanJson,
+          updatedSpanJson.description,
+          location,
+          routes,
+          basename,
+          spanType,
+          allRoutes
+        );
+        cleanupNavigationSpan();
+        originalEnd(endTimestamp);
+      }).catch(() => {
+        cleanupNavigationSpan();
+        originalEnd(endTimestamp);
+      });
       return;
     }
-
     tryUpdateSpanNameBeforeEnd(span, spanJson, currentName, location, routes, basename, spanType, allRoutes);
     cleanupNavigationSpan();
     originalEnd(endTimestamp);
   };
-
-  core.addNonEnumerableProperty(span , patchedPropertyName, true);
+  core.addNonEnumerableProperty(span, patchedPropertyName, true);
 }
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function createV6CompatibleWithSentryReactRouterRouting(
-  Routes,
-  version,
-) {
+function createV6CompatibleWithSentryReactRouterRouting(Routes, version) {
   if (!_useEffect || !_useLocation || !_useNavigationType || !_createRoutesFromChildren || !_matchRoutes) {
-    debugBuild.DEBUG_BUILD &&
-      core.debug.warn(`reactRouterV6Instrumentation was unable to wrap Routes because of one or more missing parameters.
+    debugBuild.DEBUG_BUILD && core.debug.warn(`reactRouterV6Instrumentation was unable to wrap Routes because of one or more missing parameters.
       useEffect: ${_useEffect}. useLocation: ${_useLocation}. useNavigationType: ${_useNavigationType}.
       createRoutesFromChildren: ${_createRoutesFromChildren}. matchRoutes: ${_matchRoutes}.`);
-
     return Routes;
   }
-
   const SentryRoutes = (props) => {
     const isMountRenderPass = React.useRef(true);
-
     const location = _useLocation();
     const navigationType = _useNavigationType();
-
     _useEffect(
       () => {
-        const routes = _createRoutesFromChildren(props.children) ;
-
+        const routes = _createRoutesFromChildren(props.children);
         if (isMountRenderPass.current) {
           addRoutesToAllRoutes(routes);
-
           updatePageloadTransaction({
             activeRootSpan: utils.getActiveRootSpan(),
             location,
             routes,
-            allRoutes: Array.from(allRoutes),
+            allRoutes: Array.from(allRoutes)
           });
           isMountRenderPass.current = false;
         } else {
-          // Note: Component-based routes don't support lazy route tracking via lazyRouteTimeout
-          // because React.lazy() loads happen at the component level, not the router level.
-          // Use createBrowserRouter with patchRoutesOnNavigation for lazy route tracking.
           handleNavigation({ location, routes, navigationType, version, allRoutes: Array.from(allRoutes) });
         }
       },
       // Re-run only on location/navigation changes, not children changes
-      [location, navigationType],
+      [location, navigationType]
     );
-
-    // @ts-expect-error Setting more specific React Component typing for `R` generic above
-    // will break advanced type inference done by react router params
-    return React.createElement(Routes, { ...props,} );
+    return /* @__PURE__ */ React.createElement(Routes, { ...props });
   };
-
   hoistNonReactStatics.hoistNonReactStatics(SentryRoutes, Routes);
-
-  // @ts-expect-error Setting more specific React Component typing for `R` generic above
-  // will break advanced type inference done by react router params
   return SentryRoutes;
 }