react-router 8.3.1 → 8.5.0

package/dist/development/lib/dom/ssr/single-fetch.d.ts

@@ -1,14 +1,40 @@
 
+import { Action } from "../../router/history.js";
 import { DataStrategyFunction } from "../../router/utils.js";
 import { Router } from "../../router/router.js";
 import { RouteModules } from "./routeModules.js";
 import { AssetsManifest } from "./entry.js";
 //#region lib/dom/ssr/single-fetch.d.ts
 declare const SingleFetchRedirectSymbol: unique symbol;
-declare function getTurboStreamSingleFetchDataStrategy(getRouter: () => Router, manifest: AssetsManifest, routeModules: RouteModules, ssr: boolean): DataStrategyFunction;
+/**
+ * Describes the operation that initiated an internal router request.
+ *
+ * Requests that reload fetchers as part of a navigation, revalidation, or
+ * initialization redirect keep that initiating `type`. `fetcherKey` identifies
+ * the fetcher being loaded, or is `null` when the request targets route loaders
+ * or actions.
+ *
+ * `navigationType` is the history action (`"PUSH"`, `"REPLACE"`, or `"POP"`)
+ * for navigation-initiated data requests, including reloaded fetchers. It is
+ * `null` for initialization, fetcher, and revalidation requests. Manifest
+ * requests have no navigation type.
+ */
+type RouterFetchContext = {
+  type: "manifest";
+} | {
+  type: "navigation";
+  fetcherKey: string | null;
+  navigationType: Action;
+} | {
+  type: "initialization" | "fetcher" | "revalidation";
+  fetcherKey: string | null;
+  navigationType: null;
+};
+type RouterFetch = (request: Request, context: RouterFetchContext) => Promise<Response>;
+declare function getTurboStreamSingleFetchDataStrategy(getRouter: () => Router, manifest: AssetsManifest, routeModules: RouteModules, ssr: boolean, fetchImplementation?: RouterFetch, isApiOnly?: boolean, serverOrigin?: string): DataStrategyFunction;
 declare function decodeViaTurboStream(body: ReadableStream<Uint8Array>, global: Window | typeof globalThis): Promise<{
   done: Promise<void>;
   value: unknown;
 }>;
 //#endregion
-export { SingleFetchRedirectSymbol, decodeViaTurboStream, getTurboStreamSingleFetchDataStrategy };
+export { RouterFetch, RouterFetchContext, SingleFetchRedirectSymbol, decodeViaTurboStream, getTurboStreamSingleFetchDataStrategy };

package/dist/development/lib/dom/ssr/single-fetch.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.3.1
+ * react-router v8.5.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -56,7 +56,7 @@ function StreamTransfer({ context, identifier, reader, textDecoder, nonce }) {
 		nonce
 	})));
 }
-function getTurboStreamSingleFetchDataStrategy(getRouter, manifest, routeModules, ssr) {
+function getTurboStreamSingleFetchDataStrategy(getRouter, manifest, routeModules, ssr, fetchImplementation = (request) => fetch(request), isApiOnly = false, serverOrigin) {
 	let dataStrategy = getSingleFetchDataStrategyImpl(getRouter, (match) => {
 		let manifestRoute = manifest.routes[match.route.id];
 		invariant(manifestRoute, "Route not found in manifest");
@@ -64,10 +64,10 @@ function getTurboStreamSingleFetchDataStrategy(getRouter, manifest, routeModules
 			hasLoader: manifestRoute.hasLoader,
 			hasClientLoader: manifestRoute.hasClientLoader
 		};
-	}, fetchAndDecodeViaTurboStream, ssr);
+	}, fetchAndDecodeViaTurboStream(fetchImplementation, serverOrigin), ssr, void 0, isApiOnly);
 	return async (args) => args.runClientMiddleware(dataStrategy);
 }
