react-router 8.4.0 → 8.5.1

package/dist/production/lib/dom/ssr/fog-of-war.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.4.0
+ * react-router v8.5.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -27,7 +27,13 @@ function getPathsWithAncestors(paths) {
 	return Array.from(result);
 }
 function isFogOfWarEnabled(routeDiscovery, ssr) {
-	return routeDiscovery.mode === "lazy" && ssr === true;
+	return routeDiscovery.mode === "lazy" && ssr;
+}
+const MANIFEST_MATCH_COST_LIMIT = 5e4;
+const MANIFEST_MATCH_COST_SEGMENT_THRESHOLD = 10;
+function shouldUseInitialRouteDiscovery(pathname, matchCost = 0) {
+	let segmentCount = pathname.split("/").length - 1;
+	return Math.max(segmentCount - 1, 0) * pathname.length + 1 > 7680 || segmentCount > MANIFEST_MATCH_COST_SEGMENT_THRESHOLD && segmentCount * matchCost > MANIFEST_MATCH_COST_LIMIT;
 }
 function getPartialManifest({ sri, ...manifest }, router) {
 	let routeIds = new Set(router.state.matches.map((m) => m.route.id));
@@ -49,15 +55,15 @@ function getPartialManifest({ sri, ...manifest }, router) {
 		sri: sri ? true : void 0
 	};
 }
