@remix-run/router 1.16.1 → 1.17.0

package/dist/router.umd.js

@@ -1,5 +1,5 @@
 /**
- * @remix-run/router v1.16.1
+ * @remix-run/router v1.17.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -720,7 +720,7 @@
       manifest = {};
     }
     return routes.map((route, index) => {
-      let treePath = [...parentPath, index];
+      let treePath = [...parentPath, String(index)];
       let id = typeof route.id === "string" ? route.id : treePath.join("-");
       invariant(route.index !== true || !route.children, "Cannot specify children on an index route");
       invariant(!manifest[id], "Found a route id collision on id \"" + id + "\".  Route " + "id's must be globally unique within Data Router usages");
@@ -753,6 +753,9 @@
     if (basename === void 0) {
       basename = "/";
     }
+    return matchRoutesImpl(routes, locationArg, basename, false);
+  }
+  function matchRoutesImpl(routes, locationArg, basename, allowPartial) {
     let location = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
     let pathname = stripBasename(location.pathname || "/", basename);
     if (pathname == null) {
@@ -769,7 +772,7 @@
       // should be a safe operation.  This avoids needing matchRoutes to be
       // history-aware.
       let decoded = decodePath(pathname);
-      matches = matchRouteBranch(branches[i], decoded);
+      matches = matchRouteBranch(branches[i], decoded, allowPartial);
     }
     return matches;
   }
@@ -929,7 +932,10 @@
     // so they sort equally.
     0;
   }
-  function matchRouteBranch(branch, pathname) {
+  function matchRouteBranch(branch, pathname, allowPartial) {
+    if (allowPartial === void 0) {
+      allowPartial = false;
+    }
     let {
       routesMeta
     } = branch;
@@ -945,9 +951,18 @@
         caseSensitive: meta.caseSensitive,
         end
       }, remainingPathname);
-      if (!match) return null;
-      Object.assign(matchedParams, match.params);
       let route = meta.route;
+      if (!match && end && allowPartial && !routesMeta[routesMeta.length - 1].route.index) {
+        match = matchPath({
+          path: meta.relativePath,
+          caseSensitive: meta.caseSensitive,
+          end: false
+        }, remainingPathname);
+      }
+      if (!match) {
+        return null;
+      }
+      Object.assign(matchedParams, match.params);
       matches.push({
         // TODO: Can this as be avoided?
         params: matchedParams,
@@ -1671,6 +1686,8 @@
     let inFlightDataRoutes;
     let basename = init.basename || "/";
     let dataStrategyImpl = init.unstable_dataStrategy || defaultDataStrategy;
+    let patchRoutesOnMissImpl = init.unstable_patchRoutesOnMiss;
+
     // Config driven behavior flags
     let future = _extends({
       v7_fetcherPersist: false,
@@ -1699,7 +1716,7 @@
     let initialScrollRestored = init.hydrationData != null;
     let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);
     let initialErrors = null;
-    if (initialMatches == null) {
+    if (initialMatches == null && !patchRoutesOnMissImpl) {
       // If we do not match a user-provided-route, fall back to the root
       // to allow the error boundary to take over
       let error = getInternalRouterError(404, {
@@ -1715,13 +1732,15 @@
       };
     }
     let initialized;
-    let hasLazyRoutes = initialMatches.some(m => m.route.lazy);
-    let hasLoaders = initialMatches.some(m => m.route.loader);
-    if (hasLazyRoutes) {
+    if (!initialMatches) {
+      // We need to run patchRoutesOnMiss in initialize()
+      initialized = false;
+      initialMatches = [];
+    } else if (initialMatches.some(m => m.route.lazy)) {
       // All initialMatches need to be loaded before we're ready.  If we have lazy
       // functions around still then we'll need to run them in initialize()
       initialized = false;
-    } else if (!hasLoaders) {
+    } else if (!initialMatches.some(m => m.route.loader)) {
       // If we've got no loaders to run, then we're good to go
       initialized = true;
     } else if (future.v7_partialHydration) {
@@ -1848,6 +1867,10 @@
     // we don't need to update UI state if they change
     let blockerFunctions = new Map();
 
+    // Map of pending patchRoutesOnMiss() promises (keyed by path/matches) so
+    // that we only kick them off once for a given combo
+    let pendingPatchRoutes = new Map();
+
     // Flag to ignore the next history update, so we can revert the URL change on
     // a POP navigation that was blocked by the user without touching router state
     let ignoreNextHistoryUpdate = false;
@@ -2237,18 +2260,18 @@
       let loadingNavigation = opts && opts.overrideNavigation;
       let matches = matchRoutes(routesToUse, location, basename);
       let flushSync = (opts && opts.flushSync) === true;
+      let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);
+      if (fogOfWar.active && fogOfWar.matches) {
+        matches = fogOfWar.matches;
+      }
 
       // Short circuit with a 404 on the root error boundary if we match nothing
       if (!matches) {
-        let error = getInternalRouterError(404, {
-          pathname: location.pathname
-        });
         let {
-          matches: notFoundMatches,
+          error,
+          notFoundMatches,
           route
-        } = getShortCircuitMatches(routesToUse);
-        // Cancel all pending deferred on 404s since we don't keep any routes
-        cancelActiveDeferreds();
+        } = handleNavigational404(location.pathname);
         completeNavigation(location, {
           matches: notFoundMatches,
           loaderData: {},
@@ -2291,16 +2314,36 @@
         }];
       } else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {
         // Call action if we received an action submission
-        let actionResult = await handleAction(request, location, opts.submission, matches, {
+        let actionResult = await handleAction(request, location, opts.submission, matches, fogOfWar.active, {
           replace: opts.replace,
           flushSync
         });
         if (actionResult.shortCircuited) {
           return;
         }
+
+        // If we received a 404 from handleAction, it's because we couldn't lazily
+        // discover the destination route so we don't want to call loaders
+        if (actionResult.pendingActionResult) {
+          let [routeId, result] = actionResult.pendingActionResult;
+          if (isErrorResult(result) && isRouteErrorResponse(result.error) && result.error.status === 404) {
+            pendingNavigationController = null;
+            completeNavigation(location, {
+              matches: actionResult.matches,
+              loaderData: {},
+              errors: {
+                [routeId]: result.error
+              }
+            });
+            return;
+          }
+        }
+        matches = actionResult.matches || matches;
         pendingActionResult = actionResult.pendingActionResult;
         loadingNavigation = getLoadingNavigation(location, opts.submission);
         flushSync = false;
+        // No need to do fog of war matching again on loader execution
+        fogOfWar.active = false;
 
         // Create a GET request for the loaders
         request = createClientSideRequest(init.history, request.url, request.signal);
@@ -2309,9 +2352,10 @@
       // Call loaders
       let {
         shortCircuited,
+        matches: updatedMatches,
         loaderData,
         errors
-      } = await handleLoaders(request, location, matches, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult);
+      } = await handleLoaders(request, location, matches, fogOfWar.active, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult);
       if (shortCircuited) {
         return;
       }
@@ -2321,7 +2365,7 @@
       // been assigned to a new controller for the next navigation
       pendingNavigationController = null;
       completeNavigation(location, _extends({
-        matches
+        matches: updatedMatches || matches
       }, getActionDataForCommit(pendingActionResult), {
         loaderData,
         errors
@@ -2330,7 +2374,7 @@
 
     // Call the action matched by the leaf route for this navigation and handle
     // redirects/errors
-    async function handleAction(request, location, submission, matches, opts) {
+    async function handleAction(request, location, submission, matches, isFogOfWar, opts) {
       if (opts === void 0) {
         opts = {};
       }
@@ -2343,6 +2387,42 @@
       }, {
         flushSync: opts.flushSync === true
       });
+      if (isFogOfWar) {
+        let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
+        if (discoverResult.type === "aborted") {
+          return {
+            shortCircuited: true
+          };
+        } else if (discoverResult.type === "error") {
+          let {
+            error,
+            notFoundMatches,
+            route
+          } = handleDiscoverRouteError(location.pathname, discoverResult);
+          return {
+            matches: notFoundMatches,
+            pendingActionResult: [route.id, {
+              type: ResultType.error,
+              error
+            }]
+          };
+        } else if (!discoverResult.matches) {
+          let {
+            notFoundMatches,
+            error,
+            route
+          } = handleNavigational404(location.pathname);
+          return {
+            matches: notFoundMatches,
+            pendingActionResult: [route.id, {
+              type: ResultType.error,
+              error
+            }]
+          };
+        } else {
+          matches = discoverResult.matches;
+        }
+      }
 
       // Call our action and get the result
       let result;
@@ -2394,31 +2474,94 @@
         // to call and will commit it when we complete the navigation
         let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);
 
-        // By default, all submissions are REPLACE navigations, but if the
-        // action threw an error that'll be rendered in an errorElement, we fall
-        // back to PUSH so that the user can use the back button to get back to
-        // the pre-submission form location to try again
+        // By default, all submissions to the current location are REPLACE
+        // navigations, but if the action threw an error that'll be rendered in
+        // an errorElement, we fall back to PUSH so that the user can use the
+        // back button to get back to the pre-submission form location to try
+        // again
         if ((opts && opts.replace) !== true) {
           pendingAction = Action.Push;
         }
         return {
+          matches,
           pendingActionResult: [boundaryMatch.route.id, result]
         };
       }
       return {
+        matches,
         pendingActionResult: [actionMatch.route.id, result]
       };
     }
 
     // Call all applicable loaders for the given matches, handling redirects,
     // errors, etc.
-    async function handleLoaders(request, location, matches, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult) {
+    async function handleLoaders(request, location, matches, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult) {
       // Figure out the right navigation we want to use for data loading
       let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);
 
       // If this was a redirect from an action we don't have a "submission" but
       // we have it on the loading navigation so use that if available
       let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);
+
+      // If this is an uninterrupted revalidation, we remain in our current idle
+      // state.  If not, we need to switch to our loading state and load data,
+      // preserving any new action data or existing action data (in the case of
+      // a revalidation interrupting an actionReload)
+      // If we have partialHydration enabled, then don't update the state for the
+      // initial data load since it's not a "navigation"
+      let shouldUpdateNavigationState = !isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration);
+
+      // When fog of war is enabled, we enter our `loading` state earlier so we
+      // can discover new routes during the `loading` state.  We skip this if
+      // we've already run actions since we would have done our matching already.
+      // If the children() function threw then, we want to proceed with the
+      // partial matches it discovered.
+      if (isFogOfWar) {
+        if (shouldUpdateNavigationState) {
+          let actionData = getUpdatedActionData(pendingActionResult);
+          updateState(_extends({
+            navigation: loadingNavigation
+          }, actionData !== undefined ? {
+            actionData
+          } : {}), {
+            flushSync
+          });
+        }
+        let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
+        if (discoverResult.type === "aborted") {
+          return {
+            shortCircuited: true
+          };
+        } else if (discoverResult.type === "error") {
+          let {
+            error,
+            notFoundMatches,
+            route
+          } = handleDiscoverRouteError(location.pathname, discoverResult);
+          return {
+            matches: notFoundMatches,
+            loaderData: {},
+            errors: {
+              [route.id]: error
+            }
+          };
+        } else if (!discoverResult.matches) {
+          let {
+            error,
+            notFoundMatches,
+            route
+          } = handleNavigational404(location.pathname);
+          return {
+            matches: notFoundMatches,
+            loaderData: {},
+            errors: {
+              [route.id]: error
+            }
+          };
+        } else {
+          matches = discoverResult.matches;
+        }
+      }
       let routesToUse = inFlightDataRoutes || dataRoutes;
       let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, future.unstable_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult);
 
@@ -2447,41 +2590,20 @@
           shortCircuited: true
         };
       }
-
-      // If this is an uninterrupted revalidation, we remain in our current idle
-      // state.  If not, we need to switch to our loading state and load data,
-      // preserving any new action data or existing action data (in the case of
-      // a revalidation interrupting an actionReload)
-      // If we have partialHydration enabled, then don't update the state for the
-      // initial data load since it's not a "navigation"
-      if (!isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration)) {
-        revalidatingFetchers.forEach(rf => {
-          let fetcher = state.fetchers.get(rf.key);
-          let revalidatingFetcher = getLoadingFetcher(undefined, fetcher ? fetcher.data : undefined);
-          state.fetchers.set(rf.key, revalidatingFetcher);
-        });
-        let actionData;
-        if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {
-          // This is cast to `any` currently because `RouteData`uses any and it
-          // would be a breaking change to use any.
-          // TODO: v7 - change `RouteData` to use `unknown` instead of `any`
-          actionData = {
-            [pendingActionResult[0]]: pendingActionResult[1].data
-          };
-        } else if (state.actionData) {
-          if (Object.keys(state.actionData).length === 0) {
-            actionData = null;
-          } else {
-            actionData = state.actionData;
+      if (shouldUpdateNavigationState) {
+        let updates = {};
+        if (!isFogOfWar) {
+          // Only update navigation/actionNData if we didn't already do it above
+          updates.navigation = loadingNavigation;
+          let actionData = getUpdatedActionData(pendingActionResult);
+          if (actionData !== undefined) {
+            updates.actionData = actionData;
           }
         }
-        updateState(_extends({
-          navigation: loadingNavigation
-        }, actionData !== undefined ? {
-          actionData
-        } : {}, revalidatingFetchers.length > 0 ? {
-          fetchers: new Map(state.fetchers)
-        } : {}), {
+        if (revalidatingFetchers.length > 0) {
+          updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);
+        }
+        updateState(updates, {
           flushSync
         });
       }
@@ -2572,12 +2694,37 @@
       let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);
       let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;
       return _extends({
+        matches,
         loaderData,
         errors
       }, shouldUpdateFetchers ? {
         fetchers: new Map(state.fetchers)
       } : {});
     }
+    function getUpdatedActionData(pendingActionResult) {
+      if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {
+        // This is cast to `any` currently because `RouteData`uses any and it
+        // would be a breaking change to use any.
+        // TODO: v7 - change `RouteData` to use `unknown` instead of `any`
+        return {
+          [pendingActionResult[0]]: pendingActionResult[1].data
+        };
+      } else if (state.actionData) {
+        if (Object.keys(state.actionData).length === 0) {
+          return null;
+        } else {
+          return state.actionData;
+        }
+      }
+    }
+    function getUpdatedRevalidatingFetchers(revalidatingFetchers) {
+      revalidatingFetchers.forEach(rf => {
+        let fetcher = state.fetchers.get(rf.key);
+        let revalidatingFetcher = getLoadingFetcher(undefined, fetcher ? fetcher.data : undefined);
+        state.fetchers.set(rf.key, revalidatingFetcher);
+      });
+      return new Map(state.fetchers);
+    }
 
     // Trigger a fetcher load/submit for the given fetcher key
     function fetch(key, routeId, href, opts) {
@@ -2589,6 +2736,10 @@
       let routesToUse = inFlightDataRoutes || dataRoutes;
       let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, future.v7_relativeSplatPath, routeId, opts == null ? void 0 : opts.relative);
       let matches = matchRoutes(routesToUse, normalizedPath, basename);
+      let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);
+      if (fogOfWar.active && fogOfWar.matches) {
+        matches = fogOfWar.matches;
+      }
       if (!matches) {
         setFetcherError(key, routeId, getInternalRouterError(404, {
           pathname: normalizedPath
@@ -2611,7 +2762,7 @@
       let match = getTargetMatch(matches, path);
       pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
       if (submission && isMutationMethod(submission.formMethod)) {
-        handleFetcherAction(key, routeId, path, match, matches, flushSync, submission);
+        handleFetcherAction(key, routeId, path, match, matches, fogOfWar.active, flushSync, submission);
         return;
       }
 
@@ -2621,23 +2772,29 @@
         routeId,
         path
       });
-      handleFetcherLoader(key, routeId, path, match, matches, flushSync, submission);
+      handleFetcherLoader(key, routeId, path, match, matches, fogOfWar.active, flushSync, submission);
     }
 
     // Call the action for the matched fetcher.submit(), and then handle redirects,
     // errors, and revalidation
-    async function handleFetcherAction(key, routeId, path, match, requestMatches, flushSync, submission) {
+    async function handleFetcherAction(key, routeId, path, match, requestMatches, isFogOfWar, flushSync, submission) {
       interruptActiveLoads();
       fetchLoadMatches.delete(key);
-      if (!match.route.action && !match.route.lazy) {
-        let error = getInternalRouterError(405, {
-          method: submission.formMethod,
-          pathname: path,
-          routeId: routeId
-        });
-        setFetcherError(key, routeId, error, {
-          flushSync
-        });
+      function detectAndHandle405Error(m) {
+        if (!m.route.action && !m.route.lazy) {
+          let error = getInternalRouterError(405, {
+            method: submission.formMethod,
+            pathname: path,
+            routeId: routeId
+          });
+          setFetcherError(key, routeId, error, {
+            flushSync
+          });
+          return true;
+        }
+        return false;
+      }
+      if (!isFogOfWar && detectAndHandle405Error(match)) {
         return;
       }
 
@@ -2646,10 +2803,37 @@
       updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {
         flushSync
       });
-
-      // Call the action for the fetcher
       let abortController = new AbortController();
       let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);
+      if (isFogOfWar) {
+        let discoverResult = await discoverRoutes(requestMatches, path, fetchRequest.signal);
+        if (discoverResult.type === "aborted") {
+          return;
+        } else if (discoverResult.type === "error") {
+          let {
+            error
+          } = handleDiscoverRouteError(path, discoverResult);
+          setFetcherError(key, routeId, error, {
+            flushSync
+          });
+          return;
+        } else if (!discoverResult.matches) {
+          setFetcherError(key, routeId, getInternalRouterError(404, {
+            pathname: path
+          }), {
+            flushSync
+          });
+          return;
+        } else {
+          requestMatches = discoverResult.matches;
+          match = getTargetMatch(requestMatches, path);
+          if (detectAndHandle405Error(match)) {
+            return;
+          }
+        }
+      }
+
+      // Call the action for the fetcher
       fetchControllers.set(key, abortController);
       let originatingLoadId = incrementingLoadId;
       let actionResults = await callDataStrategy("action", fetchRequest, [match], requestMatches);
@@ -2799,15 +2983,39 @@
     }
 
     // Call the matched loader for fetcher.load(), handling redirects, errors, etc.
-    async function handleFetcherLoader(key, routeId, path, match, matches, flushSync, submission) {
+    async function handleFetcherLoader(key, routeId, path, match, matches, isFogOfWar, flushSync, submission) {
       let existingFetcher = state.fetchers.get(key);
       updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : undefined), {
         flushSync
       });
-
-      // Call the loader for this fetcher route match
       let abortController = new AbortController();
       let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);
+      if (isFogOfWar) {
+        let discoverResult = await discoverRoutes(matches, path, fetchRequest.signal);
+        if (discoverResult.type === "aborted") {
+          return;
+        } else if (discoverResult.type === "error") {
+          let {
+            error
+          } = handleDiscoverRouteError(path, discoverResult);
+          setFetcherError(key, routeId, error, {
+            flushSync
+          });
+          return;
+        } else if (!discoverResult.matches) {
+          setFetcherError(key, routeId, getInternalRouterError(404, {
+            pathname: path
+          }), {
+            flushSync
+          });
+          return;
+        } else {
+          matches = discoverResult.matches;
+          match = getTargetMatch(matches, path);
+        }
+      }
+
+      // Call the loader for this fetcher route match
       fetchControllers.set(key, abortController);
       let originatingLoadId = incrementingLoadId;
       let results = await callDataStrategy("loader", fetchRequest, [match], matches);
@@ -3191,6 +3399,39 @@
         return blockerKey;
       }
     }
+    function handleNavigational404(pathname) {
+      let error = getInternalRouterError(404, {
+        pathname
+      });
+      let routesToUse = inFlightDataRoutes || dataRoutes;
+      let {
+        matches,
+        route
+      } = getShortCircuitMatches(routesToUse);
+
+      // Cancel all pending deferred on 404s since we don't keep any routes
+      cancelActiveDeferreds();
+      return {
+        notFoundMatches: matches,
+        route,
+        error
+      };
+    }
+    function handleDiscoverRouteError(pathname, discoverResult) {
+      let matches = discoverResult.partialMatches;
+      let route = matches[matches.length - 1].route;
+      let error = getInternalRouterError(400, {
+        type: "route-discovery",
+        routeId: route.id,
+        pathname,
+        message: discoverResult.error != null && "message" in discoverResult.error ? discoverResult.error : String(discoverResult.error)
+      });
+      return {
+        notFoundMatches: matches,
+        route,
+        error
+      };
+    }
     function cancelActiveDeferreds(predicate) {
       let cancelledRouteIds = [];
       activeDeferreds.forEach((dfd, routeId) => {
@@ -3254,6 +3495,100 @@
       }
       return null;
     }
+    function checkFogOfWar(matches, routesToUse, pathname) {
+      if (patchRoutesOnMissImpl) {
+        if (!matches) {
+          let fogMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
+          return {
+            active: true,
+            matches: fogMatches || []
+          };
+        } else {
+          let leafRoute = matches[matches.length - 1].route;
+          if (leafRoute.path === "*") {
+            // If we matched a splat, it might only be because we haven't yet fetched
+            // the children that would match with a higher score, so let's fetch
+            // around and find out
+            let partialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
+            return {
+              active: true,
+              matches: partialMatches
+            };
+          }
+        }
+      }
+      return {
+        active: false,
+        matches: null
+      };
+    }
+    async function discoverRoutes(matches, pathname, signal) {
+      let partialMatches = matches;
+      let route = partialMatches.length > 0 ? partialMatches[partialMatches.length - 1].route : null;
+      while (true) {
+        try {
+          await loadLazyRouteChildren(patchRoutesOnMissImpl, pathname, partialMatches, dataRoutes || inFlightDataRoutes, manifest, mapRouteProperties, pendingPatchRoutes, signal);
+        } catch (e) {
+          return {
+            type: "error",
+            error: e,
+            partialMatches
+          };
+        }
+        if (signal.aborted) {
+          return {
+            type: "aborted"
+          };
+        }
+        let routesToUse = inFlightDataRoutes || dataRoutes;
+        let newMatches = matchRoutes(routesToUse, pathname, basename);
+        let matchedSplat = false;
+        if (newMatches) {
+          let leafRoute = newMatches[newMatches.length - 1].route;
+          if (leafRoute.index) {
+            // If we found an index route, we can stop
+            return {
+              type: "success",
+              matches: newMatches
+            };
+          }
+          if (leafRoute.path && leafRoute.path.length > 0) {
+            if (leafRoute.path === "*") {
+              // If we found a splat route, we can't be sure there's not a
+              // higher-scoring route down some partial matches trail so we need
+              // to check that out
+              matchedSplat = true;
+            } else {
+              // If we found a non-splat route, we can stop
+              return {
+                type: "success",
+                matches: newMatches
+              };
+            }
+          }
+        }
+        let newPartialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
+
+        // If we are no longer partially matching anything, this was either a
+        // legit splat match above, or it's a 404.  Also avoid loops if the
+        // second pass results in the same partial matches
+        if (!newPartialMatches || partialMatches.map(m => m.route.id).join("-") === newPartialMatches.map(m => m.route.id).join("-")) {
+          return {
+            type: "success",
+            matches: matchedSplat ? newMatches : null
+          };
+        }
+        partialMatches = newPartialMatches;
+        route = partialMatches[partialMatches.length - 1].route;
+        if (route.path === "*") {
+          // The splat is still our most accurate partial, so run with it
+          return {
+            type: "success",
+            matches: partialMatches
+          };
+        }
+      }
+    }
     function _internalSetRoutes(newRoutes) {
       manifest = {};
       inFlightDataRoutes = convertRoutesToDataRoutes(newRoutes, mapRouteProperties, undefined, manifest);
@@ -3289,6 +3624,9 @@
       dispose,
       getBlocker,
       deleteBlocker,
+      patchRoutes(routeId, children) {
+        return patchRoutes(routeId, children, dataRoutes || inFlightDataRoutes, manifest, mapRouteProperties);
+      },
       _internalFetchControllers: fetchControllers,
       _internalActiveDeferreds: activeDeferreds,
       // TODO: Remove setRoutes, it's temporary to avoid dealing with
@@ -4105,6 +4443,50 @@
     return arg.defaultShouldRevalidate;
   }
 
+  /**
+   * Idempotent utility to execute route.children() method to lazily load route
+   * definitions and update the routes/routeManifest
+   */
+  async function loadLazyRouteChildren(patchRoutesOnMissImpl, path, matches, routes, manifest, mapRouteProperties, pendingRouteChildren, signal) {
+    let key = [path, ...matches.map(m => m.route.id)].join("-");
+    try {
+      let pending = pendingRouteChildren.get(key);
+      if (!pending) {
+        pending = patchRoutesOnMissImpl({
+          path,
+          matches,
+          patch: (routeId, children) => {
+            if (!signal.aborted) {
+              patchRoutes(routeId, children, routes, manifest, mapRouteProperties);
+            }
+          }
+        });
+        pendingRouteChildren.set(key, pending);
+      }
+      if (pending && isPromise(pending)) {
+        await pending;
+      }
+    } finally {
+      pendingRouteChildren.delete(key);
+    }
+  }
+  function patchRoutes(routeId, children, routes, manifest, mapRouteProperties) {
+    if (routeId) {
+      var _route$children;
+      let route = manifest[routeId];
+      invariant(route, "No route found to patch children into: routeId = " + routeId);
+      let dataChildren = convertRoutesToDataRoutes(children, mapRouteProperties, [routeId, "patch", String(((_route$children = route.children) == null ? void 0 : _route$children.length) || "0")], manifest);
+      if (route.children) {
+        route.children.push(...dataChildren);
+      } else {
+        route.children = dataChildren;
+      }
+    } else {
+      let dataChildren = convertRoutesToDataRoutes(children, mapRouteProperties, ["patch", String(routes.length || "0")], manifest);
+      routes.push(...dataChildren);
+    }
+  }
+
   /**
    * Execute route.lazy() methods to lazily load route modules (loader, action,
    * shouldRevalidate) and update the routeManifest in place which shares objects
@@ -4648,13 +5030,16 @@
       pathname,
       routeId,
       method,
-      type
+      type,
+      message
     } = _temp5 === void 0 ? {} : _temp5;
     let statusText = "Unknown Server Error";
     let errorMessage = "Unknown @remix-run/router error";
     if (status === 400) {
       statusText = "Bad Request";
-      if (method && pathname && routeId) {
+      if (type === "route-discovery") {
+        errorMessage = "Unable to match URL \"" + pathname + "\" - the `children()` function for " + ("route `" + routeId + "` threw the following error:\n" + message);
+      } else if (method && pathname && routeId) {
         errorMessage = "You made a " + method + " request to \"" + pathname + "\" but " + ("did not provide a `loader` for route \"" + routeId + "\", ") + "so there is no way to handle the request.";
       } else if (type === "defer-action") {
         errorMessage = "defer() is not supported in actions";
@@ -4715,6 +5100,9 @@
     // /page#hash -> /page
     return false;
   }
+  function isPromise(val) {
+    return typeof val === "object" && val != null && "then" in val;
+  }
   function isHandlerResult(result) {
     return result != null && typeof result === "object" && "type" in result && "result" in result && (result.type === ResultType.data || result.type === ResultType.error);
   }
@@ -4980,7 +5368,6 @@
       }
     }
   }
-
   //#endregion
 
   exports.AbortedDeferredError = AbortedDeferredError;