-function getSingleFetchDataStrategyImpl(getRouter, getRouteInfo, fetchAndDecode, ssr, shouldAllowOptOut = () => true) {
+function getSingleFetchDataStrategyImpl(getRouter, getRouteInfo, fetchAndDecode, ssr, shouldAllowOptOut = () => true, isApiOnly = false) {
 	return async (args) => {
 		let { request, matches, fetcherKey } = args;
 		let router = getRouter();
@@ -78,7 +78,7 @@ function getSingleFetchDataStrategyImpl(getRouter, getRouteInfo, fetchAndDecode,
 		});
 		if (!ssr && !foundRevalidatingServerLoader) return nonSsrStrategy(args, getRouteInfo, fetchAndDecode);
 		if (fetcherKey) return singleFetchLoaderFetcherStrategy(args, fetchAndDecode);
-		return singleFetchLoaderNavigationStrategy(args, router, getRouteInfo, fetchAndDecode, ssr, shouldAllowOptOut);
+		return singleFetchLoaderNavigationStrategy(args, router, getRouteInfo, fetchAndDecode, ssr, shouldAllowOptOut, isApiOnly);
 	};
 }
 async function singleFetchActionStrategy(args, fetchAndDecode) {
@@ -101,28 +101,19 @@ async function singleFetchActionStrategy(args, fetchAndDecode) {
 async function nonSsrStrategy(args, getRouteInfo, fetchAndDecode) {
 	let matchesToLoad = args.matches.filter((m) => m.shouldCallHandler());
 	let results = {};
-	await Promise.all(matchesToLoad.map((m) => m.resolve(async (handler) => {
-		try {
+	await Promise.all(matchesToLoad.map(async (m) => {
+		let routeId = m.route.id;
+		results[routeId] = await m.resolve(async (handler) => {
 			let { hasClientLoader } = getRouteInfo(m);
-			let routeId = m.route.id;
-			let result = hasClientLoader ? await handler(async () => {
+			return hasClientLoader ? handler(async () => {
 				let { data } = await fetchAndDecode(args, [routeId]);
 				return unwrapSingleFetchResult(data, routeId);
-			}) : await handler();
-			results[m.route.id] = {
-				type: "data",
-				result
-			};
-		} catch (e) {
-			results[m.route.id] = {
-				type: "error",
-				result: e
-			};
-		}
-	})));
+			}) : handler();
+		});
+	}));
 	return results;
 }
-async function singleFetchLoaderNavigationStrategy(args, router, getRouteInfo, fetchAndDecode, ssr, shouldAllowOptOut = () => true) {
+async function singleFetchLoaderNavigationStrategy(args, router, getRouteInfo, fetchAndDecode, ssr, shouldAllowOptOut = () => true, isApiOnly = false) {
 	let routesParams = /* @__PURE__ */ new Set();
 	let foundOptOutRoute = false;
 	let routeDfds = args.matches.map(() => createDeferred());
@@ -171,7 +162,7 @@ async function singleFetchLoaderNavigationStrategy(args, router, getRouteInfo, f
 		}
 	})));
 	await Promise.all(routeDfds.map((d) => d.promise));