-function getPatchRoutesOnNavigationFunction(getRouter, manifest, routeModules, ssr, routeDiscovery, isSpaMode, basename) {
+function getPatchRoutesOnNavigationFunction(getRouter, manifest, routeModules, ssr, routeDiscovery, isSpaMode, basename, fetchImplementation = (request) => fetch(request), serverOrigin, isApiOnly = false) {
 	if (!isFogOfWarEnabled(routeDiscovery, ssr)) return;
 	return async ({ path, patch, signal, fetcherKey }) => {
 		if (discoveredPaths.has(path)) return;
 		let { state } = getRouter();
-		await fetchAndApplyManifestPatches([path], fetcherKey ? window.location.href : createPath(state.navigation.location || state.location), manifest, routeModules, ssr, isSpaMode, basename, routeDiscovery.manifestPath, patch, signal);
+		await fetchAndApplyManifestPatches([path], fetcherKey ? window.location.href : createPath(state.navigation.location || state.location), manifest, routeModules, ssr, isSpaMode, basename, routeDiscovery.manifestPath, patch, signal, fetchImplementation, serverOrigin, isApiOnly);
 	};
 }
-function useFogOFWarDiscovery(router, manifest, routeModules, ssr, routeDiscovery, isSpaMode) {
+function useFogOFWarDiscovery(router, manifest, routeModules, ssr, routeDiscovery, isSpaMode, fetchImplementation = (request) => fetch(request), serverOrigin, isApiOnly = false) {
 	React$1.useEffect(() => {
 		if (!isFogOfWarEnabled(routeDiscovery, ssr) || window.navigator?.connection?.saveData === true) return;
 		function registerElement(el) {
@@ -77,7 +83,7 @@ function useFogOFWarDiscovery(router, manifest, routeModules, ssr, routeDiscover
 			});
 			if (lazyPaths.length === 0) return;
 			try {
-				await fetchAndApplyManifestPatches(lazyPaths, null, manifest, routeModules, ssr, isSpaMode, router.basename, routeDiscovery.manifestPath, router.patchRoutes);
+				await fetchAndApplyManifestPatches(lazyPaths, null, manifest, routeModules, ssr, isSpaMode, router.basename, routeDiscovery.manifestPath, router.patchRoutes, void 0, fetchImplementation, serverOrigin, isApiOnly);
 			} catch (e) {
 				console.error("Failed to fetch manifest patches", e);
 			}
@@ -102,9 +108,15 @@ function useFogOFWarDiscovery(router, manifest, routeModules, ssr, routeDiscover
 		manifest,
 		routeModules,
 		router,
-		routeDiscovery
+		routeDiscovery,
+		fetchImplementation,
+		serverOrigin,
+		isApiOnly
 	]);
 }
+function getManifestPathsParam(paths) {
+	return paths.slice().sort().map((path) => path.replace(/,/g, "%2C")).join(",");
+}
 function getManifestPath(_manifestPath, basename) {
 	let manifestPath = _manifestPath || "/__manifest";
 	return basename == null ? manifestPath : joinPaths([basename, manifestPath]);
@@ -154,12 +166,12 @@ async function handleClientVersionMismatch(needsReload, version, errorReloadPath
 	}
 	return reloadPromise;
 }
-async function fetchAndApplyManifestPatches(paths, errorReloadPath, manifest, routeModules, ssr, isSpaMode, basename, manifestPath, patchRoutes, signal) {
+async function fetchAndApplyManifestPatches(paths, errorReloadPath, manifest, routeModules, ssr, isSpaMode, basename, manifestPath, patchRoutes, signal, fetchImplementation = (request) => fetch(request), serverOrigin, isApiOnly = false) {
 	paths = getPathsWithAncestors(paths);
 	const searchParams = new URLSearchParams();
-	searchParams.set("paths", paths.sort().join(","));
+	searchParams.set("paths", getManifestPathsParam(paths));
 	searchParams.set("version", manifest.version);
-	let url = new URL(getManifestPath(manifestPath, basename), window.location.origin);
+	let url = new URL(getManifestPath(manifestPath, basename), serverOrigin ?? window.location.origin);
 	url.search = searchParams.toString();
 	if (url.toString().length > 7680) {
 		nextPaths.clear();
@@ -167,7 +179,7 @@ async function fetchAndApplyManifestPatches(paths, errorReloadPath, manifest, ro
 	}
 	let serverPatches;
 	try {
-		let res = await fetch(url, { signal });
+		let res = await fetchImplementation(new Request(url, { signal }), { type: "manifest" });
 		if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
 		if (await handleClientVersionMismatch(res.status === 204 && res.headers.has("X-Remix-Reload-Document"), manifest.version, errorReloadPath)) return;
 		serverPatches = await res.json();
@@ -187,7 +199,7 @@ async function fetchAndApplyManifestPatches(paths, errorReloadPath, manifest, ro
 	Object.values(patches).forEach((patch) => {
 		if (patch && (!patch.parentId || !patches[patch.parentId])) parentIds.add(patch.parentId);
 	});
-	parentIds.forEach((parentId) => patchRoutes(parentId || null, createClientRoutes(patches, routeModules, null, ssr, isSpaMode, parentId)));
+	parentIds.forEach((parentId) => patchRoutes(parentId || null, createClientRoutes(patches, routeModules, null, ssr, isSpaMode, parentId, void 0, void 0, isApiOnly)));
 }
 function addToFifoQueue(path, queue) {
 	if (queue.size >= discoveredPathsMaxSize) {
@@ -204,4 +216,4 @@ function debounce(callback, wait) {
 	};
 }
 //#endregion
-export { URL_LIMIT, getManifestPath, getPartialManifest, getPatchRoutesOnNavigationFunction, getPathsWithAncestors, handleClientVersionMismatch, isFogOfWarEnabled, useFogOFWarDiscovery };
+export { URL_LIMIT, getManifestPath, getManifestPathsParam, getPartialManifest, getPatchRoutesOnNavigationFunction, getPathsWithAncestors, handleClientVersionMismatch, isFogOfWarEnabled, shouldUseInitialRouteDiscovery, useFogOFWarDiscovery };

package/dist/production/lib/dom/ssr/hydration.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.4.0
+ * react-router v8.5.1
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/production/lib/dom/ssr/invariant.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.4.0
+ * react-router v8.5.1
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/production/lib/dom/ssr/links.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.4.0
+ * react-router v8.5.1
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/production/lib/dom/ssr/markup.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.4.0
+ * react-router v8.5.1
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/production/lib/dom/ssr/route-discovery.d.ts

@@ -0,0 +1,120 @@
+
+import { PatchRoutesOnNavigationFunction, RouteObject } from "../../router/utils.js";
+import { Router } from "../../router/router.js";
+import { ClientOnErrorFunction } from "../../components.js";
+import { RouteModules } from "./routeModules.js";
+import { RouterFetch } from "./single-fetch.js";
+import { ServerHandoff } from "../../server-runtime/serverHandoff.js";
+import { AssetsManifest } from "./entry.js";
+
+//#region lib/dom/ssr/route-discovery.d.ts
+/** A discovery response from a different build. */
+type ManifestMismatchEvent = {
+  source: "eager" | "navigation" | "fetcher" | "imperative";
+  version: string;
+  reloadUrl: string | null;
+  loadAllRoutes(): Promise<void>;
+  stopPropagation(): void; /** Run built-in recovery for this source, at most once per mismatch event. */
+  defaultBehavior(): Promise<void>;
+};
+/** The result of imperative route discovery. */
+type DiscoveryResult = {
+  type: "success";
+} | {
+  type: "version-mismatch";
+} | {
+  type: "aborted";
+};
+/** Options for {@link unstable_useRouteDiscovery}. */
+type RouteDiscoveryOptions = {
+  onManifestMismatch?: (event: ManifestMismatchEvent) => void | Promise<void>;
+};
+type Registration = {
+  current: RouteDiscoveryOptions;
+};
+type DiscoveryState = "partial" | "loading" | "complete";
+type RouteDiscoverySsrInfo = {
+  manifest: AssetsManifest;
+  routeModules: RouteModules;
+  router: Router | undefined;
+  context: Pick<ServerHandoff, "ssr" | "routeDiscovery" | "isSpaMode" | "basename" | "unstable_apiServerOrigin" | "unstable_apiOnly">;
+};
+declare class RouteDiscoveryRuntime {
+  private ssrInfo;
+  readonly enabled: boolean;
+  readonly discoveredPaths: Set<string>;
+  readonly nextPaths: Set<string>;
+  state: DiscoveryState;
+  ready: boolean;
+  private registrations;
+  private listeners;
+  private fullLoadErrorListeners;
+  private fullLoad?;
+  private loadedManifest?;
+  private mismatch?;
+  private fetchImplementation;
+  private loadManifest;
+  onError?: ClientOnErrorFunction;
+  constructor(ssrInfo: RouteDiscoverySsrInfo, {
+    fetch: fetchImplementation,
+    loadManifest
+  }?: {
+    fetch?: RouterFetch;
+    loadManifest?: () => Promise<AssetsManifest>;
+  });
+  private get router();
+  private loadManifestAsset;
+  subscribe: (listener: () => void) => () => void;
+  private update;
+  markReady: () => void;
+  register(registration: Registration): () => void;
+  private isComplete;
+  loadAllRoutes: () => Promise<void>;
+  reportError(error: unknown): void;
+  private dispatchMismatch;
+  private requestUrl;
+  discoverRoutes: (paths: string[], options?: {
+    signal?: AbortSignal;
+  }) => Promise<DiscoveryResult>;
+  discover(paths: string[], source: ManifestMismatchEvent["source"], reloadUrl: string | null, signal?: AbortSignal, patch?: (routeId: string | null, children: RouteObject[], unstable_allowElementMutations?: boolean) => void): Promise<DiscoveryResult>;
+}
+/**
+ * Control lazy route discovery in Framework Mode with `future.unstable_customRouteDiscovery`
+ * enabled. This allows you to imperatively discover routes as well as add custom behavior
+ * when a manifest version mismatch is detected.  Calling `loadAllRoutes` will load the entire
+ * route manifest for the current (potentially stale) client version - this requires that prior
+ * client artifacts are still available on your CDN _and_ you have not made breaking changes to
+ * the API contracts of your loaders and actions.
+ *
+ * See the [Route Discovery guide](../../how-to/route-discovery) for more information and examples.
+ *
+ * @example
+ * let { state, discoverRoutes, loadAllRoutes } = unstable_useRouteDiscovery({
+ *   onManifestMismatch: async (event) => {
+ *     // Eagerly load the complete route tree for this client without requiring a hard reload
+ *     await event.loadAllRoutes();
+ *   },
+ * });
+ *
+ * // Eagerly discover specific routes
+ * discoverRoutes(["/a", "/b"]);
+ *
+ * @name unstable_useRouteDiscovery
+ * @public
+ * @category Hooks
+ * @mode framework
+ * @param options An awaited manifest-mismatch handler.
+ * @returns The client version, full-manifest loading state, and discovery operations.
+ */
+declare function useRouteDiscovery(options?: RouteDiscoveryOptions): {
+  version: string;
+  state: DiscoveryState;
+  loadAllRoutes: () => Promise<void>;
+  discoverRoutes: (paths: string[], options?: {
+    signal?: AbortSignal;
+  }) => Promise<DiscoveryResult>;
+};
+declare function getCustomPatchRoutesOnNavigationFunction(getRouter: () => Router, runtime: RouteDiscoveryRuntime): PatchRoutesOnNavigationFunction | undefined;
+declare function useCustomRouteDiscovery(runtime: RouteDiscoveryRuntime, onError?: ClientOnErrorFunction): "partial" | "loading" | "complete";
+//#endregion
+export { DiscoveryResult, DiscoveryState, ManifestMismatchEvent, RouteDiscoveryOptions, RouteDiscoveryRuntime, getCustomPatchRoutesOnNavigationFunction, useCustomRouteDiscovery, useRouteDiscovery };

package/dist/production/lib/dom/ssr/route-discovery.js

@@ -0,0 +1,415 @@
+/**
+ * react-router v8.5.1
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+import { createPath, invariant } from "../../router/history.js";
+import { DiscoveryCancelledError, getRoutePattern, prependBasename } from "../../router/utils.js";
+import { createClientRoutes } from "./routes.js";
+import { getManifestPath, getManifestPathsParam, getPathsWithAncestors, handleClientVersionMismatch, isFogOfWarEnabled } from "./fog-of-war.js";
+import { useFrameworkContext } from "./components.js";
+import * as React$1 from "react";
+//#region lib/dom/ssr/route-discovery.ts
+var RouteDiscoveryRuntime = class {
+	ssrInfo;
+	enabled;
+	discoveredPaths = /* @__PURE__ */ new Set();
+	nextPaths = /* @__PURE__ */ new Set();
+	state;
+	ready = false;
+	registrations = /* @__PURE__ */ new Set();
+	listeners = /* @__PURE__ */ new Set();
+	fullLoadErrorListeners = /* @__PURE__ */ new Set();
+	fullLoad;
+	loadedManifest;
+	mismatch;
+	fetchImplementation;
+	loadManifest;
+	onError;
+	constructor(ssrInfo, { fetch: fetchImplementation = (request) => fetch(request), loadManifest } = {}) {
+		this.ssrInfo = ssrInfo;
+		this.fetchImplementation = fetchImplementation;
+		this.loadManifest = loadManifest ?? (() => this.loadManifestAsset());
+		let { manifest, context } = ssrInfo;
+		this.enabled = isFogOfWarEnabled(context.routeDiscovery, context.ssr);
+		this.state = this.enabled && !manifest.hmr ? "partial" : "complete";
+	}
+	get router() {
+		invariant(this.ssrInfo.router, "Router unavailable for route discovery");
+		return this.ssrInfo.router;
+	}
+	async loadManifestAsset() {
+		let { manifest } = this.ssrInfo;
+		if (this.loadedManifest) return this.loadedManifest;
+		try {
+			await import(
+				/* @vite-ignore */
+				/* webpackIgnore: true */
+				manifest.url
+);
+			invariant(window.__reactRouterManifest, "Unable to load the client manifest");
+			invariant(window.__reactRouterManifest !== manifest, "The full route manifest asset did not provide a manifest.");
+			this.loadedManifest = window.__reactRouterManifest;
+			return this.loadedManifest;
+		} finally {
+			window.__reactRouterManifest = manifest;
+		}
+	}
+	subscribe = (listener) => {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	};
+	update(state, ready = this.ready) {
+		this.state = state;
+		this.ready = ready;
+		this.listeners.forEach((listener) => listener());
+	}
+	markReady = () => {
+		if (!this.ready) this.update(this.state, true);
+	};
+	register(registration) {
+		this.registrations.add(registration);
+		return () => {
+			this.registrations.delete(registration);
+		};
+	}
+	isComplete() {
+		return this.state === "complete";
+	}
+	loadAllRoutes = () => {
+		if (this.isComplete()) return Promise.resolve();
+		if (this.fullLoad) return this.fullLoad;
+		let { manifest, routeModules, context } = this.ssrInfo;
+		this.fullLoad = Promise.resolve().then(async () => {
+			try {
+				let fullManifest = await this.loadManifest();
+				invariant(fullManifest.version === manifest.version, "The full route manifest does not match the running client version.");
+				applyManifestPatches(fullManifest.routes, manifest, routeModules, context.ssr, context.isSpaMode, this.router.patchRoutes, context.unstable_apiOnly === true);
+				this.nextPaths.clear();
+				this.update("complete");
+			} catch (error) {
+				this.fullLoadErrorListeners.forEach((listener) => listener(error));
+				this.update("partial");
+				throw error;
+			} finally {
+				this.fullLoad = void 0;
+			}
+		});
+		this.update("loading");
+		return this.fullLoad;
+	};
+	reportError(error) {
+		if (this.onError) {
+			let { location, matches } = this.router.state;
+			this.onError(error, {
+				location,
+				params: matches[0]?.params || {},
+				pattern: getRoutePattern(matches)
+			});
+		} else console.error(error);
+	}
+	async dispatchMismatch(source, reloadUrl) {
+		let { version } = this.ssrInfo.manifest;
+		let stopped = false;
+		let defaultBehavior;
+		let event = {
+			source,
+			reloadUrl,
+			version,
+			stopPropagation() {
+				stopped = true;
+			},
+			loadAllRoutes: this.loadAllRoutes,
+			defaultBehavior: () => {
+				defaultBehavior ??= Promise.resolve().then(async () => {
+					if (source !== "imperative" && !this.isComplete()) await handleClientVersionMismatch(true, version, reloadUrl);
+				});
+				return defaultBehavior;
+			}
+		};
+		let registrations = [...this.registrations].reverse().filter((registration) => registration.current.onManifestMismatch);
+		if (registrations.length === 0) return event.defaultBehavior();
+		let loadErrors = /* @__PURE__ */ new Set();
+		let onLoadError = (error) => loadErrors.add(error);
+		this.fullLoadErrorListeners.add(onLoadError);
+		try {
+			for (let registration of registrations) {
+				if (!this.registrations.has(registration)) continue;
+				try {
+					await registration.current.onManifestMismatch?.(event);
+				} catch (error) {
+					if (!loadErrors.has(error)) throw error;
+					this.reportError(error);
+					break;
+				}
+				if (stopped) break;
+			}
+		} finally {
+			this.fullLoadErrorListeners.delete(onLoadError);
+		}
+	}
+	requestUrl(paths) {
+		let { manifest, context } = this.ssrInfo;
+		let params = new URLSearchParams();
+		params.set("paths", getManifestPathsParam(paths));
+		params.set("version", manifest.version);
+		let url = new URL(getManifestPath(context.routeDiscovery.manifestPath, context.basename), context.unstable_apiServerOrigin ?? window.location.origin);
+		url.search = params.toString();
+		return url;
+	}
+	discoverRoutes = async (paths, options = {}) => {
+		if (options.signal?.aborted) return { type: "aborted" };
+		if (this.isComplete()) return { type: "success" };
+		let pathnames = paths.map((path) => {
+			invariant(path.startsWith("/") && !path.startsWith("//") && !path.includes("\\"), "discoverRoutes expects application-root paths beginning with a single '/'.");
+			return prependBasename({
+				pathname: new URL(path, window.location.origin).pathname,
+				basename: this.ssrInfo.context.basename || "/"
+			});
+		});
+		return this.discover(pathnames, "imperative", null, options.signal);
+	};
+	async discover(paths, source, reloadUrl, signal, patch = this.router.patchRoutes) {
+		let { manifest, routeModules, context } = this.ssrInfo;
+		if (signal?.aborted) return { type: "aborted" };
+		if (this.isComplete()) return { type: "success" };
+		let pending = getPathsWithAncestors(paths.filter((path) => !this.discoveredPaths.has(path)));
+		if (!pending.length) return { type: "success" };
+		let batches = [];
+		if (source !== "imperative") {
+			if (this.requestUrl(pending).href.length > 7680) {
+				this.nextPaths.clear();
+				return { type: "success" };
+			}
+			batches.push(pending);
+		} else {
+			let batch = [];
+			for (let path of pending) {
+				if (this.discoveredPaths.has(path)) continue;
+				if (this.requestUrl([path]).href.length > 7680) {
+					console.warn(`Unable to discover path exceeding the manifest request URL limit: ${path}`);
+					continue;
+				}
+				if (this.requestUrl([...batch, path]).href.length > 7680) {
+					batches.push(batch);
+					batch = [];
+				}
+				batch.push(path);
+			}
+			if (batch.length) batches.push(batch);
+		}
+		for (let batch of batches) try {
+			if (signal?.aborted) return { type: "aborted" };
+			if (this.isComplete()) return { type: "success" };
+			let response;
+			try {
+				response = await this.fetchImplementation(new Request(this.requestUrl(batch), { signal }), { type: "manifest" });
+			} catch (error) {
+				if (signal?.aborted) return { type: "aborted" };
+				if (this.isComplete()) return { type: "success" };
+				throw error;
+			}
+			if (signal?.aborted) return { type: "aborted" };
+			if (this.isComplete()) return { type: "success" };
+			if (!response.ok) throw new Error(`${response.status} ${response.statusText}`);
+			if (response.status === 204 && response.headers.has("X-Remix-Reload-Document")) {
+				if (this.mismatch || [...this.registrations].some((r) => r.current.onManifestMismatch)) {
+					if (!this.mismatch) this.mismatch = Promise.resolve().then(() => this.dispatchMismatch(source, reloadUrl)).finally(() => {
+						this.mismatch = void 0;
+					});
+					await waitForDiscovery(this.mismatch, signal);
+				} else await waitForDiscovery(this.dispatchMismatch(source, reloadUrl), signal);
+				if (signal?.aborted) return { type: "aborted" };
+				return { type: this.isComplete() ? "success" : "version-mismatch" };
+			}
+			await handleClientVersionMismatch(false, manifest.version, reloadUrl);
+			let patches;
+			try {
+				patches = await response.json();
+			} catch (error) {
+				if (signal?.aborted) return { type: "aborted" };
+				if (this.isComplete()) return { type: "success" };
+				throw error;
+			}
+			if (signal?.aborted) return { type: "aborted" };
+			if (this.isComplete()) return { type: "success" };
+			applyManifestPatches(patches, manifest, routeModules, context.ssr, context.isSpaMode, patch, context.unstable_apiOnly === true);
+			batch.forEach((path) => {
+				if (this.discoveredPaths.size >= 1e3) this.discoveredPaths.delete(this.discoveredPaths.values().next().value);
+				this.discoveredPaths.add(path);
+			});
+		} catch (error) {
+			if (signal?.aborted) return { type: "aborted" };
+			throw error;
+		}
+		return { type: "success" };
+	}
+};
+function waitForDiscovery(promise, signal) {
+	return new Promise((resolve, reject) => {
+		let abort = () => resolve();
+		signal?.addEventListener("abort", abort, { once: true });
+		if (signal?.aborted) abort();
+		promise.then(() => resolve(), reject).finally(() => signal?.removeEventListener("abort", abort));
+	});
+}
+const serverLoad = () => Promise.resolve();
+const serverDiscover = async () => ({ type: "success" });
+/**
+* Control lazy route discovery in Framework Mode with `future.unstable_customRouteDiscovery`
+* enabled. This allows you to imperatively discover routes as well as add custom behavior
+* when a manifest version mismatch is detected.  Calling `loadAllRoutes` will load the entire
+* route manifest for the current (potentially stale) client version - this requires that prior
+* client artifacts are still available on your CDN _and_ you have not made breaking changes to
+* the API contracts of your loaders and actions.
+*
+* See the [Route Discovery guide](../../how-to/route-discovery) for more information and examples.
+*
+* @example
+* let { state, discoverRoutes, loadAllRoutes } = unstable_useRouteDiscovery({
+*   onManifestMismatch: async (event) => {
+*     // Eagerly load the complete route tree for this client without requiring a hard reload
+*     await event.loadAllRoutes();
+*   },
+* });
+*
+* // Eagerly discover specific routes
+* discoverRoutes(["/a", "/b"]);
+*
+* @name unstable_useRouteDiscovery
+* @public
+* @category Hooks
+* @mode framework
+* @param options An awaited manifest-mismatch handler.
+* @returns The client version, full-manifest loading state, and discovery operations.
+*/
+function useRouteDiscovery(options = {}) {
+	let context = useFrameworkContext();
+	invariant(context.future.unstable_customRouteDiscovery, "unstable_useRouteDiscovery requires future.unstable_customRouteDiscovery to be enabled in react-router.config.ts.");
+	invariant(context.manifest.url, "unstable_useRouteDiscovery is not supported in RSC mode.");
+	let runtime = context.routeDiscoveryRuntime;
+	let registration = React$1.useRef({ current: options });
+	let hasHandlers = Boolean(options.onManifestMismatch);
+	React$1.useLayoutEffect(() => {
+		registration.current.current = options;
+	});
+	React$1.useLayoutEffect(() => {
+		if (hasHandlers) return runtime?.register(registration.current);
+	}, [runtime, hasHandlers]);
+	let state = context.routeDiscoveryState ?? (isFogOfWarEnabled(context.routeDiscovery, context.ssr) && !context.manifest.hmr ? "partial" : "complete");
+	return {
+		version: context.manifest.version,
+		state,
+		loadAllRoutes: runtime?.loadAllRoutes || serverLoad,
+		discoverRoutes: runtime?.discoverRoutes || serverDiscover
+	};
+}
+function getCustomPatchRoutesOnNavigationFunction(getRouter, runtime) {
+	if (!runtime.enabled) return;
+	return async ({ path, patch, signal, fetcherKey }) => {
+		let { state } = getRouter();
+		if ((await runtime.discover([path], fetcherKey != null ? "fetcher" : "navigation", fetcherKey != null ? window.location.href : createPath(state.navigation.location || state.location), signal, patch)).type === "version-mismatch") throw new DiscoveryCancelledError();
+	};
+}
+function useCustomRouteDiscovery(runtime, onError) {
+	React$1.useLayoutEffect(() => {
+		runtime.onError = onError;
+	}, [runtime, onError]);
+	let [state, setState] = React$1.useState(runtime.state);
+	React$1.useLayoutEffect(() => {
+		let updateState = () => {
+			let nextState = runtime.state;
+			React$1.startTransition(() => setState(nextState));
+		};
+		let unsubscribe = runtime.subscribe(updateState);
+		updateState();
+		return unsubscribe;
+	}, [runtime]);
+	React$1.useEffect(() => {
+		if (!runtime.enabled || window.navigator?.connection?.saveData === true) return;
+		let { discoveredPaths, nextPaths } = runtime;
+		function registerElement(el) {
+			let path = el.tagName === "FORM" ? el.getAttribute("action") : el.getAttribute("href");
+			if (!path) return;
+			let pathname = el.tagName === "A" ? el.pathname : new URL(path, window.location.origin).pathname;
+			if (!discoveredPaths.has(pathname)) nextPaths.add(pathname);
+		}
+		let active = false;
+		async function fetchPatches() {
+			if (!active || runtime.state === "complete") return;
+			document.querySelectorAll("a[data-discover], form[data-discover]").forEach(registerElement);
+			let lazyPaths = Array.from(nextPaths.keys()).filter((path) => {
+				if (discoveredPaths.has(path)) {
+					nextPaths.delete(path);
+					return false;
+				}
+				return true;
+			});
+			if (lazyPaths.length === 0) return;
+			try {
+				await runtime.discover(lazyPaths, "eager", null);
+			} catch (e) {
+				runtime.reportError(e);
+			}
+		}
+		let debouncedFetchPatches = debounce(fetchPatches, 100);
+		let observer = new MutationObserver(() => debouncedFetchPatches());
+		function updateDiscovery() {
+			let { ready, state } = runtime;
+			if (!ready || state === "complete") {
+				active = false;
+				observer.disconnect();
+			} else if (!active) {
+				active = true;
+				observer.observe(document.documentElement, {
+					subtree: true,
+					childList: true,
+					attributes: true,
+					attributeFilter: [
+						"data-discover",
+						"href",
+						"action"
+					]
+				});
+				fetchPatches();
+			}
+		}
+		let unsubscribe = runtime.subscribe(updateDiscovery);
+		updateDiscovery();
+		return () => {
+			active = false;
+			unsubscribe();
+			observer.disconnect();
+		};
+	}, [runtime]);
+	return state;
+}
+function applyManifestPatches(serverPatches, manifest, routeModules, ssr, isSpaMode, patchRoutes, isApiOnly) {
+	let knownRoutes = new Set(Object.keys(manifest.routes));
+	let patches = Object.values(serverPatches).reduce((acc, route) => {
+		if (route && !knownRoutes.has(route.id)) acc[route.id] = route;
+		return acc;
+	}, {});
+	let parentIds = /* @__PURE__ */ new Set();
+	Object.values(patches).forEach((patch) => {
+		if (patch && (!patch.parentId || !patches[patch.parentId])) parentIds.add(patch.parentId);
+	});
+	parentIds.forEach((parentId) => patchRoutes(parentId || null, createClientRoutes(patches, routeModules, null, ssr, isSpaMode, parentId, void 0, void 0, isApiOnly)));
+	Object.assign(manifest.routes, patches);
+}
+function debounce(callback, wait) {
+	let timeoutId;
+	return (...args) => {
+		window.clearTimeout(timeoutId);
+		timeoutId = window.setTimeout(() => callback(...args), wait);
+	};
+}
+//#endregion
+export { RouteDiscoveryRuntime, getCustomPatchRoutesOnNavigationFunction, useCustomRouteDiscovery, useRouteDiscovery };

package/dist/production/lib/dom/ssr/routeModules.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.4.0
+ * react-router v8.5.1
  *
  * Copyright (c) Remix Software Inc.
  *