@tanstack/router-core 1.121.0-alpha.27 → 1.121.0-alpha.28

package/dist/esm/router.js

@@ -2,12 +2,13 @@ import { Store, batch } from "@tanstack/store";
 import { createMemoryHistory, createBrowserHistory, parseHref } from "@tanstack/history";
 import invariant from "tiny-invariant";
 import { pick, createControlledPromise, deepEqual, replaceEqualDeep, last, functionalUpdate } from "./utils.js";
-import { trimPath, resolvePath, cleanPath, matchPathname, trimPathRight, interpolatePath, joinPaths, trimPathLeft, parsePathname } from "./path.js";
+import { trimPath, resolvePath, cleanPath, matchPathname, trimPathRight, interpolatePath, joinPaths, trimPathLeft, parsePathname, SEGMENT_TYPE_PARAM, SEGMENT_TYPE_OPTIONAL_PARAM, SEGMENT_TYPE_WILDCARD, SEGMENT_TYPE_PATHNAME } from "./path.js";
 import { isNotFound } from "./not-found.js";
 import { setupScrollRestoration } from "./scroll-restoration.js";
 import { defaultParseSearch, defaultStringifySearch } from "./searchParams.js";
 import { rootRouteId } from "./root.js";
-import { isRedirect } from "./redirect.js";
+import { redirect, isRedirect } from "./redirect.js";
+import { createLRUCache } from "./lru-cache.js";
 function defaultSerializeError(err) {
   if (err instanceof Error) {
     const obj = {
@@ -26,9 +27,9 @@ function defaultSerializeError(err) {
 function getLocationChangeInfo(routerState) {
   const fromLocation = routerState.resolvedLocation;
   const toLocation = routerState.location;
-  const pathChanged = (fromLocation == null ? void 0 : fromLocation.pathname) !== toLocation.pathname;
-  const hrefChanged = (fromLocation == null ? void 0 : fromLocation.href) !== toLocation.href;
-  const hashChanged = (fromLocation == null ? void 0 : fromLocation.hash) !== toLocation.hash;
+  const pathChanged = fromLocation?.pathname !== toLocation.pathname;
+  const hrefChanged = fromLocation?.href !== toLocation.href;
+  const hashChanged = fromLocation?.hash !== toLocation.hash;
   return { fromLocation, toLocation, pathChanged, hrefChanged, hashChanged };
 }
 class RouterCore {
@@ -46,9 +47,7 @@ class RouterCore {
     this.isScrollRestoring = false;
     this.isScrollRestorationSetup = false;
     this.startTransition = (fn) => fn();
-    this.isShell = false;
     this.update = (newOptions) => {
-      var _a;
       if (newOptions.notFoundRoute) {
         console.warn(
           "The notFoundRoute API is deprecated and will be removed in the next major version. See https://tanstack.com/router/v1/docs/framework/react/guide/not-found-errors#migrating-from-notfoundroute for more info."
@@ -96,22 +95,18 @@ class RouterCore {
         });
         setupScrollRestoration(this);
       }
-      if (typeof window !== "undefined" && "CSS" in window && typeof ((_a = window.CSS) == null ? void 0 : _a.supports) === "function") {
+      if (typeof window !== "undefined" && "CSS" in window && typeof window.CSS?.supports === "function") {
         this.isViewTransitionTypesSupported = window.CSS.supports(
           "selector(:active-view-transition-type(a)"
         );
       }
-      if (this.latestLocation.search.__TSS_SHELL) {
-        this.isShell = true;
-      }
     };
     this.buildRouteTree = () => {
       const { routesById, routesByPath, flatRoutes } = processRouteTree({
         routeTree: this.routeTree,
         initRoute: (route, i) => {
           route.init({
-            originalIndex: i,
-            defaultSsr: this.options.defaultSsr
+            originalIndex: i
           });
         }
       });
@@ -121,8 +116,7 @@ class RouterCore {
       const notFoundRoute = this.options.notFoundRoute;
       if (notFoundRoute) {
         notFoundRoute.init({
-          originalIndex: 99999999999,
-          defaultSsr: this.options.defaultSsr
+          originalIndex: 99999999999
         });
         this.routesById[notFoundRoute.id] = notFoundRoute;
       }
@@ -156,10 +150,10 @@ class RouterCore {
         return {
           pathname,
           searchStr,
-          search: replaceEqualDeep(previousLocation == null ? void 0 : previousLocation.search, parsedSearch),
+          search: replaceEqualDeep(previousLocation?.search, parsedSearch),
           hash: hash.split("#").reverse()[0] ?? "",
           href: `${pathname}${searchStr}${hash}`,
-          state: replaceEqualDeep(previousLocation == null ? void 0 : previousLocation.state, state)
+          state: replaceEqualDeep(previousLocation?.state, state)
         };
       };
       const location = parse(locationToParse ?? this.history.location);
@@ -167,6 +161,7 @@ class RouterCore {
       if (__tempLocation && (!__tempKey || __tempKey === this.tempLocationKey)) {
         const parsedTempLocation = parse(__tempLocation);
         parsedTempLocation.state.key = location.state.key;
+        parsedTempLocation.state.__TSR_key = location.state.__TSR_key;
         delete parsedTempLocation.state.__tempLocation;
         return {
           ...parsedTempLocation,
@@ -181,7 +176,8 @@ class RouterCore {
         base: from,
         to: cleanPath(path),
         trailingSlash: this.options.trailingSlash,
-        caseSensitive: this.options.caseSensitive
+        caseSensitive: this.options.caseSensitive,
+        parseCache: this.parsePathnameCache
       });
       return resolvedPath;
     };
@@ -197,6 +193,7 @@ class RouterCore {
       }
       return this.matchRoutesInternal(pathnameOrNext, locationSearchOrOpts);
     };
+    this.parsePathnameCache = createLRUCache(1e3);
     this.getMatchedRoutes = (pathname, routePathname) => {
       return getMatchedRoutes({
         pathname,
@@ -205,50 +202,71 @@ class RouterCore {
         caseSensitive: this.options.caseSensitive,
         routesByPath: this.routesByPath,
         routesById: this.routesById,
-        flatRoutes: this.flatRoutes
+        flatRoutes: this.flatRoutes,
+        parseCache: this.parsePathnameCache
       });
     };
     this.cancelMatch = (id) => {
       const match = this.getMatch(id);
       if (!match) return;
       match.abortController.abort();
-      clearTimeout(match.pendingTimeout);
+      this.updateMatch(id, (prev) => {
+        clearTimeout(prev.pendingTimeout);
+        return {
+          ...prev,
+          pendingTimeout: void 0
+        };
+      });
     };
     this.cancelMatches = () => {
-      var _a;
-      (_a = this.state.pendingMatches) == null ? void 0 : _a.forEach((match) => {
+      this.state.pendingMatches?.forEach((match) => {
         this.cancelMatch(match.id);
       });
     };
     this.buildLocation = (opts) => {
       const build = (dest = {}) => {
-        var _a;
         const currentLocation = dest._fromLocation || this.latestLocation;
-        const allFromMatches = this.matchRoutes(currentLocation, {
+        const allCurrentLocationMatches = this.matchRoutes(currentLocation, {
           _buildLocation: true
         });
-        const lastMatch = last(allFromMatches);
+        const lastMatch = last(allCurrentLocationMatches);
         let fromPath = lastMatch.fullPath;
+        const toPath = dest.to ? this.resolvePathWithBase(fromPath, `${dest.to}`) : this.resolvePathWithBase(fromPath, ".");
+        const routeIsChanging = !!dest.to && !comparePaths(dest.to.toString(), fromPath) && !comparePaths(toPath, fromPath);
         if (dest.unsafeRelative === "path") {
           fromPath = currentLocation.pathname;
-        } else if (dest.to && dest.from) {
+        } else if (routeIsChanging && dest.from) {
           fromPath = dest.from;
-          const existingFrom = [...allFromMatches].reverse().find((d) => {
-            return d.fullPath === fromPath || d.fullPath === joinPaths([fromPath, "/"]);
-          });
-          if (!existingFrom) {
-            console.warn(`Could not find match for from: ${dest.from}`);
+          if (process.env.NODE_ENV !== "production" && dest._isNavigate) {
+            const allFromMatches = this.getMatchedRoutes(
+              dest.from,
+              void 0
+            ).matchedRoutes;
+            const matchedFrom = [...allCurrentLocationMatches].reverse().find((d) => {
+              return comparePaths(d.fullPath, fromPath);
+            });
+            const matchedCurrent = [...allFromMatches].reverse().find((d) => {
+              return comparePaths(d.fullPath, currentLocation.pathname);
+            });
+            if (!matchedFrom && !matchedCurrent) {
+              console.warn(`Could not find match for from: ${fromPath}`);
+            }
           }
         }
         const fromSearch = lastMatch.search;
         const fromParams = { ...lastMatch.params };
-        const nextTo = dest.to ? this.resolvePathWithBase(fromPath, `${dest.to}`) : fromPath;
-        let nextParams = (dest.params ?? true) === true ? fromParams : {
+        const nextTo = dest.to ? this.resolvePathWithBase(fromPath, `${dest.to}`) : this.resolvePathWithBase(fromPath, ".");
+        let nextParams = dest.params === false || dest.params === null ? {} : (dest.params ?? true) === true ? fromParams : {
           ...fromParams,
           ...functionalUpdate(dest.params, fromParams)
         };
+        const interpolatedNextTo = interpolatePath({
+          path: nextTo,
+          params: nextParams ?? {},
+          parseCache: this.parsePathnameCache
+        }).interpolatedPath;
         const destRoutes = this.matchRoutes(
-          nextTo,
+          interpolatedNextTo,
           {},
           {
             _buildLocation: true
@@ -256,21 +274,23 @@ class RouterCore {
         ).map((d) => this.looseRoutesById[d.routeId]);
         if (Object.keys(nextParams).length > 0) {
           destRoutes.map((route) => {
-            var _a2;
-            return ((_a2 = route.options.params) == null ? void 0 : _a2.stringify) ?? route.options.stringifyParams;
+            return route.options.params?.stringify ?? route.options.stringifyParams;
           }).filter(Boolean).forEach((fn) => {
             nextParams = { ...nextParams, ...fn(nextParams) };
           });
         }
         const nextPathname = interpolatePath({
+          // Use the original template path for interpolation
+          // This preserves the original parameter syntax including optional parameters
           path: nextTo,
           params: nextParams ?? {},
           leaveWildcards: false,
           leaveParams: opts.leaveParams,
-          decodeCharMap: this.pathParamsDecodeCharMap
+          decodeCharMap: this.pathParamsDecodeCharMap,
+          parseCache: this.parsePathnameCache
         }).interpolatedPath;
         let nextSearch = fromSearch;
-        if (opts._includeValidateSearch && ((_a = this.options.search) == null ? void 0 : _a.strict)) {
+        if (opts._includeValidateSearch && this.options.search?.strict) {
           let validatedSearch = {};
           destRoutes.forEach((route) => {
             try {
@@ -311,17 +331,21 @@ class RouterCore {
         };
       };
       const buildWithMatches = (dest = {}, maskedDest) => {
-        var _a;
         const next = build(dest);
         let maskedNext = maskedDest ? build(maskedDest) : void 0;
         if (!maskedNext) {
           let params = {};
-          const foundMask = (_a = this.options.routeMasks) == null ? void 0 : _a.find((d) => {
-            const match = matchPathname(this.basepath, next.pathname, {
-              to: d.from,
-              caseSensitive: false,
-              fuzzy: false
-            });
+          const foundMask = this.options.routeMasks?.find((d) => {
+            const match = matchPathname(
+              this.basepath,
+              next.pathname,
+              {
+                to: d.from,
+                caseSensitive: false,
+                fuzzy: false
+              },
+              this.parsePathnameCache
+            );
             if (match) {
               params = match;
               return true;
@@ -360,6 +384,8 @@ class RouterCore {
       const isSameState = () => {
         const ignoredProps = [
           "key",
+          // TODO: Remove in v2 - use __TSR_key instead
+          "__TSR_key",
           "__TSR_index",
           "__hashScrollIntoViewOptions"
         ];
@@ -375,7 +401,7 @@ class RouterCore {
       const isSameUrl = this.latestLocation.href === next.href;
       const previousCommitPromise = this.commitLocationPromise;
       this.commitLocationPromise = createControlledPromise(() => {
-        previousCommitPromise == null ? void 0 : previousCommitPromise.resolve();
+        previousCommitPromise?.resolve();
       });
       if (isSameUrl && isSameState()) {
         this.load();
@@ -394,7 +420,9 @@ class RouterCore {
                   ...nextHistory.state,
                   __tempKey: void 0,
                   __tempLocation: void 0,
+                  __TSR_key: void 0,
                   key: void 0
+                  // TODO: Remove in v2 - use __TSR_key instead
                 }
               }
             }
@@ -466,37 +494,58 @@ class RouterCore {
         } else {
           window.location.href = href;
         }
-        return;
+        return Promise.resolve();
       }
       return this.buildAndCommitLocation({
         ...rest,
         href,
-        to
+        to,
+        _isNavigate: true
       });
     };
     this.beforeLoad = () => {
       this.cancelMatches();
       this.latestLocation = this.parseLocation(this.latestLocation);
+      if (this.isServer) {
+        const nextLocation = this.buildLocation({
+          to: this.latestLocation.pathname,
+          search: true,
+          params: true,
+          hash: true,
+          state: true,
+          _includeValidateSearch: true
+        });
+        const normalizeUrl = (url) => {
+          try {
+            return encodeURI(decodeURI(url));
+          } catch {
+            return url;
+          }
+        };
+        if (trimPath(normalizeUrl(this.latestLocation.href)) !== trimPath(normalizeUrl(nextLocation.href))) {
+          throw redirect({ href: nextLocation.href });
+        }
+      }
       const pendingMatches = this.matchRoutes(this.latestLocation);
       this.__store.setState((s) => ({
         ...s,
         status: "pending",
+        statusCode: 200,
         isLoading: true,
         location: this.latestLocation,
         pendingMatches,
         // If a cached moved to pendingMatches, remove it from cachedMatches
-        cachedMatches: s.cachedMatches.filter((d) => {
-          return !pendingMatches.find((e) => e.id === d.id);
-        })
+        cachedMatches: s.cachedMatches.filter(
+          (d) => !pendingMatches.some((e) => e.id === d.id)
+        )
       }));
     };
     this.load = async (opts) => {
-      let redirect;
+      let redirect2;
       let notFound;
       let loadPromise;
       loadPromise = new Promise((resolve) => {
         this.startTransition(async () => {
-          var _a;
           try {
             this.beforeLoad();
             const next = this.latestLocation;
@@ -518,7 +567,7 @@ class RouterCore {
               })
             });
             await this.loadMatches({
-              sync: opts == null ? void 0 : opts.sync,
+              sync: opts?.sync,
               matches: this.state.pendingMatches,
               location: next,
               // eslint-disable-next-line @typescript-eslint/require-await
@@ -532,13 +581,13 @@ class RouterCore {
                       const previousMatches = s.matches;
                       const newMatches = s.pendingMatches || s.matches;
                       exitingMatches = previousMatches.filter(
-                        (match) => !newMatches.find((d) => d.id === match.id)
+                        (match) => !newMatches.some((d) => d.id === match.id)
                       );
                       enteringMatches = newMatches.filter(
-                        (match) => !previousMatches.find((d) => d.id === match.id)
+                        (match) => !previousMatches.some((d) => d.id === match.id)
                       );
                       stayingMatches = previousMatches.filter(
-                        (match) => newMatches.find((d) => d.id === match.id)
+                        (match) => newMatches.some((d) => d.id === match.id)
                       );
                       return {
                         ...s,
@@ -560,8 +609,7 @@ class RouterCore {
                     [stayingMatches, "onStay"]
                   ].forEach(([matches, hook]) => {
                     matches.forEach((match) => {
-                      var _a2, _b;
-                      (_b = (_a2 = this.looseRoutesById[match.routeId].options)[hook]) == null ? void 0 : _b.call(_a2, match);
+                      this.looseRoutesById[match.routeId].options[hook]?.(match);
                     });
                   });
                 });
@@ -569,10 +617,10 @@ class RouterCore {
             });
           } catch (err) {
             if (isRedirect(err)) {
-              redirect = err;
+              redirect2 = err;
               if (!this.isServer) {
                 this.navigate({
-                  ...redirect.options,
+                  ...redirect2.options,
                   replace: true,
                   ignoreBlocker: true
                 });
@@ -582,12 +630,12 @@ class RouterCore {
             }
             this.__store.setState((s) => ({
               ...s,
-              statusCode: redirect ? redirect.status : notFound ? 404 : s.matches.some((d) => d.status === "error") ? 500 : 200,
-              redirect
+              statusCode: redirect2 ? redirect2.status : notFound ? 404 : s.matches.some((d) => d.status === "error") ? 500 : 200,
+              redirect: redirect2
             }));
           }
           if (this.latestLoadPromise === loadPromise) {
-            (_a = this.commitLocationPromise) == null ? void 0 : _a.resolve();
+            this.commitLocationPromise?.resolve();
             this.latestLoadPromise = void 0;
             this.commitLocationPromise = void 0;
           }
@@ -633,31 +681,17 @@ class RouterCore {
       }
     };
     this.updateMatch = (id, updater) => {
-      var _a;
-      let updated;
-      const isPending = (_a = this.state.pendingMatches) == null ? void 0 : _a.find((d) => d.id === id);
-      const isMatched = this.state.matches.find((d) => d.id === id);
-      const isCached = this.state.cachedMatches.find((d) => d.id === id);
-      const matchesKey = isPending ? "pendingMatches" : isMatched ? "matches" : isCached ? "cachedMatches" : "";
+      const matchesKey = this.state.pendingMatches?.some((d) => d.id === id) ? "pendingMatches" : this.state.matches.some((d) => d.id === id) ? "matches" : this.state.cachedMatches.some((d) => d.id === id) ? "cachedMatches" : "";
       if (matchesKey) {
-        this.__store.setState((s) => {
-          var _a2;
-          return {
-            ...s,
-            [matchesKey]: (_a2 = s[matchesKey]) == null ? void 0 : _a2.map(
-              (d) => d.id === id ? updated = updater(d) : d
-            )
-          };
-        });
+        this.__store.setState((s) => ({
+          ...s,
+          [matchesKey]: s[matchesKey]?.map((d) => d.id === id ? updater(d) : d)
+        }));
       }
-      return updated;
     };
     this.getMatch = (matchId) => {
-      return [
-        ...this.state.cachedMatches,
-        ...this.state.pendingMatches ?? [],
-        ...this.state.matches
-      ].find((d) => d.id === matchId);
+      const findFn = (d) => d.id === matchId;
+      return this.state.cachedMatches.find(findFn) ?? this.state.pendingMatches?.find(findFn) ?? this.state.matches.find(findFn);
     };
     this.loadMatches = async ({
       location,
@@ -672,14 +706,16 @@ class RouterCore {
       const triggerOnReady = async () => {
         if (!rendered) {
           rendered = true;
-          await (onReady == null ? void 0 : onReady());
+          await onReady?.();
         }
       };
       const resolvePreload = (matchId) => {
-        return !!(allPreload && !this.state.matches.find((d) => d.id === matchId));
+        return !!(allPreload && !this.state.matches.some((d) => d.id === matchId));
       };
+      if (!this.isServer && this.state.matches.some((d) => d._forcePending)) {
+        triggerOnReady();
+      }
       const handleRedirectAndNotFound = (match, err) => {
-        var _a, _b, _c, _d;
         if (isRedirect(err) || isNotFound(err)) {
           if (isRedirect(err)) {
             if (err.redirectHandled) {
@@ -688,6 +724,8 @@ class RouterCore {
               }
             }
           }
+          match.beforeLoadPromise?.resolve();
+          match.loaderPromise?.resolve();
           updateMatch(match.id, (prev) => ({
             ...prev,
             status: isRedirect(err) ? "redirected" : isNotFound(err) ? "notFound" : "error",
@@ -699,9 +737,7 @@ class RouterCore {
           if (!err.routeId) {
             err.routeId = match.routeId;
           }
-          (_a = match.beforeLoadPromise) == null ? void 0 : _a.resolve();
-          (_b = match.loaderPromise) == null ? void 0 : _b.resolve();
-          (_c = match.loadPromise) == null ? void 0 : _c.resolve();
+          match.loadPromise?.resolve();
           if (isRedirect(err)) {
             rendered = true;
             err.options._fromLocation = location;
@@ -712,22 +748,28 @@ class RouterCore {
             this._handleNotFound(matches, err, {
               updateMatch
             });
-            (_d = this.serverSsr) == null ? void 0 : _d.onMatchSettled({
-              router: this,
-              match: this.getMatch(match.id)
-            });
             throw err;
           }
         }
       };
+      const shouldSkipLoader = (matchId) => {
+        const match = this.getMatch(matchId);
+        if (!this.isServer && match._dehydrated) {
+          return true;
+        }
+        if (this.isServer) {
+          if (match.ssr === false) {
+            return true;
+          }
+        }
+        return false;
+      };
       try {
         await new Promise((resolveAll, rejectAll) => {
           ;
           (async () => {
-            var _a, _b, _c, _d;
             try {
               const handleSerialError = (index, err, routerCode) => {
-                var _a2, _b2;
                 const { id: matchId, routeId } = matches[index];
                 const route = this.looseRoutesById[routeId];
                 if (err instanceof Promise) {
@@ -737,15 +779,14 @@ class RouterCore {
                 firstBadMatchIndex = firstBadMatchIndex ?? index;
                 handleRedirectAndNotFound(this.getMatch(matchId), err);
                 try {
-                  (_b2 = (_a2 = route.options).onError) == null ? void 0 : _b2.call(_a2, err);
+                  route.options.onError?.(err);
                 } catch (errorHandlerErr) {
                   err = errorHandlerErr;
                   handleRedirectAndNotFound(this.getMatch(matchId), err);
                 }
                 updateMatch(matchId, (prev) => {
-                  var _a3, _b3;
-                  (_a3 = prev.beforeLoadPromise) == null ? void 0 : _a3.resolve();
-                  (_b3 = prev.loadPromise) == null ? void 0 : _b3.resolve();
+                  prev.beforeLoadPromise?.resolve();
+                  prev.loadPromise?.resolve();
                   return {
                     ...prev,
                     error: err,
@@ -759,26 +800,94 @@ class RouterCore {
               };
               for (const [index, { id: matchId, routeId }] of matches.entries()) {
                 const existingMatch = this.getMatch(matchId);
-                const parentMatchId = (_a = matches[index - 1]) == null ? void 0 : _a.id;
+                const parentMatchId = matches[index - 1]?.id;
+                const parentMatch = parentMatchId ? this.getMatch(parentMatchId) : void 0;
                 const route = this.looseRoutesById[routeId];
                 const pendingMs = route.options.pendingMs ?? this.options.defaultPendingMs;
-                const shouldPending = !!(onReady && !this.isServer && !resolvePreload(matchId) && (route.options.loader || route.options.beforeLoad || routeNeedsPreload(route)) && typeof pendingMs === "number" && pendingMs !== Infinity && (route.options.pendingComponent ?? ((_b = this.options) == null ? void 0 : _b.defaultPendingComponent)));
+                if (this.isServer) {
+                  let ssr;
+                  if (this.isShell()) {
+                    ssr = matchId === rootRouteId;
+                  } else {
+                    const defaultSsr = this.options.defaultSsr ?? true;
+                    if (parentMatch?.ssr === false) {
+                      ssr = false;
+                    } else {
+                      let tempSsr;
+                      if (route.options.ssr === void 0) {
+                        tempSsr = defaultSsr;
+                      } else if (typeof route.options.ssr === "function") {
+                        let makeMaybe = function(value, error) {
+                          if (error) {
+                            return { status: "error", error };
+                          }
+                          return { status: "success", value };
+                        };
+                        const { search, params } = this.getMatch(matchId);
+                        const ssrFnContext = {
+                          search: makeMaybe(search, existingMatch.searchError),
+                          params: makeMaybe(params, existingMatch.paramsError),
+                          location,
+                          matches: matches.map((match) => ({
+                            index: match.index,
+                            pathname: match.pathname,
+                            fullPath: match.fullPath,
+                            staticData: match.staticData,
+                            id: match.id,
+                            routeId: match.routeId,
+                            search: makeMaybe(match.search, match.searchError),
+                            params: makeMaybe(match.params, match.paramsError),
+                            ssr: match.ssr
+                          }))
+                        };
+                        tempSsr = await route.options.ssr(ssrFnContext) ?? defaultSsr;
+                      } else {
+                        tempSsr = route.options.ssr;
+                      }
+                      if (tempSsr === true && parentMatch?.ssr === "data-only") {
+                        ssr = "data-only";
+                      } else {
+                        ssr = tempSsr;
+                      }
+                    }
+                  }
+                  updateMatch(matchId, (prev) => ({
+                    ...prev,
+                    ssr
+                  }));
+                }
+                if (shouldSkipLoader(matchId)) {
+                  continue;
+                }
+                const shouldPending = !!(onReady && !this.isServer && !resolvePreload(matchId) && (route.options.loader || route.options.beforeLoad || routeNeedsPreload(route)) && typeof pendingMs === "number" && pendingMs !== Infinity && (route.options.pendingComponent ?? this.options?.defaultPendingComponent));
                 let executeBeforeLoad = true;
-                if (
-                  // If we are in the middle of a load, either of these will be present
-                  // (not to be confused with `loadPromise`, which is always defined)
-                  existingMatch.beforeLoadPromise || existingMatch.loaderPromise
-                ) {
-                  if (shouldPending) {
-                    setTimeout(() => {
+                const setupPendingTimeout = () => {
+                  if (shouldPending && this.getMatch(matchId).pendingTimeout === void 0) {
+                    const pendingTimeout = setTimeout(() => {
                       try {
                         triggerOnReady();
                       } catch {
                       }
                     }, pendingMs);
+                    updateMatch(matchId, (prev) => ({
+                      ...prev,
+                      pendingTimeout
+                    }));
                   }
+                };
+                if (
+                  // If we are in the middle of a load, either of these will be present
+                  // (not to be confused with `loadPromise`, which is always defined)
+                  existingMatch.beforeLoadPromise || existingMatch.loaderPromise
+                ) {
+                  setupPendingTimeout();
                   await existingMatch.beforeLoadPromise;
-                  executeBeforeLoad = this.getMatch(matchId).status !== "success";
+                  const match = this.getMatch(matchId);
+                  if (match.status === "error") {
+                    executeBeforeLoad = true;
+                  } else if (match.preload && (match.status === "redirected" || match.status === "notFound")) {
+                    handleRedirectAndNotFound(match, match.error);
+                  }
                 }
                 if (executeBeforeLoad) {
                   try {
@@ -787,21 +896,11 @@ class RouterCore {
                       return {
                         ...prev,
                         loadPromise: createControlledPromise(() => {
-                          prevLoadPromise == null ? void 0 : prevLoadPromise.resolve();
+                          prevLoadPromise?.resolve();
                         }),
                         beforeLoadPromise: createControlledPromise()
                       };
                     });
-                    const abortController = new AbortController();
-                    let pendingTimeout;
-                    if (shouldPending) {
-                      pendingTimeout = setTimeout(() => {
-                        try {
-                          triggerOnReady();
-                        } catch {
-                        }
-                      }, pendingMs);
-                    }
                     const { paramsError, searchError } = this.getMatch(matchId);
                     if (paramsError) {
                       handleSerialError(index, paramsError, "PARSE_PARAMS");
@@ -809,15 +908,16 @@ class RouterCore {
                     if (searchError) {
                       handleSerialError(index, searchError, "VALIDATE_SEARCH");
                     }
-                    const getParentMatchContext = () => parentMatchId ? this.getMatch(parentMatchId).context : this.options.context ?? {};
+                    setupPendingTimeout();
+                    const abortController = new AbortController();
+                    const parentMatchContext = parentMatch?.context ?? this.options.context ?? {};
                     updateMatch(matchId, (prev) => ({
                       ...prev,
                       isFetching: "beforeLoad",
                       fetchCount: prev.fetchCount + 1,
                       abortController,
-                      pendingTimeout,
                       context: {
-                        ...getParentMatchContext(),
+                        ...parentMatchContext,
                         ...prev.__routeContext
                       }
                     }));
@@ -835,7 +935,7 @@ class RouterCore {
                       cause: preload ? "preload" : cause,
                       matches
                     };
-                    const beforeLoadContext = await ((_d = (_c = route.options).beforeLoad) == null ? void 0 : _d.call(_c, beforeLoadFnContext)) ?? {};
+                    const beforeLoadContext = await route.options.beforeLoad?.(beforeLoadFnContext);
                     if (isRedirect(beforeLoadContext) || isNotFound(beforeLoadContext)) {
                       handleSerialError(index, beforeLoadContext, "BEFORE_LOAD");
                     }
@@ -844,7 +944,7 @@ class RouterCore {
                         ...prev,
                         __beforeLoadContext: beforeLoadContext,
                         context: {
-                          ...getParentMatchContext(),
+                          ...parentMatchContext,
                           ...prev.__routeContext,
                           ...beforeLoadContext
                         },
@@ -855,8 +955,7 @@ class RouterCore {
                     handleSerialError(index, err, "BEFORE_LOAD");
                   }
                   updateMatch(matchId, (prev) => {
-                    var _a2;
-                    (_a2 = prev.beforeLoadPromise) == null ? void 0 : _a2.resolve();
+                    prev.beforeLoadPromise?.resolve();
                     return {
                       ...prev,
                       beforeLoadPromise: void 0,
@@ -870,18 +969,63 @@ class RouterCore {
               validResolvedMatches.forEach(({ id: matchId, routeId }, index) => {
                 matchPromises.push(
                   (async () => {
-                    const { loaderPromise: prevLoaderPromise } = this.getMatch(matchId);
                     let loaderShouldRunAsync = false;
                     let loaderIsRunningAsync = false;
-                    if (prevLoaderPromise) {
-                      await prevLoaderPromise;
+                    const route = this.looseRoutesById[routeId];
+                    const executeHead = async () => {
+                      const match = this.getMatch(matchId);
+                      if (!match) {
+                        return;
+                      }
+                      const assetContext = {
+                        matches,
+                        match,
+                        params: match.params,
+                        loaderData: match.loaderData
+                      };
+                      const headFnContent = await route.options.head?.(assetContext);
+                      const meta = headFnContent?.meta;
+                      const links = headFnContent?.links;
+                      const headScripts = headFnContent?.scripts;
+                      const styles = headFnContent?.styles;
+                      const scripts = await route.options.scripts?.(assetContext);
+                      const headers = await route.options.headers?.(assetContext);
+                      return {
+                        meta,
+                        links,
+                        headScripts,
+                        headers,
+                        scripts,
+                        styles
+                      };
+                    };
+                    const potentialPendingMinPromise = async () => {
+                      const latestMatch = this.getMatch(matchId);
+                      if (latestMatch.minPendingPromise) {
+                        await latestMatch.minPendingPromise;
+                      }
+                    };
+                    const prevMatch = this.getMatch(matchId);
+                    if (shouldSkipLoader(matchId)) {
+                      if (this.isServer) {
+                        const head = await executeHead();
+                        updateMatch(matchId, (prev) => ({
+                          ...prev,
+                          ...head
+                        }));
+                        return this.getMatch(matchId);
+                      }
+                    } else if (prevMatch.loaderPromise) {
+                      if (prevMatch.status === "success" && !sync && !prevMatch.preload) {
+                        return this.getMatch(matchId);
+                      }
+                      await prevMatch.loaderPromise;
                       const match = this.getMatch(matchId);
                       if (match.error) {
                         handleRedirectAndNotFound(match, match.error);
                       }
                     } else {
                       const parentMatchPromise = matchPromises[index - 1];
-                      const route = this.looseRoutesById[routeId];
                       const getLoaderContext = () => {
                         const {
                           params,
@@ -912,49 +1056,29 @@ class RouterCore {
                       updateMatch(matchId, (prev) => ({
                         ...prev,
                         loaderPromise: createControlledPromise(),
-                        preload: !!preload && !this.state.matches.find((d) => d.id === matchId)
+                        preload: !!preload && !this.state.matches.some((d) => d.id === matchId)
                       }));
-                      const executeHead = async () => {
-                        var _a2, _b2, _c2, _d2, _e, _f;
-                        const match = this.getMatch(matchId);
-                        if (!match) {
-                          return;
-                        }
-                        const assetContext = {
-                          matches,
-                          match,
-                          params: match.params,
-                          loaderData: match.loaderData
-                        };
-                        const headFnContent = await ((_b2 = (_a2 = route.options).head) == null ? void 0 : _b2.call(_a2, assetContext));
-                        const meta = headFnContent == null ? void 0 : headFnContent.meta;
-                        const links = headFnContent == null ? void 0 : headFnContent.links;
-                        const headScripts = headFnContent == null ? void 0 : headFnContent.scripts;
-                        const scripts = await ((_d2 = (_c2 = route.options).scripts) == null ? void 0 : _d2.call(_c2, assetContext));
-                        const headers = await ((_f = (_e = route.options).headers) == null ? void 0 : _f.call(_e, assetContext));
-                        return { meta, links, headScripts, headers, scripts };
-                      };
                       const runLoader = async () => {
-                        var _a2, _b2, _c2, _d2, _e;
                         try {
-                          const potentialPendingMinPromise = async () => {
-                            const latestMatch = this.getMatch(matchId);
-                            if (latestMatch.minPendingPromise) {
-                              await latestMatch.minPendingPromise;
-                            }
-                          };
                           try {
-                            this.loadRouteChunk(route);
+                            if (!this.isServer || this.isServer && this.getMatch(matchId).ssr === true) {
+                              this.loadRouteChunk(route);
+                            }
                             updateMatch(matchId, (prev) => ({
                               ...prev,
                               isFetching: "loader"
                             }));
-                            const loaderData = await ((_b2 = (_a2 = route.options).loader) == null ? void 0 : _b2.call(_a2, getLoaderContext()));
+                            const loaderData = await route.options.loader?.(getLoaderContext());
                             handleRedirectAndNotFound(
                               this.getMatch(matchId),
                               loaderData
                             );
+                            updateMatch(matchId, (prev) => ({
+                              ...prev,
+                              loaderData
+                            }));
                             await route._lazyPromise;
+                            const head = await executeHead();
                             await potentialPendingMinPromise();
                             await route._componentsPromise;
                             updateMatch(matchId, (prev) => ({
@@ -963,11 +1087,6 @@ class RouterCore {
                               status: "success",
                               isFetching: false,
                               updatedAt: Date.now(),
-                              loaderData
-                            }));
-                            const head = await executeHead();
-                            updateMatch(matchId, (prev) => ({
-                              ...prev,
                               ...head
                             }));
                           } catch (e) {
@@ -975,7 +1094,7 @@ class RouterCore {
                             await potentialPendingMinPromise();
                             handleRedirectAndNotFound(this.getMatch(matchId), e);
                             try {
-                              (_d2 = (_c2 = route.options).onError) == null ? void 0 : _d2.call(_c2, e);
+                              route.options.onError?.(e);
                             } catch (onErrorError) {
                               error = onErrorError;
                               handleRedirectAndNotFound(
@@ -992,10 +1111,6 @@ class RouterCore {
                               ...head
                             }));
                           }
-                          (_e = this.serverSsr) == null ? void 0 : _e.onMatchSettled({
-                            router: this,
-                            match: this.getMatch(matchId)
-                          });
                         } catch (err) {
                           const head = await executeHead();
                           updateMatch(matchId, (prev) => ({
@@ -1015,8 +1130,8 @@ class RouterCore {
                           try {
                             await runLoader();
                             const { loaderPromise, loadPromise } = this.getMatch(matchId);
-                            loaderPromise == null ? void 0 : loaderPromise.resolve();
-                            loadPromise == null ? void 0 : loadPromise.resolve();
+                            loaderPromise?.resolve();
+                            loadPromise?.resolve();
                             updateMatch(matchId, (prev) => ({
                               ...prev,
                               loaderPromise: void 0
@@ -1039,15 +1154,20 @@ class RouterCore {
                     }
                     if (!loaderIsRunningAsync) {
                       const { loaderPromise, loadPromise } = this.getMatch(matchId);
-                      loaderPromise == null ? void 0 : loaderPromise.resolve();
-                      loadPromise == null ? void 0 : loadPromise.resolve();
+                      loaderPromise?.resolve();
+                      loadPromise?.resolve();
                     }
-                    updateMatch(matchId, (prev) => ({
-                      ...prev,
-                      isFetching: loaderIsRunningAsync ? prev.isFetching : false,
-                      loaderPromise: loaderIsRunningAsync ? prev.loaderPromise : void 0,
-                      invalid: false
-                    }));
+                    updateMatch(matchId, (prev) => {
+                      clearTimeout(prev.pendingTimeout);
+                      return {
+                        ...prev,
+                        isFetching: loaderIsRunningAsync ? prev.isFetching : false,
+                        loaderPromise: loaderIsRunningAsync ? prev.loaderPromise : void 0,
+                        invalid: false,
+                        pendingTimeout: void 0,
+                        _dehydrated: void 0
+                      };
+                    });
                     return this.getMatch(matchId);
                   })()
                 );
@@ -1072,40 +1192,36 @@ class RouterCore {
     };
     this.invalidate = (opts) => {
       const invalidate = (d) => {
-        var _a;
-        if (((_a = opts == null ? void 0 : opts.filter) == null ? void 0 : _a.call(opts, d)) ?? true) {
+        if (opts?.filter?.(d) ?? true) {
           return {
             ...d,
             invalid: true,
-            ...d.status === "error" ? { status: "pending", error: void 0 } : {}
+            ...opts?.forcePending || d.status === "error" ? { status: "pending", error: void 0 } : {}
           };
         }
         return d;
       };
-      this.__store.setState((s) => {
-        var _a;
-        return {
-          ...s,
-          matches: s.matches.map(invalidate),
-          cachedMatches: s.cachedMatches.map(invalidate),
-          pendingMatches: (_a = s.pendingMatches) == null ? void 0 : _a.map(invalidate)
-        };
-      });
+      this.__store.setState((s) => ({
+        ...s,
+        matches: s.matches.map(invalidate),
+        cachedMatches: s.cachedMatches.map(invalidate),
+        pendingMatches: s.pendingMatches?.map(invalidate)
+      }));
       this.shouldViewTransition = false;
-      return this.load({ sync: opts == null ? void 0 : opts.sync });
+      return this.load({ sync: opts?.sync });
     };
-    this.resolveRedirect = (redirect) => {
-      if (!redirect.options.href) {
-        redirect.options.href = this.buildLocation(redirect.options).href;
-        redirect.headers.set("Location", redirect.options.href);
+    this.resolveRedirect = (redirect2) => {
+      if (!redirect2.options.href) {
+        redirect2.options.href = this.buildLocation(redirect2.options).href;
+        redirect2.headers.set("Location", redirect2.options.href);
       }
-      if (!redirect.headers.get("Location")) {
-        redirect.headers.set("Location", redirect.options.href);
+      if (!redirect2.headers.get("Location")) {
+        redirect2.headers.set("Location", redirect2.options.href);
       }
-      return redirect;
+      return redirect2;
     };
     this.clearCache = (opts) => {
-      const filter = opts == null ? void 0 : opts.filter;
+      const filter = opts?.filter;
       if (filter !== void 0) {
         this.__store.setState((s) => {
           return {
@@ -1131,7 +1247,10 @@ class RouterCore {
           return true;
         }
         const gcTime = (d.preload ? route.options.preloadGcTime ?? this.options.defaultPreloadGcTime : route.options.gcTime ?? this.options.defaultGcTime) ?? 5 * 60 * 1e3;
-        return !(d.status !== "error" && Date.now() - d.updatedAt < gcTime);
+        const isError = d.status === "error";
+        if (isError) return true;
+        const gcEligible = Date.now() - d.updatedAt >= gcTime;
+        return gcEligible;
       };
       this.clearCache({ filter });
     };
@@ -1151,7 +1270,7 @@ class RouterCore {
           () => Promise.all(
             componentTypes.map(async (type) => {
               const component = route.options[type];
-              if (component == null ? void 0 : component.preload) {
+              if (component?.preload) {
                 await component.preload();
               }
             })
@@ -1227,15 +1346,20 @@ class RouterCore {
         leaveParams: true
       };
       const next = this.buildLocation(matchLocation);
-      if ((opts == null ? void 0 : opts.pending) && this.state.status !== "pending") {
+      if (opts?.pending && this.state.status !== "pending") {
         return false;
       }
-      const pending = (opts == null ? void 0 : opts.pending) === void 0 ? !this.state.isLoading : opts.pending;
+      const pending = opts?.pending === void 0 ? !this.state.isLoading : opts.pending;
       const baseLocation = pending ? this.latestLocation : this.state.resolvedLocation || this.state.location;
-      const match = matchPathname(this.basepath, baseLocation.pathname, {
-        ...opts,
-        to: next.pathname
-      });
+      const match = matchPathname(
+        this.basepath,
+        baseLocation.pathname,
+        {
+          ...opts,
+          to: next.pathname
+        },
+        this.parsePathnameCache
+      );
       if (!match) {
         return false;
       }
@@ -1244,7 +1368,7 @@ class RouterCore {
           return false;
         }
       }
-      if (match && ((opts == null ? void 0 : opts.includeSearch) ?? true)) {
+      if (match && (opts?.includeSearch ?? true)) {
         return deepEqual(baseLocation.search, next.search, { partial: true }) ? match : false;
       }
       return match;
@@ -1252,13 +1376,12 @@ class RouterCore {
     this._handleNotFound = (matches, err, {
       updateMatch = this.updateMatch
     } = {}) => {
-      var _a;
       const routeCursor = this.routesById[err.routeId ?? ""] ?? this.routeTree;
       const matchesByRouteId = {};
       for (const match of matches) {
         matchesByRouteId[match.routeId] = match;
       }
-      if (!routeCursor.options.notFoundComponent && ((_a = this.options) == null ? void 0 : _a.defaultNotFoundComponent)) {
+      if (!routeCursor.options.notFoundComponent && this.options?.defaultNotFoundComponent) {
         routeCursor.options.notFoundComponent = this.options.defaultNotFoundComponent;
       }
       invariant(
@@ -1300,9 +1423,15 @@ class RouterCore {
       parseSearch: options.parseSearch ?? defaultParseSearch
     });
     if (typeof document !== "undefined") {
-      window.__TSR_ROUTER__ = this;
+      self.__TSR_ROUTER__ = this;
     }
   }
+  isShell() {
+    return !!this.options.isShell;
+  }
+  isPrerendering() {
+    return !!this.options.isPrerendering;
+  }
   get state() {
     return this.__store.state;
   }
@@ -1310,10 +1439,9 @@ class RouterCore {
     return this.routesById;
   }
   matchRoutesInternal(next, opts) {
-    var _a;
     const { foundRoute, matchedRoutes, routeParams } = this.getMatchedRoutes(
       next.pathname,
-      (_a = opts == null ? void 0 : opts.dest) == null ? void 0 : _a.to
+      opts?.dest?.to
     );
     let isGlobalNotFound = false;
     if (
@@ -1344,9 +1472,8 @@ class RouterCore {
       return rootRouteId;
     })();
     const parseErrors = matchedRoutes.map((route) => {
-      var _a2;
       let parsedParamsError;
-      const parseParams = ((_a2 = route.options.params) == null ? void 0 : _a2.parse) ?? route.options.parseParams;
+      const parseParams = route.options.params?.parse ?? route.options.parseParams;
       if (parseParams) {
         try {
           const parsedParams = parseParams(routeParams);
@@ -1355,7 +1482,7 @@ class RouterCore {
           parsedParamsError = new PathParamError(err.message, {
             cause: err
           });
-          if (opts == null ? void 0 : opts.throwOnError) {
+          if (opts?.throwOnError) {
             throw parsedParamsError;
           }
           return parsedParamsError;
@@ -1365,16 +1492,15 @@ class RouterCore {
     });
     const matches = [];
     const getParentContext = (parentMatch) => {
-      const parentMatchId = parentMatch == null ? void 0 : parentMatch.id;
+      const parentMatchId = parentMatch?.id;
       const parentContext = !parentMatchId ? this.options.context ?? {} : parentMatch.context ?? this.options.context ?? {};
       return parentContext;
     };
     matchedRoutes.forEach((route, index) => {
-      var _a2, _b;
       const parentMatch = matches[index - 1];
       const [preMatchSearch, strictMatchSearch, searchError] = (() => {
-        const parentSearch = (parentMatch == null ? void 0 : parentMatch.search) ?? next.search;
-        const parentStrictSearch = (parentMatch == null ? void 0 : parentMatch._strictSearch) ?? {};
+        const parentSearch = parentMatch?.search ?? next.search;
+        const parentStrictSearch = parentMatch?._strictSearch ?? {};
         try {
           const strictSearch = validateSearch(route.options.validateSearch, { ...parentSearch }) ?? {};
           return [
@@ -1392,15 +1518,15 @@ class RouterCore {
               cause: err
             });
           }
-          if (opts == null ? void 0 : opts.throwOnError) {
+          if (opts?.throwOnError) {
             throw searchParamError;
           }
           return [parentSearch, {}, searchParamError];
         }
       })();
-      const loaderDeps = ((_b = (_a2 = route.options).loaderDeps) == null ? void 0 : _b.call(_a2, {
+      const loaderDeps = route.options.loaderDeps?.({
         search: preMatchSearch
-      })) ?? "";
+      }) ?? "";
       const loaderDepsHash = loaderDeps ? JSON.stringify(loaderDeps) : "";
       const { usedParams, interpolatedPath } = interpolatePath({
         path: route.fullPath,
@@ -1411,7 +1537,8 @@ class RouterCore {
         path: route.id,
         params: routeParams,
         leaveWildcards: true,
-        decodeCharMap: this.pathParamsDecodeCharMap
+        decodeCharMap: this.pathParamsDecodeCharMap,
+        parseCache: this.parsePathnameCache
       }).interpolatedPath + loaderDepsHash;
       const existingMatch = this.getMatch(matchId);
       const previousMatch = this.state.matches.find(
@@ -1446,7 +1573,7 @@ class RouterCore {
           error: void 0,
           paramsError: parseErrors[index],
           __routeContext: {},
-          __beforeLoadContext: {},
+          __beforeLoadContext: void 0,
           context: {},
           abortController: new AbortController(),
           fetchCount: 0,
@@ -1463,7 +1590,7 @@ class RouterCore {
           fullPath: route.fullPath
         };
       }
-      if (!(opts == null ? void 0 : opts.preload)) {
+      if (!opts?.preload) {
         match.globalNotFound = globalNotFoundRouteId === route.id;
       }
       match.searchError = searchError;
@@ -1476,10 +1603,9 @@ class RouterCore {
       matches.push(match);
     });
     matches.forEach((match, index) => {
-      var _a2, _b;
       const route = this.looseRoutesById[match.routeId];
       const existingMatch = this.getMatch(match.id);
-      if (!existingMatch && (opts == null ? void 0 : opts._buildLocation) !== true) {
+      if (!existingMatch && opts?._buildLocation !== true) {
         const parentMatch = matches[index - 1];
         const parentContext = getParentContext(parentMatch);
         const contextFnContext = {
@@ -1494,7 +1620,7 @@ class RouterCore {
           preload: !!match.preload,
           matches
         };
-        match.__routeContext = ((_b = (_a2 = route.options).context) == null ? void 0 : _b.call(_a2, contextFnContext)) ?? {};
+        match.__routeContext = route.options.context?.(contextFnContext) ?? {};
         match.context = {
           ...parentContext,
           ...match.__routeContext,
@@ -1509,6 +1635,10 @@ class SearchParamError extends Error {
 }
 class PathParamError extends Error {
 }
+const normalize = (str) => str.endsWith("/") && str.length > 1 ? str.slice(0, -1) : str;
+function comparePaths(a, b) {
+  return normalize(a) === normalize(b);
+}
 function lazyFn(fn, key) {
   return async (...args) => {
     const imported = await fn();
@@ -1556,14 +1686,33 @@ const componentTypes = [
   "notFoundComponent"
 ];
 function routeNeedsPreload(route) {
-  var _a;
   for (const componentType of componentTypes) {
-    if ((_a = route.options[componentType]) == null ? void 0 : _a.preload) {
+    if (route.options[componentType]?.preload) {
       return true;
     }
   }
   return false;
 }
+const REQUIRED_PARAM_BASE_SCORE = 0.5;
+const OPTIONAL_PARAM_BASE_SCORE = 0.4;
+const WILDCARD_PARAM_BASE_SCORE = 0.25;
+const BOTH_PRESENCE_BASE_SCORE = 0.05;
+const PREFIX_PRESENCE_BASE_SCORE = 0.02;
+const SUFFIX_PRESENCE_BASE_SCORE = 0.01;
+const PREFIX_LENGTH_SCORE_MULTIPLIER = 2e-4;
+const SUFFIX_LENGTH_SCORE_MULTIPLIER = 1e-4;
+function handleParam(segment, baseScore) {
+  if (segment.prefixSegment && segment.suffixSegment) {
+    return baseScore + BOTH_PRESENCE_BASE_SCORE + PREFIX_LENGTH_SCORE_MULTIPLIER * segment.prefixSegment.length + SUFFIX_LENGTH_SCORE_MULTIPLIER * segment.suffixSegment.length;
+  }
+  if (segment.prefixSegment) {
+    return baseScore + PREFIX_PRESENCE_BASE_SCORE + PREFIX_LENGTH_SCORE_MULTIPLIER * segment.prefixSegment.length;
+  }
+  if (segment.suffixSegment) {
+    return baseScore + SUFFIX_PRESENCE_BASE_SCORE + SUFFIX_LENGTH_SCORE_MULTIPLIER * segment.suffixSegment.length;
+  }
+  return baseScore;
+}
 function processRouteTree({
   routeTree,
   initRoute
@@ -1572,7 +1721,7 @@ function processRouteTree({
   const routesByPath = {};
   const recurseRoutes = (childRoutes) => {
     childRoutes.forEach((childRoute, i) => {
-      initRoute == null ? void 0 : initRoute(childRoute, i);
+      initRoute?.(childRoute, i);
       const existingRoute = routesById[childRoute.id];
       invariant(
         !existingRoute,
@@ -1586,7 +1735,7 @@ function processRouteTree({
         }
       }
       const children = childRoute.children;
-      if (children == null ? void 0 : children.length) {
+      if (children?.length) {
         recurseRoutes(children);
       }
     });
@@ -1595,46 +1744,52 @@ function processRouteTree({
   const scoredRoutes = [];
   const routes = Object.values(routesById);
   routes.forEach((d, i) => {
-    var _a;
     if (d.isRoot || !d.path) {
       return;
     }
     const trimmed = trimPathLeft(d.fullPath);
-    const parsed = parsePathname(trimmed);
-    while (parsed.length > 1 && ((_a = parsed[0]) == null ? void 0 : _a.value) === "/") {
-      parsed.shift();
+    let parsed = parsePathname(trimmed);
+    let skip = 0;
+    while (parsed.length > skip + 1 && parsed[skip]?.value === "/") {
+      skip++;
     }
-    const scores = parsed.map((segment) => {
+    if (skip > 0) parsed = parsed.slice(skip);
+    let optionalParamCount = 0;
+    let hasStaticAfter = false;
+    const scores = parsed.map((segment, index) => {
       if (segment.value === "/") {
         return 0.75;
       }
-      if (segment.type === "param" && segment.prefixSegment && segment.suffixSegment) {
-        return 0.55;
-      }
-      if (segment.type === "param" && segment.prefixSegment) {
-        return 0.52;
+      let baseScore = void 0;
+      if (segment.type === SEGMENT_TYPE_PARAM) {
+        baseScore = REQUIRED_PARAM_BASE_SCORE;
+      } else if (segment.type === SEGMENT_TYPE_OPTIONAL_PARAM) {
+        baseScore = OPTIONAL_PARAM_BASE_SCORE;
+        optionalParamCount++;
+      } else if (segment.type === SEGMENT_TYPE_WILDCARD) {
+        baseScore = WILDCARD_PARAM_BASE_SCORE;
       }
-      if (segment.type === "param" && segment.suffixSegment) {
-        return 0.51;
-      }
-      if (segment.type === "param") {
-        return 0.5;
-      }
-      if (segment.type === "wildcard" && segment.prefixSegment && segment.suffixSegment) {
-        return 0.3;
-      }
-      if (segment.type === "wildcard" && segment.prefixSegment) {
-        return 0.27;
-      }
-      if (segment.type === "wildcard" && segment.suffixSegment) {
-        return 0.26;
-      }
-      if (segment.type === "wildcard") {
-        return 0.25;
+      if (baseScore) {
+        for (let i2 = index + 1; i2 < parsed.length; i2++) {
+          const nextSegment = parsed[i2];
+          if (nextSegment.type === SEGMENT_TYPE_PATHNAME && nextSegment.value !== "/") {
+            hasStaticAfter = true;
+            return handleParam(segment, baseScore + 0.2);
+          }
+        }
+        return handleParam(segment, baseScore);
       }
       return 1;
     });
-    scoredRoutes.push({ child: d, trimmed, parsed, index: i, scores });
+    scoredRoutes.push({
+      child: d,
+      trimmed,
+      parsed,
+      index: i,
+      scores,
+      optionalParamCount,
+      hasStaticAfter
+    });
   });
   const flatRoutes = scoredRoutes.sort((a, b) => {
     const minLength = Math.min(a.scores.length, b.scores.length);
@@ -1644,6 +1799,15 @@ function processRouteTree({
       }
     }
     if (a.scores.length !== b.scores.length) {
+      if (a.optionalParamCount !== b.optionalParamCount) {
+        if (a.hasStaticAfter === b.hasStaticAfter) {
+          return a.optionalParamCount - b.optionalParamCount;
+        } else if (a.hasStaticAfter && !b.hasStaticAfter) {
+          return -1;
+        } else if (!a.hasStaticAfter && b.hasStaticAfter) {
+          return 1;
+        }
+      }
       return b.scores.length - a.scores.length;
     }
     for (let i = 0; i < minLength; i++) {
@@ -1665,38 +1829,56 @@ function getMatchedRoutes({
   caseSensitive,
   routesByPath,
   routesById,
-  flatRoutes
+  flatRoutes,
+  parseCache
 }) {
   let routeParams = {};
   const trimmedPath = trimPathRight(pathname);
   const getMatchedParams = (route) => {
-    var _a;
-    const result = matchPathname(basepath, trimmedPath, {
-      to: route.fullPath,
-      caseSensitive: ((_a = route.options) == null ? void 0 : _a.caseSensitive) ?? caseSensitive,
-      fuzzy: true
-    });
+    const result = matchPathname(
+      basepath,
+      trimmedPath,
+      {
+        to: route.fullPath,
+        caseSensitive: route.options?.caseSensitive ?? caseSensitive,
+        // we need fuzzy matching for `notFoundMode: 'fuzzy'`
+        fuzzy: true
+      },
+      parseCache
+    );
     return result;
   };
   let foundRoute = routePathname !== void 0 ? routesByPath[routePathname] : void 0;
   if (foundRoute) {
     routeParams = getMatchedParams(foundRoute);
   } else {
-    foundRoute = flatRoutes.find((route) => {
+    let fuzzyMatch = void 0;
+    for (const route of flatRoutes) {
       const matchedParams = getMatchedParams(route);
       if (matchedParams) {
-        routeParams = matchedParams;
-        return true;
+        if (route.path !== "/" && matchedParams["**"]) {
+          if (!fuzzyMatch) {
+            fuzzyMatch = { foundRoute: route, routeParams: matchedParams };
+          }
+        } else {
+          foundRoute = route;
+          routeParams = matchedParams;
+          break;
+        }
       }
-      return false;
-    });
+    }
+    if (!foundRoute && fuzzyMatch) {
+      foundRoute = fuzzyMatch.foundRoute;
+      routeParams = fuzzyMatch.routeParams;
+    }
   }
   let routeCursor = foundRoute || routesById[rootRouteId];
   const matchedRoutes = [routeCursor];
   while (routeCursor.parentRoute) {
     routeCursor = routeCursor.parentRoute;
-    matchedRoutes.unshift(routeCursor);
+    matchedRoutes.push(routeCursor);
   }
+  matchedRoutes.reverse();
   return { matchedRoutes, routeParams, foundRoute };
 }
 function applySearchMiddleware({
@@ -1707,10 +1889,9 @@ function applySearchMiddleware({
 }) {
   const allMiddlewares = destRoutes.reduce(
     (acc, route) => {
-      var _a;
       const middlewares = [];
       if ("search" in route.options) {
-        if ((_a = route.options.search) == null ? void 0 : _a.middlewares) {
+        if (route.options.search?.middlewares) {
           middlewares.push(...route.options.search.middlewares);
         }
       } else if (route.options.preSearchFilters || route.options.postSearchFilters) {