-	if ((!router.state.initialized && router.state.navigation.state === "idle" || routesParams.size === 0) && !window.__reactRouterHdrActive) singleFetchDfd.resolve({ routes: {} });
+	if ((!router.state.initialized && router.state.navigation.state === "idle" && !isApiOnly || routesParams.size === 0) && !window.__reactRouterHdrActive) singleFetchDfd.resolve({ routes: {} });
 	else {
 		let targetRoutes = ssr && foundOptOutRoute && routesParams.size > 0 ? [...routesParams.keys()] : void 0;
 		try {
@@ -225,61 +216,79 @@ function stripIndexParam(url) {
 	for (let toKeep of indexValuesToKeep) url.searchParams.append("index", toKeep);
 	return url;
 }
-function singleFetchUrl(reqUrl, extension) {
-	let url = typeof reqUrl === "string" ? new URL(reqUrl, typeof window === "undefined" ? "server://singlefetch/" : window.location.origin) : reqUrl;
+function singleFetchUrl(reqUrl, extension, serverOrigin) {
+	let url = typeof reqUrl === "string" ? new URL(reqUrl, serverOrigin ?? (typeof window === "undefined" ? "server://singlefetch/" : window.location.origin)) : new URL(reqUrl);
+	if (serverOrigin && url.origin !== serverOrigin) url = new URL(url.pathname + url.search + url.hash, serverOrigin);
 	if (url.pathname.endsWith("/")) url.pathname = `${url.pathname}_.${extension}`;
 	else url.pathname = `${url.pathname}.${extension}`;
 	return url;
 }
-async function fetchAndDecodeViaTurboStream(args, targetRoutes) {
-	let { request } = args;
-	let url = singleFetchUrl(request.url, "data");
-	if (request.method === "GET") {
-		url = stripIndexParam(url);
-		if (targetRoutes) url.searchParams.set("_routes", targetRoutes.join(","));
-	}
-	let res = await fetch(url, await createRequestInit(request));
-	if (res.status >= 400 && !res.headers.has("X-Remix-Response")) throw new ErrorResponseImpl(res.status, res.statusText, await res.text());
-	if (res.status === 204 && res.headers.has("X-Remix-Redirect")) return {
-		status: 202,
-		data: { redirect: {
-			redirect: res.headers.get("X-Remix-Redirect"),
-			status: Number(res.headers.get("X-Remix-Status") || "302"),
-			revalidate: res.headers.get("X-Remix-Revalidate") === "true",
-			reload: res.headers.get("X-Remix-Reload-Document") === "true",
-			replace: res.headers.get("X-Remix-Replace") === "true"
-		} }
-	};
-	if (NO_BODY_STATUS_CODES.has(res.status)) {
-		let routes = {};
-		if (targetRoutes && request.method !== "GET") routes[targetRoutes[0]] = { data: void 0 };
-		return {
-			status: res.status,
-			data: { routes }
-		};
-	}
-	invariant(res.body, "No response body to decode");
-	try {
-		let decoded = await decodeViaTurboStream(res.body, window);
-		let data;
+function fetchAndDecodeViaTurboStream(fetchImplementation, serverOrigin) {
+	return async (args, targetRoutes) => {
+		let { request } = args;
+		let url = singleFetchUrl(request.url, "data", serverOrigin);
 		if (request.method === "GET") {
-			let typed = decoded.value;
-			if (SingleFetchRedirectSymbol in typed) data = { redirect: typed[SingleFetchRedirectSymbol] };
-			else data = { routes: typed };
-		} else {
-			let typed = decoded.value;
-			let routeId = targetRoutes?.[0];
-			invariant(routeId, "No routeId found for single fetch call decoding");
-			if ("redirect" in typed) data = { redirect: typed };
-			else data = { routes: { [routeId]: typed } };
+			url = stripIndexParam(url);
+			if (targetRoutes) url.searchParams.set("_routes", targetRoutes.join(","));
 		}
-		return {
-			status: res.status,
-			data
+		let req = new Request(url, await createRequestInit(request));
+		invariant(args.unstable_initiator !== "static", "Static data strategy initiator used for a client data request");
+		let fetchContext;
+		if (args.unstable_initiator === "navigation") {
+			invariant(args.unstable_navigationType !== null, "Missing navigation type for a navigation data request");
+			fetchContext = {
+				type: "navigation",
+				fetcherKey: args.fetcherKey,
+				navigationType: args.unstable_navigationType
+			};
+		} else fetchContext = {
+			type: args.unstable_initiator,
+			fetcherKey: args.fetcherKey,
+			navigationType: null
 		};
-	} catch {
-		throw new Error("Unable to decode turbo-stream response");
-	}
+		let res = await fetchImplementation(req, fetchContext);
+		if (res.status >= 400 && !res.headers.has("X-Remix-Response")) throw new ErrorResponseImpl(res.status, res.statusText, await res.text());
+		if (res.status === 204 && res.headers.has("X-Remix-Redirect")) return {
+			status: 202,
+			data: { redirect: {
+				redirect: res.headers.get("X-Remix-Redirect"),
+				status: Number(res.headers.get("X-Remix-Status") || "302"),
+				revalidate: res.headers.get("X-Remix-Revalidate") === "true",
+				reload: res.headers.get("X-Remix-Reload-Document") === "true",
+				replace: res.headers.get("X-Remix-Replace") === "true"
+			} }
+		};
+		if (NO_BODY_STATUS_CODES.has(res.status)) {
+			let routes = {};
+			if (targetRoutes && request.method !== "GET") routes[targetRoutes[0]] = { data: void 0 };
+			return {
+				status: res.status,
+				data: { routes }
+			};
+		}
+		invariant(res.body, "No response body to decode");
+		try {
+			let decoded = await decodeViaTurboStream(res.body, window);
+			let data;
+			if (request.method === "GET") {
+				let typed = decoded.value;
+				if (SingleFetchRedirectSymbol in typed) data = { redirect: typed[SingleFetchRedirectSymbol] };
+				else data = { routes: typed };
+			} else {
+				let typed = decoded.value;
+				let routeId = targetRoutes?.[0];
+				invariant(routeId, "No routeId found for single fetch call decoding");
+				if ("redirect" in typed) data = { redirect: typed };
+				else data = { routes: { [routeId]: typed } };
+			}
+			return {
+				status: res.status,
+				data
+			};
+		} catch (cause) {
+			throw new Error("Unable to decode turbo-stream response", { cause });
+		}
+	};
 }
 function decodeViaTurboStream(body, global) {
 	return decode(body, { plugins: [(type, ...rest) => {

package/dist/development/lib/dom-export/dom-router-provider.js

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

package/dist/development/lib/dom-export/hydrated-router.d.ts

@@ -1,4 +1,5 @@
 
+import { RouterFetch } from "../dom/ssr/single-fetch.js";
 import { ClientInstrumentation } from "../router/instrumentation.js";
 import * as React$1 from "react";
 import { ClientOnErrorFunction, RouterInit } from "react-router";
@@ -107,6 +108,32 @@ interface HydratedRouterProps {
    * For more information, please see the [docs](../../explanation/react-transitions).
    */
   useTransitions?: boolean;
+  /**
+   * <docs-warning>This prop is experimental and subject to breaking
+   * changes.</docs-warning>
+   *
+   * Provide a custom implementation for `fetch`, which will be used to perform
+   * JavaScript-issued manifest and data requests. The context identifies the
+   * operation that initiated each request. Defaults to `window.fetch`.
+   *
+   * This prop is read when the singleton router is created. Changing it after
+   * router initialization has no effect. To use changing values such as auth
+   * tokens, read current application state inside the function rather than
+   * capturing values from a component render.
+   *
+   * See the [Custom Fetch guide](../../how-to/custom-fetch) for examples of
+   * authentication headers, cross-origin credentials, traversal caching, and
+   * retries.
+   *
+   * <docs-info>
+   * Browser-managed data prefetches from {@link Link}, {@link NavLink}, or
+   * {@link PrefetchPageLinks} use native `<link rel="prefetch">` elements
+   * and do not call this function. If your data requests require custom headers
+   * or other request transformations, use `prefetch="none"` on links and avoid
+   * rendering {@link PrefetchPageLinks}.
+   * </docs-info>
+   */
+  unstable_fetch?: RouterFetch;
 }
 /**
  * Framework-mode router component to be used to hydrate a router from a
@@ -118,6 +145,7 @@ interface HydratedRouterProps {
  * @param props Props
  * @param {dom.HydratedRouterProps.getContext} props.getContext n/a
  * @param {dom.HydratedRouterProps.onError} props.onError n/a
+ * @param {dom.HydratedRouterProps.unstable_fetch} props.unstable_fetch n/a
  * @returns A React element that represents the hydrated application.
  */
 declare function HydratedRouter(props: HydratedRouterProps): React$1.JSX.Element;

package/dist/development/lib/dom-export/hydrated-router.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.3.1
+ * react-router v8.5.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -11,10 +11,11 @@
 import { CRITICAL_CSS_DATA_ATTRIBUTE } from "../dom/ssr/components.js";
 import { RouterProvider as RouterProvider$1 } from "./dom-router-provider.js";
 import * as React$1 from "react";
-import { UNSAFE_FrameworkContext, UNSAFE_RemixErrorBoundary, UNSAFE_createBrowserHistory, UNSAFE_createClientRoutes, UNSAFE_createClientRoutesWithHMRRevalidationOptOut, UNSAFE_createRouter, UNSAFE_decodeViaTurboStream, UNSAFE_defaultMapRouteProperties, UNSAFE_getHydrationData, UNSAFE_getPatchRoutesOnNavigationFunction, UNSAFE_getTurboStreamSingleFetchDataStrategy, UNSAFE_hydrationRouteProperties, UNSAFE_invariant, UNSAFE_useFogOFWarDiscovery } from "react-router";
+import { UNSAFE_FrameworkContext, UNSAFE_RemixErrorBoundary, UNSAFE_RouteDiscoveryRuntime, UNSAFE_createBrowserHistory, UNSAFE_createClientRoutes, UNSAFE_createClientRoutesWithHMRRevalidationOptOut, UNSAFE_createRouter, UNSAFE_decodeViaTurboStream, UNSAFE_defaultMapRouteProperties, UNSAFE_getCustomPatchRoutesOnNavigationFunction, UNSAFE_getHydrationData, UNSAFE_getPatchRoutesOnNavigationFunction, UNSAFE_getTurboStreamSingleFetchDataStrategy, UNSAFE_hydrationRouteProperties, UNSAFE_invariant, UNSAFE_useCustomRouteDiscovery, UNSAFE_useFogOFWarDiscovery } from "react-router";
 //#region lib/dom-export/hydrated-router.tsx
 let ssrInfo = null;
 let router = null;
+let fetchImplementation = (request) => window.fetch(request);
 function initSsrInfo() {
 	if (!ssrInfo && window.__reactRouterContext && window.__reactRouterManifest && window.__reactRouterRouteModules) {
 		if (window.__reactRouterManifest.sri === true) {
@@ -31,14 +32,17 @@ function initSsrInfo() {
 			routeModules: window.__reactRouterRouteModules,
 			stateDecodingPromise: void 0,
 			router: void 0,
+			routeDiscoveryRuntime: void 0,
 			routerInitialized: false
 		};
 	}
 }
-function createHydratedRouter({ getContext, instrumentations }) {
+function createHydratedRouter({ getContext, instrumentations, fetch: fetchImplementation }) {
 	initSsrInfo();
 	if (!ssrInfo) throw new Error("You must be using the SSR features of React Router in order to skip passing a `router` prop to `<RouterProvider>`");
 	let localSsrInfo = ssrInfo;
+	let isApiOnly = ssrInfo.context.unstable_apiOnly === true;
+	let ssr = ssrInfo.context.ssr;
 	if (!ssrInfo.stateDecodingPromise) {
 		let stream = ssrInfo.context.stream;
 		UNSAFE_invariant(stream, "No stream found for single fetch decoding");
@@ -52,7 +56,7 @@ function createHydratedRouter({ getContext, instrumentations }) {
 	}
 	if (ssrInfo.stateDecodingPromise.error) throw ssrInfo.stateDecodingPromise.error;
 	if (!ssrInfo.stateDecodingPromise.value) throw ssrInfo.stateDecodingPromise;
-	let routes = UNSAFE_createClientRoutes(ssrInfo.manifest.routes, ssrInfo.routeModules, ssrInfo.context.state, ssrInfo.context.ssr, ssrInfo.context.isSpaMode);
+	let routes = UNSAFE_createClientRoutes(ssrInfo.manifest.routes, ssrInfo.routeModules, ssrInfo.context.state, ssr, ssrInfo.context.isSpaMode, "", void 0, void 0, isApiOnly);
 	let hydrationData = void 0;
 	if (ssrInfo.context.isSpaMode) {
 		let { loaderData } = ssrInfo.context.state;
@@ -67,25 +71,29 @@ function createHydratedRouter({ getContext, instrumentations }) {
 		}),
 		location: window.location,
 		basename: window.__reactRouterContext?.basename,
+		future: ssrInfo.context.future,
 		isSpaMode: ssrInfo.context.isSpaMode
 	});
 	if (window.history.state && window.history.state.masked) window.history.replaceState({
 		...window.history.state,
 		masked: void 0
 	}, "");
+	let discoveryRuntime = ssrInfo.context.future.unstable_customRouteDiscovery ? new UNSAFE_RouteDiscoveryRuntime(ssrInfo, { fetch: fetchImplementation }) : void 0;
 	let router = UNSAFE_createRouter({
 		routes,
 		history: UNSAFE_createBrowserHistory(),
+		future: { unstable_customRouteDiscovery: ssrInfo.context.future.unstable_customRouteDiscovery },
 		basename: ssrInfo.context.basename,
 		getContext,
 		hydrationData,
 		mapRouteProperties: UNSAFE_defaultMapRouteProperties,
 		hydrationRouteProperties: UNSAFE_hydrationRouteProperties,
 		instrumentations,
-		dataStrategy: UNSAFE_getTurboStreamSingleFetchDataStrategy(() => router, ssrInfo.manifest, ssrInfo.routeModules, ssrInfo.context.ssr),
-		patchRoutesOnNavigation: UNSAFE_getPatchRoutesOnNavigationFunction(() => router, ssrInfo.manifest, ssrInfo.routeModules, ssrInfo.context.ssr, ssrInfo.context.routeDiscovery, ssrInfo.context.isSpaMode, ssrInfo.context.basename)
+		dataStrategy: UNSAFE_getTurboStreamSingleFetchDataStrategy(() => router, ssrInfo.manifest, ssrInfo.routeModules, ssr, fetchImplementation, ssrInfo.context.unstable_apiOnly === true, ssrInfo.context.unstable_apiServerOrigin),
+		patchRoutesOnNavigation: discoveryRuntime ? UNSAFE_getCustomPatchRoutesOnNavigationFunction(() => router, discoveryRuntime) : UNSAFE_getPatchRoutesOnNavigationFunction(() => router, ssrInfo.manifest, ssrInfo.routeModules, ssr, ssrInfo.context.routeDiscovery, ssrInfo.context.isSpaMode, ssrInfo.context.basename, fetchImplementation, ssrInfo.context.unstable_apiServerOrigin, isApiOnly)
 	});
 	ssrInfo.router = router;
+	ssrInfo.routeDiscoveryRuntime = discoveryRuntime;
 	if (router.state.initialized) {
 		ssrInfo.routerInitialized = true;
 		router.initialize();
@@ -104,13 +112,18 @@ function createHydratedRouter({ getContext, instrumentations }) {
 * @param props Props
 * @param {dom.HydratedRouterProps.getContext} props.getContext n/a
 * @param {dom.HydratedRouterProps.onError} props.onError n/a
+* @param {dom.HydratedRouterProps.unstable_fetch} props.unstable_fetch n/a
 * @returns A React element that represents the hydrated application.
 */
 function HydratedRouter(props) {
-	if (!router) router = createHydratedRouter({
-		getContext: props.getContext,
-		instrumentations: props.instrumentations
-	});
+	if (!router) {
+		router = createHydratedRouter({
+			getContext: props.getContext,
+			instrumentations: props.instrumentations,
+			fetch: props.unstable_fetch ?? fetchImplementation
+		});
+		if (props.unstable_fetch) fetchImplementation = props.unstable_fetch;
+	}
 	let [criticalCss, setCriticalCss] = React$1.useState(process.env.NODE_ENV === "development" ? ssrInfo?.context.criticalCss : void 0);
 	React$1.useEffect(() => {
 		if (process.env.NODE_ENV === "development") setCriticalCss(void 0);
@@ -131,15 +144,23 @@ function HydratedRouter(props) {
 		});
 	}, [location]);
 	UNSAFE_invariant(ssrInfo, "ssrInfo unavailable for HydratedRouter");
-	UNSAFE_useFogOFWarDiscovery(router, ssrInfo.manifest, ssrInfo.routeModules, ssrInfo.context.ssr, ssrInfo.context.routeDiscovery, ssrInfo.context.isSpaMode);
+	let ssr = ssrInfo.context.ssr;
+	let discoveryRuntime = ssrInfo.routeDiscoveryRuntime;
+	let discoveryState;
+	if (discoveryRuntime) discoveryState = UNSAFE_useCustomRouteDiscovery(discoveryRuntime, props.onError);
+	else UNSAFE_useFogOFWarDiscovery(router, ssrInfo.manifest, ssrInfo.routeModules, ssr, ssrInfo.context.routeDiscovery, ssrInfo.context.isSpaMode, fetchImplementation, ssrInfo.context.unstable_apiServerOrigin, ssrInfo.context.unstable_apiOnly === true);
 	return /* @__PURE__ */ React$1.createElement(React$1.Fragment, null, /* @__PURE__ */ React$1.createElement(UNSAFE_FrameworkContext.Provider, { value: {
+		routeDiscoveryRuntime: discoveryRuntime,
+		routeDiscoveryState: discoveryState,
 		manifest: ssrInfo.manifest,
 		routeModules: ssrInfo.routeModules,
 		future: ssrInfo.context.future,
 		criticalCss,
 		ssr: ssrInfo.context.ssr,
 		isSpaMode: ssrInfo.context.isSpaMode,
-		routeDiscovery: ssrInfo.context.routeDiscovery
+		unstable_apiOnly: ssrInfo.context.unstable_apiOnly,
+		routeDiscovery: ssrInfo.context.routeDiscovery,
+		unstable_apiServerOrigin: ssrInfo.context.unstable_apiServerOrigin
 	} }, /* @__PURE__ */ React$1.createElement(UNSAFE_RemixErrorBoundary, { location }, /* @__PURE__ */ React$1.createElement(RouterProvider$1, {
 		router,
 		useTransitions: props.useTransitions,

package/dist/development/lib/errors.js

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

package/dist/development/lib/hooks.d.ts

@@ -3,8 +3,8 @@ import { Action, Location, Path, To } from "./router/history.js";
 import { ParamParseKey, Params, PathMatch, PathPattern, RouteObject, UIMatch } from "./router/utils.js";
 import { Blocker, BlockerFunction, NavigationStates, RelativeRoutingType, Router } from "./router/router.js";
 import { NavigateOptions } from "./context.js";
-import { RouteModules } from "./types/register.js";
 import { GetActionData, GetLoaderData, SerializeFrom } from "./types/route-data.js";
+import { RouteModules } from "./types/register.js";
 import * as React$1 from "react";
 
 //#region lib/hooks.d.ts
@@ -116,7 +116,7 @@ interface NavigateFunction {
  *   * These options only work in Framework and Data modes:
  *     * `flushSync`: Wrap the DOM updates in [`ReactDom.flushSync`](https://react.dev/reference/react-dom/flushSync)
  *     * `preventScrollReset`: Do not scroll back to the top of the page after navigation
- *     * `viewTransition`: Enable [`document.startViewTransition`](https://developer.mozilla.org/en-US/docs/Web/API/Document/startViewTransition) for this navigation
+ *     * `viewTransition`: **Deprecated.** Use React's [`<ViewTransition>`](https://react.dev/reference/react/ViewTransition) component instead. See the [migration guide](../../how-to/view-transitions).
  *
  * @example
  * import { useNavigate } from "react-router";
@@ -939,7 +939,7 @@ type unstable_RouterState = {
  * @example
  * import { unstable_useRouterState as useRouterState } from "react-router";
  *
- * let { active, pending } = unstable_useRouterState();
+ * let { active, pending } = useRouterState();
  *
  * // Active is always populated with the current location
  * active.location; // replaces `useLocation()`