@tanstack/router-core 1.120.7 → 1.121.0-alpha.11

package/dist/cjs/router.cjs

@@ -48,6 +48,7 @@ class RouterCore {
     this.isScrollRestoring = false;
     this.isScrollRestorationSetup = false;
     this.startTransition = (fn) => fn();
+    this.isShell = false;
     this.update = (newOptions) => {
       var _a;
       if (newOptions.notFoundRoute) {
@@ -74,10 +75,7 @@ class RouterCore {
           this.basepath = `/${path.trimPath(newOptions.basepath)}`;
         }
       }
-      if (
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        !this.history || this.options.history && this.options.history !== this.history
-      ) {
+      if (!this.history || this.options.history && this.options.history !== this.history) {
         this.history = this.options.history ?? (this.isServer ? history.createMemoryHistory({
           initialEntries: [this.basepath || "/"]
         }) : history.createBrowserHistory());
@@ -100,16 +98,28 @@ class RouterCore {
         });
         scrollRestoration.setupScrollRestoration(this);
       }
-      if (typeof window !== "undefined" && "CSS" in window && // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      typeof ((_a = window.CSS) == null ? void 0 : _a.supports) === "function") {
+      if (typeof window !== "undefined" && "CSS" in window && typeof ((_a = window.CSS) == null ? void 0 : _a.supports) === "function") {
         this.isViewTransitionTypesSupported = window.CSS.supports(
           "selector(:active-view-transition-type(a)"
         );
       }
+      if (this.latestLocation.search.__TSS_SHELL) {
+        this.isShell = true;
+      }
     };
     this.buildRouteTree = () => {
-      this.routesById = {};
-      this.routesByPath = {};
+      const { routesById, routesByPath, flatRoutes } = processRouteTree({
+        routeTree: this.routeTree,
+        initRoute: (route, i) => {
+          route.init({
+            originalIndex: i,
+            defaultSsr: this.options.defaultSsr
+          });
+        }
+      });
+      this.routesById = routesById;
+      this.routesByPath = routesByPath;
+      this.flatRoutes = flatRoutes;
       const notFoundRoute = this.options.notFoundRoute;
       if (notFoundRoute) {
         notFoundRoute.init({
@@ -118,77 +128,6 @@ class RouterCore {
         });
         this.routesById[notFoundRoute.id] = notFoundRoute;
       }
-      const recurseRoutes = (childRoutes) => {
-        childRoutes.forEach((childRoute, i) => {
-          childRoute.init({
-            originalIndex: i,
-            defaultSsr: this.options.defaultSsr
-          });
-          const existingRoute = this.routesById[childRoute.id];
-          invariant(
-            !existingRoute,
-            `Duplicate routes found with id: ${String(childRoute.id)}`
-          );
-          this.routesById[childRoute.id] = childRoute;
-          if (!childRoute.isRoot && childRoute.path) {
-            const trimmedFullPath = path.trimPathRight(childRoute.fullPath);
-            if (!this.routesByPath[trimmedFullPath] || childRoute.fullPath.endsWith("/")) {
-              this.routesByPath[trimmedFullPath] = childRoute;
-            }
-          }
-          const children = childRoute.children;
-          if (children == null ? void 0 : children.length) {
-            recurseRoutes(children);
-          }
-        });
-      };
-      recurseRoutes([this.routeTree]);
-      const scoredRoutes = [];
-      const routes = Object.values(this.routesById);
-      routes.forEach((d, i) => {
-        var _a;
-        if (d.isRoot || !d.path) {
-          return;
-        }
-        const trimmed = path.trimPathLeft(d.fullPath);
-        const parsed = path.parsePathname(trimmed);
-        while (parsed.length > 1 && ((_a = parsed[0]) == null ? void 0 : _a.value) === "/") {
-          parsed.shift();
-        }
-        const scores = parsed.map((segment) => {
-          if (segment.value === "/") {
-            return 0.75;
-          }
-          if (segment.type === "param") {
-            return 0.5;
-          }
-          if (segment.type === "wildcard") {
-            return 0.25;
-          }
-          return 1;
-        });
-        scoredRoutes.push({ child: d, trimmed, parsed, index: i, scores });
-      });
-      this.flatRoutes = scoredRoutes.sort((a, b) => {
-        const minLength = Math.min(a.scores.length, b.scores.length);
-        for (let i = 0; i < minLength; i++) {
-          if (a.scores[i] !== b.scores[i]) {
-            return b.scores[i] - a.scores[i];
-          }
-        }
-        if (a.scores.length !== b.scores.length) {
-          return b.scores.length - a.scores.length;
-        }
-        for (let i = 0; i < minLength; i++) {
-          if (a.parsed[i].value !== b.parsed[i].value) {
-            return a.parsed[i].value > b.parsed[i].value ? 1 : -1;
-          }
-        }
-        return a.index - b.index;
-      }).map((d, i) => {
-        d.child.rank = i;
-        return d.child;
-      });
     };
     this.subscribe = (eventType, fn) => {
       const listener = {
@@ -257,41 +196,19 @@ class RouterCore {
           },
           opts
         );
-      } else {
-        return this.matchRoutesInternal(pathnameOrNext, locationSearchOrOpts);
       }
+      return this.matchRoutesInternal(pathnameOrNext, locationSearchOrOpts);
     };
-    this.getMatchedRoutes = (next, dest) => {
-      let routeParams = {};
-      const trimmedPath = path.trimPathRight(next.pathname);
-      const getMatchedParams = (route) => {
-        const result = path.matchPathname(this.basepath, trimmedPath, {
-          to: route.fullPath,
-          caseSensitive: route.options.caseSensitive ?? this.options.caseSensitive,
-          fuzzy: true
-        });
-        return result;
-      };
-      let foundRoute = (dest == null ? void 0 : dest.to) !== void 0 ? this.routesByPath[dest.to] : void 0;
-      if (foundRoute) {
-        routeParams = getMatchedParams(foundRoute);
-      } else {
-        foundRoute = this.flatRoutes.find((route) => {
-          const matchedParams = getMatchedParams(route);
-          if (matchedParams) {
-            routeParams = matchedParams;
-            return true;
-          }
-          return false;
-        });
-      }
-      let routeCursor = foundRoute || this.routesById[root.rootRouteId];
-      const matchedRoutes = [routeCursor];
-      while (routeCursor.parentRoute) {
-        routeCursor = routeCursor.parentRoute;
-        matchedRoutes.unshift(routeCursor);
-      }
-      return { matchedRoutes, routeParams, foundRoute };
+    this.getMatchedRoutes = (pathname, routePathname) => {
+      return getMatchedRoutes({
+        pathname,
+        routePathname,
+        basepath: this.basepath,
+        caseSensitive: this.options.caseSensitive,
+        routesByPath: this.routesByPath,
+        routesById: this.routesById,
+        flatRoutes: this.flatRoutes
+      });
     };
     this.cancelMatch = (id) => {
       const match = this.getMatch(id);
@@ -306,173 +223,92 @@ class RouterCore {
       });
     };
     this.buildLocation = (opts) => {
-      const build = (dest = {}, matchedRoutesResult) => {
-        var _a, _b, _c, _d, _e, _f, _g;
-        const fromMatches = dest._fromLocation ? this.matchRoutes(dest._fromLocation, { _buildLocation: true }) : this.state.matches;
-        const fromMatch = dest.from != null ? fromMatches.find(
-          (d) => path.matchPathname(this.basepath, path.trimPathRight(d.pathname), {
-            to: dest.from,
-            caseSensitive: false,
-            fuzzy: false
-          })
-        ) : void 0;
-        const fromPath = (fromMatch == null ? void 0 : fromMatch.pathname) || this.latestLocation.pathname;
-        invariant(
-          dest.from == null || fromMatch != null,
-          "Could not find match for from: " + dest.from
-        );
-        const fromSearch = ((_a = this.state.pendingMatches) == null ? void 0 : _a.length) ? (_b = utils.last(this.state.pendingMatches)) == null ? void 0 : _b.search : ((_c = utils.last(fromMatches)) == null ? void 0 : _c.search) || this.latestLocation.search;
-        const stayingMatches = matchedRoutesResult == null ? void 0 : matchedRoutesResult.matchedRoutes.filter(
-          (d) => fromMatches.find((e) => e.routeId === d.id)
-        );
-        let pathname;
-        if (dest.to) {
-          const resolvePathTo = (fromMatch == null ? void 0 : fromMatch.fullPath) || ((_d = utils.last(fromMatches)) == null ? void 0 : _d.fullPath) || this.latestLocation.pathname;
-          pathname = this.resolvePathWithBase(resolvePathTo, `${dest.to}`);
-        } else {
-          const fromRouteByFromPathRouteId = this.routesById[(_e = stayingMatches == null ? void 0 : stayingMatches.find((route) => {
-            const interpolatedPath = path.interpolatePath({
-              path: route.fullPath,
-              params: (matchedRoutesResult == null ? void 0 : matchedRoutesResult.routeParams) ?? {},
-              decodeCharMap: this.pathParamsDecodeCharMap
-            }).interpolatedPath;
-            const pathname2 = path.joinPaths([this.basepath, interpolatedPath]);
-            return pathname2 === fromPath;
-          })) == null ? void 0 : _e.id];
-          pathname = this.resolvePathWithBase(
-            fromPath,
-            (fromRouteByFromPathRouteId == null ? void 0 : fromRouteByFromPathRouteId.to) ?? fromPath
-          );
+      const build = (dest = {}) => {
+        var _a;
+        const currentLocation = dest._fromLocation || this.latestLocation;
+        const allFromMatches = this.matchRoutes(currentLocation, {
+          _buildLocation: true
+        });
+        const lastMatch = utils.last(allFromMatches);
+        let fromPath = lastMatch.fullPath;
+        if (dest.unsafeRelative === "path") {
+          fromPath = currentLocation.pathname;
+        } else if (dest.to && dest.from) {
+          fromPath = dest.from;
+          const existingFrom = [...allFromMatches].reverse().find((d) => {
+            return d.fullPath === fromPath || d.fullPath === path.joinPaths([fromPath, "/"]);
+          });
+          if (!existingFrom) {
+            console.warn(`Could not find match for from: ${dest.from}`);
+          }
         }
-        const prevParams = { ...(_f = utils.last(fromMatches)) == null ? void 0 : _f.params };
-        let nextParams = (dest.params ?? true) === true ? prevParams : {
-          ...prevParams,
-          ...utils.functionalUpdate(dest.params, prevParams)
+        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 : {
+          ...fromParams,
+          ...utils.functionalUpdate(dest.params, fromParams)
         };
+        const destRoutes = this.matchRoutes(
+          nextTo,
+          {},
+          {
+            _buildLocation: true
+          }
+        ).map((d) => this.looseRoutesById[d.routeId]);
         if (Object.keys(nextParams).length > 0) {
-          matchedRoutesResult == null ? void 0 : matchedRoutesResult.matchedRoutes.map((route) => {
+          destRoutes.map((route) => {
             var _a2;
             return ((_a2 = route.options.params) == null ? void 0 : _a2.stringify) ?? route.options.stringifyParams;
           }).filter(Boolean).forEach((fn) => {
             nextParams = { ...nextParams, ...fn(nextParams) };
           });
         }
-        pathname = path.interpolatePath({
-          path: pathname,
+        const nextPathname = path.interpolatePath({
+          path: nextTo,
           params: nextParams ?? {},
           leaveWildcards: false,
           leaveParams: opts.leaveParams,
           decodeCharMap: this.pathParamsDecodeCharMap
         }).interpolatedPath;
-        let search = fromSearch;
-        if (opts._includeValidateSearch && ((_g = this.options.search) == null ? void 0 : _g.strict)) {
+        let nextSearch = fromSearch;
+        if (opts._includeValidateSearch && ((_a = this.options.search) == null ? void 0 : _a.strict)) {
           let validatedSearch = {};
-          matchedRoutesResult == null ? void 0 : matchedRoutesResult.matchedRoutes.forEach((route) => {
+          destRoutes.forEach((route) => {
             try {
               if (route.options.validateSearch) {
                 validatedSearch = {
                   ...validatedSearch,
                   ...validateSearch(route.options.validateSearch, {
                     ...validatedSearch,
-                    ...search
+                    ...nextSearch
                   }) ?? {}
                 };
               }
             } catch {
             }
           });
-          search = validatedSearch;
+          nextSearch = validatedSearch;
         }
-        const applyMiddlewares = (search2) => {
-          const allMiddlewares = (matchedRoutesResult == null ? void 0 : matchedRoutesResult.matchedRoutes.reduce(
-            (acc, route) => {
-              var _a2;
-              const middlewares = [];
-              if ("search" in route.options) {
-                if ((_a2 = route.options.search) == null ? void 0 : _a2.middlewares) {
-                  middlewares.push(...route.options.search.middlewares);
-                }
-              } else if (route.options.preSearchFilters || route.options.postSearchFilters) {
-                const legacyMiddleware = ({
-                  search: search3,
-                  next
-                }) => {
-                  let nextSearch = search3;
-                  if ("preSearchFilters" in route.options && route.options.preSearchFilters) {
-                    nextSearch = route.options.preSearchFilters.reduce(
-                      (prev, next2) => next2(prev),
-                      search3
-                    );
-                  }
-                  const result = next(nextSearch);
-                  if ("postSearchFilters" in route.options && route.options.postSearchFilters) {
-                    return route.options.postSearchFilters.reduce(
-                      (prev, next2) => next2(prev),
-                      result
-                    );
-                  }
-                  return result;
-                };
-                middlewares.push(legacyMiddleware);
-              }
-              if (opts._includeValidateSearch && route.options.validateSearch) {
-                const validate = ({ search: search3, next }) => {
-                  const result = next(search3);
-                  try {
-                    const validatedSearch = {
-                      ...result,
-                      ...validateSearch(
-                        route.options.validateSearch,
-                        result
-                      ) ?? {}
-                    };
-                    return validatedSearch;
-                  } catch {
-                    return result;
-                  }
-                };
-                middlewares.push(validate);
-              }
-              return acc.concat(middlewares);
-            },
-            []
-          )) ?? [];
-          const final = ({ search: search3 }) => {
-            if (!dest.search) {
-              return {};
-            }
-            if (dest.search === true) {
-              return search3;
-            }
-            return utils.functionalUpdate(dest.search, search3);
-          };
-          allMiddlewares.push(final);
-          const applyNext = (index, currentSearch) => {
-            if (index >= allMiddlewares.length) {
-              return currentSearch;
-            }
-            const middleware = allMiddlewares[index];
-            const next = (newSearch) => {
-              return applyNext(index + 1, newSearch);
-            };
-            return middleware({ search: currentSearch, next });
-          };
-          return applyNext(0, search2);
-        };
-        search = applyMiddlewares(search);
-        search = utils.replaceEqualDeep(fromSearch, search);
-        const searchStr = this.options.stringifySearch(search);
-        const hash = dest.hash === true ? this.latestLocation.hash : dest.hash ? utils.functionalUpdate(dest.hash, this.latestLocation.hash) : void 0;
+        nextSearch = applySearchMiddleware({
+          search: nextSearch,
+          dest,
+          destRoutes,
+          _includeValidateSearch: opts._includeValidateSearch
+        });
+        nextSearch = utils.replaceEqualDeep(fromSearch, nextSearch);
+        const searchStr = this.options.stringifySearch(nextSearch);
+        const hash = dest.hash === true ? currentLocation.hash : dest.hash ? utils.functionalUpdate(dest.hash, currentLocation.hash) : void 0;
         const hashStr = hash ? `#${hash}` : "";
-        let nextState = dest.state === true ? this.latestLocation.state : dest.state ? utils.functionalUpdate(dest.state, this.latestLocation.state) : {};
-        nextState = utils.replaceEqualDeep(this.latestLocation.state, nextState);
+        let nextState = dest.state === true ? currentLocation.state : dest.state ? utils.functionalUpdate(dest.state, currentLocation.state) : {};
+        nextState = utils.replaceEqualDeep(currentLocation.state, nextState);
         return {
-          pathname,
-          search,
+          pathname: nextPathname,
+          search: nextSearch,
           searchStr,
           state: nextState,
           hash: hash ?? "",
-          href: `${pathname}${searchStr}${hashStr}`,
+          href: `${nextPathname}${searchStr}${hashStr}`,
           unmaskOnReload: dest.unmaskOnReload
         };
       };
@@ -504,14 +340,11 @@ class RouterCore {
             maskedNext = build(maskedDest);
           }
         }
-        const nextMatches = this.getMatchedRoutes(next, dest);
-        const final = build(dest, nextMatches);
         if (maskedNext) {
-          const maskedMatches = this.getMatchedRoutes(maskedNext, maskedDest);
-          const maskedFinal = build(maskedDest, maskedMatches);
-          final.maskedLocation = maskedFinal;
+          const maskedFinal = build(maskedDest);
+          next.maskedLocation = maskedFinal;
         }
-        return final;
+        return next;
       };
       if (opts.mask) {
         return buildWithMatches(opts, {
@@ -618,6 +451,13 @@ class RouterCore {
       });
     };
     this.navigate = ({ to, reloadDocument, href, ...rest }) => {
+      if (!reloadDocument && href) {
+        try {
+          new URL(`${href}`);
+          reloadDocument = true;
+        } catch {
+        }
+      }
       if (reloadDocument) {
         if (!href) {
           const location = this.buildLocation({ to, ...rest });
@@ -636,8 +476,23 @@ class RouterCore {
         to
       });
     };
-    this.load = async (opts) => {
+    this.beforeLoad = () => {
+      this.cancelMatches();
       this.latestLocation = this.parseLocation(this.latestLocation);
+      const pendingMatches = this.matchRoutes(this.latestLocation);
+      this.__store.setState((s) => ({
+        ...s,
+        status: "pending",
+        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);
+        })
+      }));
+    };
+    this.load = async (opts) => {
       let redirect$1;
       let notFound$1;
       let loadPromise;
@@ -645,24 +500,9 @@ class RouterCore {
         this.startTransition(async () => {
           var _a;
           try {
+            this.beforeLoad();
             const next = this.latestLocation;
             const prevLocation = this.state.resolvedLocation;
-            this.cancelMatches();
-            let pendingMatches;
-            store.batch(() => {
-              pendingMatches = this.matchRoutes(next);
-              this.__store.setState((s) => ({
-                ...s,
-                status: "pending",
-                isLoading: true,
-                location: next,
-                pendingMatches,
-                // If a cached moved to pendingMatches, remove it from cachedMatches
-                cachedMatches: s.cachedMatches.filter((d) => {
-                  return !pendingMatches.find((e) => e.id === d.id);
-                })
-              }));
-            });
             if (!this.state.redirect) {
               this.emit({
                 type: "onBeforeNavigate",
@@ -681,7 +521,7 @@ class RouterCore {
             });
             await this.loadMatches({
               sync: opts == null ? void 0 : opts.sync,
-              matches: pendingMatches,
+              matches: this.state.pendingMatches,
               location: next,
               // eslint-disable-next-line @typescript-eslint/require-await
               onReady: async () => {
@@ -730,11 +570,11 @@ class RouterCore {
               }
             });
           } catch (err) {
-            if (redirect.isResolvedRedirect(err)) {
+            if (redirect.isRedirect(err)) {
               redirect$1 = err;
               if (!this.isServer) {
                 this.navigate({
-                  ...redirect$1,
+                  ...redirect$1.options,
                   replace: true,
                   ignoreBlocker: true
                 });
@@ -744,7 +584,7 @@ class RouterCore {
             }
             this.__store.setState((s) => ({
               ...s,
-              statusCode: redirect$1 ? redirect$1.statusCode : notFound$1 ? 404 : s.matches.some((d) => d.status === "error") ? 500 : 200,
+              statusCode: redirect$1 ? redirect$1.status : notFound$1 ? 404 : s.matches.some((d) => d.status === "error") ? 500 : 200,
               redirect: redirect$1
             }));
           }
@@ -842,12 +682,14 @@ class RouterCore {
       };
       const handleRedirectAndNotFound = (match, err) => {
         var _a, _b, _c, _d;
-        if (redirect.isResolvedRedirect(err)) {
-          if (!err.reloadDocument) {
-            throw err;
-          }
-        }
         if (redirect.isRedirect(err) || notFound.isNotFound(err)) {
+          if (redirect.isRedirect(err)) {
+            if (err.redirectHandled) {
+              if (!err.options.reloadDocument) {
+                throw err;
+              }
+            }
+          }
           updateMatch(match.id, (prev) => ({
             ...prev,
             status: redirect.isRedirect(err) ? "redirected" : notFound.isNotFound(err) ? "notFound" : "error",
@@ -864,7 +706,9 @@ class RouterCore {
           (_c = match.loadPromise) == null ? void 0 : _c.resolve();
           if (redirect.isRedirect(err)) {
             rendered = true;
-            err = this.resolveRedirect({ ...err, _fromLocation: location });
+            err.options._fromLocation = location;
+            err.redirectHandled = true;
+            err = this.resolveRedirect(err);
             throw err;
           } else if (notFound.isNotFound(err)) {
             this._handleNotFound(matches, err, {
@@ -1072,7 +916,7 @@ class RouterCore {
                         loaderPromise: utils.createControlledPromise(),
                         preload: !!preload && !this.state.matches.find((d) => d.id === matchId)
                       }));
-                      const executeHead = () => {
+                      const executeHead = async () => {
                         var _a2, _b2, _c2, _d2, _e, _f;
                         const match = this.getMatch(matchId);
                         if (!match) {
@@ -1084,20 +928,13 @@ class RouterCore {
                           params: match.params,
                           loaderData: match.loaderData
                         };
-                        const headFnContent = (_b2 = (_a2 = route.options).head) == null ? void 0 : _b2.call(_a2, assetContext);
+                        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 = (_d2 = (_c2 = route.options).scripts) == null ? void 0 : _d2.call(_c2, assetContext);
-                        const headers = (_f = (_e = route.options).headers) == null ? void 0 : _f.call(_e, assetContext);
-                        updateMatch(matchId, (prev) => ({
-                          ...prev,
-                          meta,
-                          links,
-                          headScripts,
-                          headers,
-                          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;
@@ -1122,17 +959,19 @@ class RouterCore {
                             await route._lazyPromise;
                             await potentialPendingMinPromise();
                             await route._componentsPromise;
-                            store.batch(() => {
-                              updateMatch(matchId, (prev) => ({
-                                ...prev,
-                                error: void 0,
-                                status: "success",
-                                isFetching: false,
-                                updatedAt: Date.now(),
-                                loaderData
-                              }));
-                              executeHead();
-                            });
+                            updateMatch(matchId, (prev) => ({
+                              ...prev,
+                              error: void 0,
+                              status: "success",
+                              isFetching: false,
+                              updatedAt: Date.now(),
+                              loaderData
+                            }));
+                            const head = await executeHead();
+                            updateMatch(matchId, (prev) => ({
+                              ...prev,
+                              ...head
+                            }));
                           } catch (e) {
                             let error = e;
                             await potentialPendingMinPromise();
@@ -1146,28 +985,26 @@ class RouterCore {
                                 onErrorError
                               );
                             }
-                            store.batch(() => {
-                              updateMatch(matchId, (prev) => ({
-                                ...prev,
-                                error,
-                                status: "error",
-                                isFetching: false
-                              }));
-                              executeHead();
-                            });
+                            const head = await executeHead();
+                            updateMatch(matchId, (prev) => ({
+                              ...prev,
+                              error,
+                              status: "error",
+                              isFetching: false,
+                              ...head
+                            }));
                           }
                           (_e = this.serverSsr) == null ? void 0 : _e.onMatchSettled({
                             router: this,
                             match: this.getMatch(matchId)
                           });
                         } catch (err) {
-                          store.batch(() => {
-                            updateMatch(matchId, (prev) => ({
-                              ...prev,
-                              loaderPromise: void 0
-                            }));
-                            executeHead();
-                          });
+                          const head = await executeHead();
+                          updateMatch(matchId, (prev) => ({
+                            ...prev,
+                            loaderPromise: void 0,
+                            ...head
+                          }));
                           handleRedirectAndNotFound(this.getMatch(matchId), err);
                         }
                       };
@@ -1187,15 +1024,19 @@ class RouterCore {
                               loaderPromise: void 0
                             }));
                           } catch (err) {
-                            if (redirect.isResolvedRedirect(err)) {
-                              await this.navigate(err);
+                            if (redirect.isRedirect(err)) {
+                              await this.navigate(err.options);
                             }
                           }
                         })();
                       } else if (status !== "success" || loaderShouldRunAsync && sync) {
                         await runLoader();
                       } else {
-                        executeHead();
+                        const head = await executeHead();
+                        updateMatch(matchId, (prev) => ({
+                          ...prev,
+                          ...head
+                        }));
                       }
                     }
                     if (!loaderIsRunningAsync) {
@@ -1254,10 +1095,13 @@ class RouterCore {
       });
       return this.load({ sync: opts == null ? void 0 : opts.sync });
     };
-    this.resolveRedirect = (err) => {
-      const redirect2 = err;
-      if (!redirect2.href) {
-        redirect2.href = this.buildLocation(redirect2).href;
+    this.resolveRedirect = (redirect2) => {
+      if (!redirect2.options.href) {
+        redirect2.options.href = this.buildLocation(redirect2.options).href;
+        redirect2.headers.set("Location", redirect2.options.href);
+      }
+      if (!redirect2.headers.get("Location")) {
+        redirect2.headers.set("Location", redirect2.options.href);
       }
       return redirect2;
     };
@@ -1359,11 +1203,11 @@ class RouterCore {
         return matches;
       } catch (err) {
         if (redirect.isRedirect(err)) {
-          if (err.reloadDocument) {
+          if (err.options.reloadDocument) {
             return void 0;
           }
           return await this.preloadRoute({
-            ...err,
+            ...err.options,
             _fromLocation: next
           });
         }
@@ -1467,9 +1311,10 @@ class RouterCore {
     return this.routesById;
   }
   matchRoutesInternal(next, opts) {
+    var _a;
     const { foundRoute, matchedRoutes, routeParams } = this.getMatchedRoutes(
-      next,
-      opts == null ? void 0 : opts.dest
+      next.pathname,
+      (_a = opts == null ? void 0 : opts.dest) == null ? void 0 : _a.to
     );
     let isGlobalNotFound = false;
     if (
@@ -1500,9 +1345,9 @@ class RouterCore {
       return root.rootRouteId;
     })();
     const parseErrors = matchedRoutes.map((route) => {
-      var _a;
+      var _a2;
       let parsedParamsError;
-      const parseParams = ((_a = route.options.params) == null ? void 0 : _a.parse) ?? route.options.parseParams;
+      const parseParams = ((_a2 = route.options.params) == null ? void 0 : _a2.parse) ?? route.options.parseParams;
       if (parseParams) {
         try {
           const parsedParams = parseParams(routeParams);
@@ -1526,7 +1371,7 @@ class RouterCore {
       return parentContext;
     };
     matchedRoutes.forEach((route, index) => {
-      var _a, _b;
+      var _a2, _b;
       const parentMatch = matches[index - 1];
       const [preMatchSearch, strictMatchSearch, searchError] = (() => {
         const parentSearch = (parentMatch == null ? void 0 : parentMatch.search) ?? next.search;
@@ -1554,7 +1399,7 @@ class RouterCore {
           return [parentSearch, {}, searchParamError];
         }
       })();
-      const loaderDeps = ((_b = (_a = route.options).loaderDeps) == null ? void 0 : _b.call(_a, {
+      const loaderDeps = ((_b = (_a2 = route.options).loaderDeps) == null ? void 0 : _b.call(_a2, {
         search: preMatchSearch
       })) ?? "";
       const loaderDepsHash = loaderDeps ? JSON.stringify(loaderDeps) : "";
@@ -1632,7 +1477,7 @@ class RouterCore {
       matches.push(match);
     });
     matches.forEach((match, index) => {
-      var _a, _b;
+      var _a2, _b;
       const route = this.looseRoutesById[match.routeId];
       const existingMatch = this.getMatch(match.id);
       if (!existingMatch && (opts == null ? void 0 : opts._buildLocation) !== true) {
@@ -1650,7 +1495,7 @@ class RouterCore {
           preload: !!match.preload,
           matches
         };
-        match.__routeContext = ((_b = (_a = route.options).context) == null ? void 0 : _b.call(_a, contextFnContext)) ?? {};
+        match.__routeContext = ((_b = (_a2 = route.options).context) == null ? void 0 : _b.call(_a2, contextFnContext)) ?? {};
         match.context = {
           ...parentContext,
           ...match.__routeContext,
@@ -1720,6 +1565,219 @@ function routeNeedsPreload(route) {
   }
   return false;
 }
+function processRouteTree({
+  routeTree,
+  initRoute
+}) {
+  const routesById = {};
+  const routesByPath = {};
+  const recurseRoutes = (childRoutes) => {
+    childRoutes.forEach((childRoute, i) => {
+      initRoute == null ? void 0 : initRoute(childRoute, i);
+      const existingRoute = routesById[childRoute.id];
+      invariant(
+        !existingRoute,
+        `Duplicate routes found with id: ${String(childRoute.id)}`
+      );
+      routesById[childRoute.id] = childRoute;
+      if (!childRoute.isRoot && childRoute.path) {
+        const trimmedFullPath = path.trimPathRight(childRoute.fullPath);
+        if (!routesByPath[trimmedFullPath] || childRoute.fullPath.endsWith("/")) {
+          routesByPath[trimmedFullPath] = childRoute;
+        }
+      }
+      const children = childRoute.children;
+      if (children == null ? void 0 : children.length) {
+        recurseRoutes(children);
+      }
+    });
+  };
+  recurseRoutes([routeTree]);
+  const scoredRoutes = [];
+  const routes = Object.values(routesById);
+  routes.forEach((d, i) => {
+    var _a;
+    if (d.isRoot || !d.path) {
+      return;
+    }
+    const trimmed = path.trimPathLeft(d.fullPath);
+    const parsed = path.parsePathname(trimmed);
+    while (parsed.length > 1 && ((_a = parsed[0]) == null ? void 0 : _a.value) === "/") {
+      parsed.shift();
+    }
+    const scores = parsed.map((segment) => {
+      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;
+      }
+      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;
+      }
+      return 1;
+    });
+    scoredRoutes.push({ child: d, trimmed, parsed, index: i, scores });
+  });
+  const flatRoutes = scoredRoutes.sort((a, b) => {
+    const minLength = Math.min(a.scores.length, b.scores.length);
+    for (let i = 0; i < minLength; i++) {
+      if (a.scores[i] !== b.scores[i]) {
+        return b.scores[i] - a.scores[i];
+      }
+    }
+    if (a.scores.length !== b.scores.length) {
+      return b.scores.length - a.scores.length;
+    }
+    for (let i = 0; i < minLength; i++) {
+      if (a.parsed[i].value !== b.parsed[i].value) {
+        return a.parsed[i].value > b.parsed[i].value ? 1 : -1;
+      }
+    }
+    return a.index - b.index;
+  }).map((d, i) => {
+    d.child.rank = i;
+    return d.child;
+  });
+  return { routesById, routesByPath, flatRoutes };
+}
+function getMatchedRoutes({
+  pathname,
+  routePathname,
+  basepath,
+  caseSensitive,
+  routesByPath,
+  routesById,
+  flatRoutes
+}) {
+  let routeParams = {};
+  const trimmedPath = path.trimPathRight(pathname);
+  const getMatchedParams = (route) => {
+    var _a;
+    const result = path.matchPathname(basepath, trimmedPath, {
+      to: route.fullPath,
+      caseSensitive: ((_a = route.options) == null ? void 0 : _a.caseSensitive) ?? caseSensitive,
+      fuzzy: true
+    });
+    return result;
+  };
+  let foundRoute = routePathname !== void 0 ? routesByPath[routePathname] : void 0;
+  if (foundRoute) {
+    routeParams = getMatchedParams(foundRoute);
+  } else {
+    foundRoute = flatRoutes.find((route) => {
+      const matchedParams = getMatchedParams(route);
+      if (matchedParams) {
+        routeParams = matchedParams;
+        return true;
+      }
+      return false;
+    });
+  }
+  let routeCursor = foundRoute || routesById[root.rootRouteId];
+  const matchedRoutes = [routeCursor];
+  while (routeCursor.parentRoute) {
+    routeCursor = routeCursor.parentRoute;
+    matchedRoutes.unshift(routeCursor);
+  }
+  return { matchedRoutes, routeParams, foundRoute };
+}
+function applySearchMiddleware({
+  search,
+  dest,
+  destRoutes,
+  _includeValidateSearch
+}) {
+  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) {
+          middlewares.push(...route.options.search.middlewares);
+        }
+      } else if (route.options.preSearchFilters || route.options.postSearchFilters) {
+        const legacyMiddleware = ({
+          search: search2,
+          next
+        }) => {
+          let nextSearch = search2;
+          if ("preSearchFilters" in route.options && route.options.preSearchFilters) {
+            nextSearch = route.options.preSearchFilters.reduce(
+              (prev, next2) => next2(prev),
+              search2
+            );
+          }
+          const result = next(nextSearch);
+          if ("postSearchFilters" in route.options && route.options.postSearchFilters) {
+            return route.options.postSearchFilters.reduce(
+              (prev, next2) => next2(prev),
+              result
+            );
+          }
+          return result;
+        };
+        middlewares.push(legacyMiddleware);
+      }
+      if (_includeValidateSearch && route.options.validateSearch) {
+        const validate = ({ search: search2, next }) => {
+          const result = next(search2);
+          try {
+            const validatedSearch = {
+              ...result,
+              ...validateSearch(route.options.validateSearch, result) ?? {}
+            };
+            return validatedSearch;
+          } catch {
+            return result;
+          }
+        };
+        middlewares.push(validate);
+      }
+      return acc.concat(middlewares);
+    },
+    []
+  ) ?? [];
+  const final = ({ search: search2 }) => {
+    if (!dest.search) {
+      return {};
+    }
+    if (dest.search === true) {
+      return search2;
+    }
+    return utils.functionalUpdate(dest.search, search2);
+  };
+  allMiddlewares.push(final);
+  const applyNext = (index, currentSearch) => {
+    if (index >= allMiddlewares.length) {
+      return currentSearch;
+    }
+    const middleware = allMiddlewares[index];
+    const next = (newSearch) => {
+      return applyNext(index + 1, newSearch);
+    };
+    return middleware({ search: currentSearch, next });
+  };
+  return applyNext(0, search);
+}
 exports.PathParamError = PathParamError;
 exports.RouterCore = RouterCore;
 exports.SearchParamError = SearchParamError;
@@ -1727,5 +1785,7 @@ exports.componentTypes = componentTypes;
 exports.defaultSerializeError = defaultSerializeError;
 exports.getInitialRouterState = getInitialRouterState;
 exports.getLocationChangeInfo = getLocationChangeInfo;
+exports.getMatchedRoutes = getMatchedRoutes;
 exports.lazyFn = lazyFn;
+exports.processRouteTree = processRouteTree;
 //# sourceMappingURL=router.cjs.map