@tanstack/router-core 1.132.0-alpha.1 → 1.132.0-alpha.3

package/dist/cjs/router.cjs

@@ -11,6 +11,7 @@ const searchParams = require("./searchParams.cjs");
 const root = require("./root.cjs");
 const redirect = require("./redirect.cjs");
 const lruCache = require("./lru-cache.cjs");
+const loadMatches = require("./load-matches.cjs");
 function defaultSerializeError(err) {
   if (err instanceof Error) {
     const obj = {
@@ -212,13 +213,8 @@ class RouterCore {
       const match = this.getMatch(id);
       if (!match) return;
       match.abortController.abort();
-      this.updateMatch(id, (prev) => {
-        clearTimeout(prev.pendingTimeout);
-        return {
-          ...prev,
-          pendingTimeout: void 0
-        };
-      });
+      clearTimeout(match._nonReactive.pendingTimeout);
+      match._nonReactive.pendingTimeout = void 0;
     };
     this.cancelMatches = () => {
       this.state.pendingMatches?.forEach((match) => {
@@ -232,7 +228,7 @@ class RouterCore {
           _buildLocation: true
         });
         const lastMatch = utils.last(allCurrentLocationMatches);
-        let fromPath = lastMatch.fullPath;
+        let fromPath = this.resolvePathWithBase(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") {
@@ -244,10 +240,10 @@ class RouterCore {
               dest.from,
               void 0
             ).matchedRoutes;
-            const matchedFrom = [...allCurrentLocationMatches].reverse().find((d) => {
+            const matchedFrom = utils.findLast(allCurrentLocationMatches, (d) => {
               return comparePaths(d.fullPath, fromPath);
             });
-            const matchedCurrent = [...allFromMatches].reverse().find((d) => {
+            const matchedCurrent = utils.findLast(allFromMatches, (d) => {
               return comparePaths(d.fullPath, currentLocation.pathname);
             });
             if (!matchedFrom && !matchedCurrent) {
@@ -255,37 +251,35 @@ class RouterCore {
             }
           }
         }
+        fromPath = this.resolvePathWithBase(fromPath, ".");
         const fromSearch = lastMatch.search;
         const fromParams = { ...lastMatch.params };
         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,
-          ...utils.functionalUpdate(dest.params, fromParams)
-        };
+        const nextParams = dest.params === false || dest.params === null ? {} : (dest.params ?? true) === true ? fromParams : Object.assign(
+          fromParams,
+          utils.functionalUpdate(dest.params, fromParams)
+        );
         const interpolatedNextTo = path.interpolatePath({
           path: nextTo,
-          params: nextParams ?? {},
+          params: nextParams,
           parseCache: this.parsePathnameCache
         }).interpolatedPath;
-        const destRoutes = this.matchRoutes(
-          interpolatedNextTo,
-          {},
-          {
-            _buildLocation: true
-          }
-        ).map((d) => this.looseRoutesById[d.routeId]);
+        const destRoutes = this.matchRoutes(interpolatedNextTo, void 0, {
+          _buildLocation: true
+        }).map((d) => this.looseRoutesById[d.routeId]);
         if (Object.keys(nextParams).length > 0) {
-          destRoutes.map((route) => {
-            return route.options.params?.stringify ?? route.options.stringifyParams;
-          }).filter(Boolean).forEach((fn) => {
-            nextParams = { ...nextParams, ...fn(nextParams) };
-          });
+          for (const route of destRoutes) {
+            const fn = route.options.params?.stringify ?? route.options.stringifyParams;
+            if (fn) {
+              Object.assign(nextParams, fn(nextParams));
+            }
+          }
         }
         const nextPathname = path.interpolatePath({
           // Use the original template path for interpolation
           // This preserves the original parameter syntax including optional parameters
           path: nextTo,
-          params: nextParams ?? {},
+          params: nextParams,
           leaveWildcards: false,
           leaveParams: opts.leaveParams,
           decodeCharMap: this.pathParamsDecodeCharMap,
@@ -293,19 +287,19 @@ class RouterCore {
         }).interpolatedPath;
         let nextSearch = fromSearch;
         if (opts._includeValidateSearch && this.options.search?.strict) {
-          let validatedSearch = {};
+          const validatedSearch = {};
           destRoutes.forEach((route) => {
-            try {
-              if (route.options.validateSearch) {
-                validatedSearch = {
-                  ...validatedSearch,
-                  ...validateSearch(route.options.validateSearch, {
+            if (route.options.validateSearch) {
+              try {
+                Object.assign(
+                  validatedSearch,
+                  validateSearch(route.options.validateSearch, {
                     ...validatedSearch,
                     ...nextSearch
-                  }) ?? {}
-                };
+                  })
+                );
+              } catch {
               }
-            } catch {
             }
           });
           nextSearch = validatedSearch;
@@ -357,7 +351,7 @@ class RouterCore {
           if (foundMask) {
             const { from: _from, ...maskProps } = foundMask;
             maskedDest = {
-              ...utils.pick(opts, ["from"]),
+              from: opts.from,
               ...maskProps,
               params
             };
@@ -372,7 +366,7 @@ class RouterCore {
       };
       if (opts.mask) {
         return buildWithMatches(opts, {
-          ...utils.pick(opts, ["from"]),
+          from: opts.from,
           ...opts.mask
         });
       }
@@ -568,10 +562,12 @@ class RouterCore {
                 location: next
               })
             });
-            await this.loadMatches({
+            await loadMatches.loadMatches({
+              router: this,
               sync: opts?.sync,
               matches: this.state.pendingMatches,
               location: next,
+              updateMatch: this.updateMatch,
               // eslint-disable-next-line @typescript-eslint/require-await
               onReady: async () => {
                 this.startViewTransition(async () => {
@@ -695,510 +691,13 @@ class RouterCore {
       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,
-      matches,
-      preload: allPreload,
-      onReady,
-      updateMatch = this.updateMatch,
-      sync
-    }) => {
-      let firstBadMatchIndex;
-      let rendered = false;
-      const triggerOnReady = async () => {
-        if (!rendered) {
-          rendered = true;
-          await onReady?.();
-        }
-      };
-      const resolvePreload = (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) => {
-        if (redirect.isRedirect(err) || notFound.isNotFound(err)) {
-          if (redirect.isRedirect(err)) {
-            if (err.redirectHandled) {
-              if (!err.options.reloadDocument) {
-                throw err;
-              }
-            }
-          }
-          match.beforeLoadPromise?.resolve();
-          match.loaderPromise?.resolve();
-          updateMatch(match.id, (prev) => ({
-            ...prev,
-            status: redirect.isRedirect(err) ? "redirected" : notFound.isNotFound(err) ? "notFound" : "error",
-            isFetching: false,
-            error: err,
-            beforeLoadPromise: void 0,
-            loaderPromise: void 0
-          }));
-          if (!err.routeId) {
-            err.routeId = match.routeId;
-          }
-          match.loadPromise?.resolve();
-          if (redirect.isRedirect(err)) {
-            rendered = true;
-            err.options._fromLocation = location;
-            err.redirectHandled = true;
-            err = this.resolveRedirect(err);
-            throw err;
-          } else if (notFound.isNotFound(err)) {
-            this._handleNotFound(matches, err, {
-              updateMatch
-            });
-            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 () => {
-            try {
-              const handleSerialError = (index, err, routerCode) => {
-                const { id: matchId, routeId } = matches[index];
-                const route = this.looseRoutesById[routeId];
-                if (err instanceof Promise) {
-                  throw err;
-                }
-                err.routerCode = routerCode;
-                firstBadMatchIndex = firstBadMatchIndex ?? index;
-                handleRedirectAndNotFound(this.getMatch(matchId), err);
-                try {
-                  route.options.onError?.(err);
-                } catch (errorHandlerErr) {
-                  err = errorHandlerErr;
-                  handleRedirectAndNotFound(this.getMatch(matchId), err);
-                }
-                updateMatch(matchId, (prev) => {
-                  prev.beforeLoadPromise?.resolve();
-                  prev.loadPromise?.resolve();
-                  return {
-                    ...prev,
-                    error: err,
-                    status: "error",
-                    isFetching: false,
-                    updatedAt: Date.now(),
-                    abortController: new AbortController(),
-                    beforeLoadPromise: void 0
-                  };
-                });
-              };
-              for (const [index, { id: matchId, routeId }] of matches.entries()) {
-                const existingMatch = this.getMatch(matchId);
-                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;
-                if (this.isServer) {
-                  let ssr;
-                  if (this.isShell()) {
-                    ssr = matchId === root.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;
-                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;
-                  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 {
-                    updateMatch(matchId, (prev) => {
-                      const prevLoadPromise = prev.loadPromise;
-                      return {
-                        ...prev,
-                        loadPromise: utils.createControlledPromise(() => {
-                          prevLoadPromise?.resolve();
-                        }),
-                        beforeLoadPromise: utils.createControlledPromise()
-                      };
-                    });
-                    const { paramsError, searchError } = this.getMatch(matchId);
-                    if (paramsError) {
-                      handleSerialError(index, paramsError, "PARSE_PARAMS");
-                    }
-                    if (searchError) {
-                      handleSerialError(index, searchError, "VALIDATE_SEARCH");
-                    }
-                    setupPendingTimeout();
-                    const abortController = new AbortController();
-                    const parentMatchContext = parentMatch?.context ?? this.options.context ?? {};
-                    updateMatch(matchId, (prev) => ({
-                      ...prev,
-                      isFetching: "beforeLoad",
-                      fetchCount: prev.fetchCount + 1,
-                      abortController,
-                      context: {
-                        ...parentMatchContext,
-                        ...prev.__routeContext
-                      }
-                    }));
-                    const { search, params, context, cause } = this.getMatch(matchId);
-                    const preload = resolvePreload(matchId);
-                    const beforeLoadFnContext = {
-                      search,
-                      abortController,
-                      params,
-                      preload,
-                      context,
-                      location,
-                      navigate: (opts) => this.navigate({ ...opts, _fromLocation: location }),
-                      buildLocation: this.buildLocation,
-                      cause: preload ? "preload" : cause,
-                      matches
-                    };
-                    const beforeLoadContext = await route.options.beforeLoad?.(beforeLoadFnContext);
-                    if (redirect.isRedirect(beforeLoadContext) || notFound.isNotFound(beforeLoadContext)) {
-                      handleSerialError(index, beforeLoadContext, "BEFORE_LOAD");
-                    }
-                    updateMatch(matchId, (prev) => {
-                      return {
-                        ...prev,
-                        __beforeLoadContext: beforeLoadContext,
-                        context: {
-                          ...parentMatchContext,
-                          ...prev.__routeContext,
-                          ...beforeLoadContext
-                        },
-                        abortController
-                      };
-                    });
-                  } catch (err) {
-                    handleSerialError(index, err, "BEFORE_LOAD");
-                  }
-                  updateMatch(matchId, (prev) => {
-                    prev.beforeLoadPromise?.resolve();
-                    return {
-                      ...prev,
-                      beforeLoadPromise: void 0,
-                      isFetching: false
-                    };
-                  });
-                }
-              }
-              const validResolvedMatches = matches.slice(0, firstBadMatchIndex);
-              const matchPromises = [];
-              validResolvedMatches.forEach(({ id: matchId, routeId }, index) => {
-                matchPromises.push(
-                  (async () => {
-                    let loaderShouldRunAsync = false;
-                    let loaderIsRunningAsync = false;
-                    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 getLoaderContext = () => {
-                        const {
-                          params,
-                          loaderDeps,
-                          abortController,
-                          context,
-                          cause
-                        } = this.getMatch(matchId);
-                        const preload2 = resolvePreload(matchId);
-                        return {
-                          params,
-                          deps: loaderDeps,
-                          preload: !!preload2,
-                          parentMatchPromise,
-                          abortController,
-                          context,
-                          location,
-                          navigate: (opts) => this.navigate({ ...opts, _fromLocation: location }),
-                          cause: preload2 ? "preload" : cause,
-                          route
-                        };
-                      };
-                      const age = Date.now() - this.getMatch(matchId).updatedAt;
-                      const preload = resolvePreload(matchId);
-                      const staleAge = preload ? route.options.preloadStaleTime ?? this.options.defaultPreloadStaleTime ?? 3e4 : route.options.staleTime ?? this.options.defaultStaleTime ?? 0;
-                      const shouldReloadOption = route.options.shouldReload;
-                      const shouldReload = typeof shouldReloadOption === "function" ? shouldReloadOption(getLoaderContext()) : shouldReloadOption;
-                      updateMatch(matchId, (prev) => ({
-                        ...prev,
-                        loaderPromise: utils.createControlledPromise(),
-                        preload: !!preload && !this.state.matches.some((d) => d.id === matchId)
-                      }));
-                      const runLoader = async () => {
-                        try {
-                          try {
-                            if (!this.isServer || this.isServer && this.getMatch(matchId).ssr === true) {
-                              this.loadRouteChunk(route);
-                            }
-                            updateMatch(matchId, (prev) => ({
-                              ...prev,
-                              isFetching: "loader"
-                            }));
-                            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) => ({
-                              ...prev,
-                              error: void 0,
-                              status: "success",
-                              isFetching: false,
-                              updatedAt: Date.now(),
-                              ...head
-                            }));
-                          } catch (e) {
-                            let error = e;
-                            await potentialPendingMinPromise();
-                            handleRedirectAndNotFound(this.getMatch(matchId), e);
-                            try {
-                              route.options.onError?.(e);
-                            } catch (onErrorError) {
-                              error = onErrorError;
-                              handleRedirectAndNotFound(
-                                this.getMatch(matchId),
-                                onErrorError
-                              );
-                            }
-                            const head = await executeHead();
-                            updateMatch(matchId, (prev) => ({
-                              ...prev,
-                              error,
-                              status: "error",
-                              isFetching: false,
-                              ...head
-                            }));
-                          }
-                        } catch (err) {
-                          const head = await executeHead();
-                          updateMatch(matchId, (prev) => ({
-                            ...prev,
-                            loaderPromise: void 0,
-                            ...head
-                          }));
-                          handleRedirectAndNotFound(this.getMatch(matchId), err);
-                        }
-                      };
-                      const { status, invalid } = this.getMatch(matchId);
-                      loaderShouldRunAsync = status === "success" && (invalid || (shouldReload ?? age > staleAge));
-                      if (preload && route.options.preload === false) {
-                      } else if (loaderShouldRunAsync && !sync) {
-                        loaderIsRunningAsync = true;
-                        (async () => {
-                          try {
-                            await runLoader();
-                            const { loaderPromise, loadPromise } = this.getMatch(matchId);
-                            loaderPromise?.resolve();
-                            loadPromise?.resolve();
-                            updateMatch(matchId, (prev) => ({
-                              ...prev,
-                              loaderPromise: void 0
-                            }));
-                          } catch (err) {
-                            if (redirect.isRedirect(err)) {
-                              await this.navigate(err.options);
-                            }
-                          }
-                        })();
-                      } else if (status !== "success" || loaderShouldRunAsync && sync) {
-                        await runLoader();
-                      } else {
-                        const head = await executeHead();
-                        updateMatch(matchId, (prev) => ({
-                          ...prev,
-                          ...head
-                        }));
-                      }
-                    }
-                    if (!loaderIsRunningAsync) {
-                      const { loaderPromise, loadPromise } = this.getMatch(matchId);
-                      loaderPromise?.resolve();
-                      loadPromise?.resolve();
-                    }
-                    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);
-                  })()
-                );
-              });
-              await Promise.all(matchPromises);
-              resolveAll();
-            } catch (err) {
-              rejectAll(err);
-            }
-          })();
-        });
-        await triggerOnReady();
-      } catch (err) {
-        if (redirect.isRedirect(err) || notFound.isNotFound(err)) {
-          if (notFound.isNotFound(err) && !allPreload) {
-            await triggerOnReady();
-          }
-          throw err;
-        }
-      }
-      return matches;
-    };
     this.invalidate = (opts) => {
       const invalidate = (d) => {
         if (opts?.filter?.(d) ?? true) {
           return {
             ...d,
             invalid: true,
-            ...opts?.forcePending || d.status === "error" ? { status: "pending", error: void 0 } : {}
+            ...opts?.forcePending || d.status === "error" ? { status: "pending", error: void 0 } : void 0
           };
         }
         return d;
@@ -1256,31 +755,7 @@ class RouterCore {
       };
       this.clearCache({ filter });
     };
-    this.loadRouteChunk = (route) => {
-      if (route._lazyPromise === void 0) {
-        if (route.lazyFn) {
-          route._lazyPromise = route.lazyFn().then((lazyRoute) => {
-            const { id: _id, ...options2 } = lazyRoute.options;
-            Object.assign(route.options, options2);
-          });
-        } else {
-          route._lazyPromise = Promise.resolve();
-        }
-      }
-      if (route._componentsPromise === void 0) {
-        route._componentsPromise = route._lazyPromise.then(
-          () => Promise.all(
-            componentTypes.map(async (type) => {
-              const component = route.options[type];
-              if (component?.preload) {
-                await component.preload();
-              }
-            })
-          )
-        );
-      }
-      return route._componentsPromise;
-    };
+    this.loadRouteChunk = loadMatches.loadRouteChunk;
     this.preloadRoute = async (opts) => {
       const next = this.buildLocation(opts);
       let matches = this.matchRoutes(next, {
@@ -1308,7 +783,8 @@ class RouterCore {
         });
       });
       try {
-        matches = await this.loadMatches({
+        matches = await loadMatches.loadMatches({
+          router: this,
           matches,
           location: next,
           preload: true,
@@ -1375,39 +851,6 @@ class RouterCore {
       }
       return match;
     };
-    this._handleNotFound = (matches, err, {
-      updateMatch = this.updateMatch
-    } = {}) => {
-      const routeCursor = this.routesById[err.routeId ?? ""] ?? this.routeTree;
-      const matchesByRouteId = {};
-      for (const match of matches) {
-        matchesByRouteId[match.routeId] = match;
-      }
-      if (!routeCursor.options.notFoundComponent && this.options?.defaultNotFoundComponent) {
-        routeCursor.options.notFoundComponent = this.options.defaultNotFoundComponent;
-      }
-      invariant(
-        routeCursor.options.notFoundComponent,
-        "No notFoundComponent found. Please set a notFoundComponent on your route or provide a defaultNotFoundComponent to the router."
-      );
-      const matchForRoute = matchesByRouteId[routeCursor.id];
-      invariant(
-        matchForRoute,
-        "Could not find match for route: " + routeCursor.id
-      );
-      updateMatch(matchForRoute.id, (prev) => ({
-        ...prev,
-        status: "notFound",
-        error: err,
-        isFetching: false
-      }));
-      if (err.routerCode === "BEFORE_LOAD" && routeCursor.parentRoute) {
-        err.routeId = routeCursor.parentRoute.id;
-        this._handleNotFound(matches, err, {
-          updateMatch
-        });
-      }
-    };
     this.hasNotFoundMatch = () => {
       return this.__store.state.matches.some(
         (d) => d.status === "notFound" || d.globalNotFound
@@ -1495,16 +938,16 @@ class RouterCore {
     const matches = [];
     const getParentContext = (parentMatch) => {
       const parentMatchId = parentMatch?.id;
-      const parentContext = !parentMatchId ? this.options.context ?? {} : parentMatch.context ?? this.options.context ?? {};
+      const parentContext = !parentMatchId ? this.options.context ?? void 0 : parentMatch.context ?? this.options.context ?? void 0;
       return parentContext;
     };
     matchedRoutes.forEach((route, index) => {
       const parentMatch = matches[index - 1];
       const [preMatchSearch, strictMatchSearch, searchError] = (() => {
         const parentSearch = parentMatch?.search ?? next.search;
-        const parentStrictSearch = parentMatch?._strictSearch ?? {};
+        const parentStrictSearch = parentMatch?._strictSearch ?? void 0;
         try {
-          const strictSearch = validateSearch(route.options.validateSearch, { ...parentSearch }) ?? {};
+          const strictSearch = validateSearch(route.options.validateSearch, { ...parentSearch }) ?? void 0;
           return [
             {
               ...parentSearch,
@@ -1558,7 +1001,7 @@ class RouterCore {
           _strictSearch: strictMatchSearch
         };
       } else {
-        const status = route.options.loader || route.options.beforeLoad || route.lazyFn || routeNeedsPreload(route) ? "pending" : "success";
+        const status = route.options.loader || route.options.beforeLoad || route.lazyFn || loadMatches.routeNeedsPreload(route) ? "pending" : "success";
         match = {
           id: matchId,
           index,
@@ -1574,7 +1017,10 @@ class RouterCore {
           isFetching: false,
           error: void 0,
           paramsError: parseErrors[index],
-          __routeContext: {},
+          __routeContext: void 0,
+          _nonReactive: {
+            loadPromise: utils.createControlledPromise()
+          },
           __beforeLoadContext: void 0,
           context: {},
           abortController: new AbortController(),
@@ -1588,7 +1034,6 @@ class RouterCore {
           headScripts: void 0,
           meta: void 0,
           staticData: route.options.staticData || {},
-          loadPromise: utils.createControlledPromise(),
           fullPath: route.fullPath
         };
       }
@@ -1610,19 +1055,21 @@ class RouterCore {
       if (!existingMatch && opts?._buildLocation !== true) {
         const parentMatch = matches[index - 1];
         const parentContext = getParentContext(parentMatch);
-        const contextFnContext = {
-          deps: match.loaderDeps,
-          params: match.params,
-          context: parentContext,
-          location: next,
-          navigate: (opts2) => this.navigate({ ...opts2, _fromLocation: next }),
-          buildLocation: this.buildLocation,
-          cause: match.cause,
-          abortController: match.abortController,
-          preload: !!match.preload,
-          matches
-        };
-        match.__routeContext = route.options.context?.(contextFnContext) ?? {};
+        if (route.options.context) {
+          const contextFnContext = {
+            deps: match.loaderDeps,
+            params: match.params,
+            context: parentContext ?? {},
+            location: next,
+            navigate: (opts2) => this.navigate({ ...opts2, _fromLocation: next }),
+            buildLocation: this.buildLocation,
+            cause: match.cause,
+            abortController: match.abortController,
+            preload: !!match.preload,
+            matches
+          };
+          match.__routeContext = route.options.context(contextFnContext) ?? void 0;
+        }
         match.context = {
           ...parentContext,
           ...match.__routeContext,
@@ -1681,20 +1128,6 @@ function validateSearch(validateSearch2, input) {
   }
   return {};
 }
-const componentTypes = [
-  "component",
-  "errorComponent",
-  "pendingComponent",
-  "notFoundComponent"
-];
-function routeNeedsPreload(route) {
-  for (const componentType of componentTypes) {
-    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;
@@ -1925,7 +1358,7 @@ function applySearchMiddleware({
           try {
             const validatedSearch = {
               ...result,
-              ...validateSearch(route.options.validateSearch, result) ?? {}
+              ...validateSearch(route.options.validateSearch, result) ?? void 0
             };
             return validatedSearch;
           } catch {
@@ -1963,7 +1396,6 @@ function applySearchMiddleware({
 exports.PathParamError = PathParamError;
 exports.RouterCore = RouterCore;
 exports.SearchParamError = SearchParamError;
-exports.componentTypes = componentTypes;
 exports.defaultSerializeError = defaultSerializeError;
 exports.getInitialRouterState = getInitialRouterState;
 exports.getLocationChangeInfo = getLocationChangeInfo;