react-router 7.9.4 → 7.9.6

package/dist/development/index.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v7.9.4
+ * react-router v7.9.6
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -11,11 +11,9 @@
 "use client";
 import {
   RSCDefaultRootErrorBoundary,
-  RSCHydratedRouter,
   RSCStaticRouter,
   ServerMode,
   ServerRouter,
-  createCallServer,
   createCookie,
   createCookieSessionStorage,
   createMemorySessionStorage,
@@ -25,13 +23,12 @@ import {
   createSessionStorage,
   deserializeErrors,
   getHydrationData,
-  getRSCStream,
   href,
   isCookie,
   isSession,
   routeRSCServerRequest,
   setDevServerHooks
-} from "./chunk-WY5IRSCW.mjs";
+} from "./chunk-G3INQAYP.mjs";
 import {
   Action,
   Await,
@@ -142,7 +139,7 @@ import {
   withComponentProps,
   withErrorBoundaryProps,
   withHydrateFallbackProps
-} from "./chunk-OIYGIGL5.mjs";
+} from "./chunk-4WY6JWTD.mjs";
 export {
   Await,
   BrowserRouter,
@@ -237,10 +234,7 @@ export {
   replace,
   resolvePath,
   HistoryRouter as unstable_HistoryRouter,
-  RSCHydratedRouter as unstable_RSCHydratedRouter,
   RSCStaticRouter as unstable_RSCStaticRouter,
-  createCallServer as unstable_createCallServer,
-  getRSCStream as unstable_getRSCStream,
   routeRSCServerRequest as unstable_routeRSCServerRequest,
   setDevServerHooks as unstable_setDevServerHooks,
   usePrompt as unstable_usePrompt,

package/dist/development/{routeModules-D5iJ6JYT.d.ts → instrumentation-Unc20tLk.d.ts}

@@ -1,6 +1,16 @@
 import * as React from 'react';
 import { ComponentType, ReactElement } from 'react';
 
+/**
+ * An augmentable interface users can modify in their app-code to opt into
+ * future-flag-specific types
+ */
+interface Future {
+}
+type MiddlewareEnabled = Future extends {
+    v8_middleware: infer T extends boolean;
+} ? T : false;
+
 /**
  * Actions represent the type of change to a location value.
  */
@@ -206,16 +216,6 @@ type UrlHistoryOptions = {
     v5Compat?: boolean;
 };
 
-/**
- * An augmentable interface users can modify in their app-code to opt into
- * future-flag-specific types
- */
-interface Future {
-}
-type MiddlewareEnabled = Future extends {
-    v8_middleware: infer T extends boolean;
-} ? T : false;
-
 type MaybePromise<T> = T | Promise<T>;
 /**
  * Map of routeId -> data returned from a loader/action/error
@@ -395,6 +395,11 @@ type DefaultContext = MiddlewareEnabled extends true ? Readonly<RouterContextPro
 interface DataFunctionArgs<Context> {
     /** A {@link https://developer.mozilla.org/en-US/docs/Web/API/Request Fetch Request instance} which you can use to read headers (like cookies, and {@link https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams URLSearchParams} from the request. */
     request: Request;
+    /**
+     * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
+     * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
+     */
+    unstable_pattern: string;
     /**
      * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
      * @example
@@ -615,7 +620,7 @@ type AgnosticPatchRoutesOnNavigationFunction<O extends AgnosticRouteObject = Agn
  * properties from framework-agnostic properties
  */
 interface MapRoutePropertiesFunction {
-    (route: AgnosticRouteObject): {
+    (route: AgnosticDataRouteObject): {
         hasErrorBoundary: boolean;
     } & Record<string, any>;
 }
@@ -1040,6 +1045,16 @@ declare class ErrorResponseImpl implements ErrorResponse {
  */
 declare function isRouteErrorResponse(error: any): error is ErrorResponse;
 
+/**
+ * An object of unknown type for route loaders and actions provided by the
+ * server's `getLoadContext()` function.  This is defined as an empty interface
+ * specifically so apps can leverage declaration merging to augment this type
+ * globally: https://www.typescriptlang.org/docs/handbook/declaration-merging.html
+ */
+interface AppLoadContext {
+    [key: string]: unknown;
+}
+
 /**
  * A Router instance manages all navigation and data loading/mutations
  */
@@ -1324,6 +1339,7 @@ interface RouterInit {
     history: History;
     basename?: string;
     getContext?: () => MaybePromise<RouterContextProvider>;
+    unstable_instrumentations?: unstable_ClientInstrumentation[];
     mapRouteProperties?: MapRoutePropertiesFunction;
     future?: Partial<FutureConfig>;
     hydrationRouteProperties?: string[];
@@ -1597,6 +1613,7 @@ declare function createRouter(init: RouterInit): Router$1;
 interface CreateStaticHandlerOptions {
     basename?: string;
     mapRouteProperties?: MapRoutePropertiesFunction;
+    unstable_instrumentations?: Pick<unstable_ServerInstrumentation, "route">[];
     future?: {};
 }
 
@@ -1637,6 +1654,55 @@ interface MemoryRouterOpts {
      * Index of `initialEntries` the application should initialize to
      */
     initialIndex?: number;
+    /**
+     * Array of instrumentation objects allowing you to instrument the router and
+     * individual routes prior to router initialization (and on any subsequently
+     * added routes via `route.lazy` or `patchRoutesOnNavigation`).  This is
+     * mostly useful for observability such as wrapping navigations, fetches,
+     * as well as route loaders/actions/middlewares with logging and/or performance
+     * tracing.
+     *
+     * ```tsx
+     * let router = createBrowserRouter(routes, {
+     *   unstable_instrumentations: [logging]
+     * });
+     *
+     *
+     * let logging = {
+     *   router({ instrument }) {
+     *     instrument({
+     *       navigate: (impl, info) => logExecution(`navigate ${info.to}`, impl),
+     *       fetch: (impl, info) => logExecution(`fetch ${info.to}`, impl)
+     *     });
+     *   },
+     *   route({ instrument, id }) {
+     *     instrument({
+     *       middleware: (impl, info) => logExecution(
+     *         `middleware ${info.request.url} (route ${id})`,
+     *         impl
+     *       ),
+     *       loader: (impl, info) => logExecution(
+     *         `loader ${info.request.url} (route ${id})`,
+     *         impl
+     *       ),
+     *       action: (impl, info) => logExecution(
+     *         `action ${info.request.url} (route ${id})`,
+     *         impl
+     *       ),
+     *     })
+     *   }
+     * };
+     *
+     * async function logExecution(label: string, impl: () => Promise<void>) {
+     *   let start = performance.now();
+     *   console.log(`start ${label}`);
+     *   await impl();
+     *   let duration = Math.round(performance.now() - start);
+     *   console.log(`end ${label} (${duration}ms)`);
+     * }
+     * ```
+     */
+    unstable_instrumentations?: unstable_ClientInstrumentation[];
     /**
      * Override the default data strategy of loading in parallel.
      * Only intended for advanced usage.
@@ -1664,6 +1730,7 @@ interface MemoryRouterOpts {
  * @param {MemoryRouterOpts.hydrationData} opts.hydrationData n/a
  * @param {MemoryRouterOpts.initialEntries} opts.initialEntries n/a
  * @param {MemoryRouterOpts.initialIndex} opts.initialIndex n/a
+ * @param {MemoryRouterOpts.unstable_instrumentations} opts.unstable_instrumentations n/a
  * @param {MemoryRouterOpts.patchRoutesOnNavigation} opts.patchRoutesOnNavigation n/a
  * @returns An initialized {@link DataRouter} to pass to {@link RouterProvider | `<RouterProvider>`}
  */
@@ -1673,7 +1740,11 @@ declare function createMemoryRouter(routes: RouteObject[], opts?: MemoryRouterOp
  * and rendering errors via `componentDidCatch`
  */
 interface unstable_ClientOnErrorFunction {
-    (error: unknown, errorInfo?: React.ErrorInfo): void;
+    (error: unknown, info: {
+        location: Location;
+        params: Params;
+        errorInfo?: React.ErrorInfo;
+    }): void;
 }
 /**
  * @category Types
@@ -2676,16 +2747,6 @@ interface PageLinkDescriptor extends Omit<HtmlLinkDescriptor, "href" | "rel" | "
 }
 type LinkDescriptor = HtmlLinkDescriptor | PageLinkDescriptor;
 
-/**
- * An object of unknown type for route loaders and actions provided by the
- * server's `getLoadContext()` function.  This is defined as an empty interface
- * specifically so apps can leverage declaration merging to augment this type
- * globally: https://www.typescriptlang.org/docs/handbook/declaration-merging.html
- */
-interface AppLoadContext {
-    [key: string]: unknown;
-}
-
 type Serializable = undefined | null | boolean | string | symbol | number | Array<Serializable> | {
     [key: PropertyKey]: Serializable;
 } | bigint | Date | URL | RegExp | Error | Map<Serializable, Serializable> | Set<Serializable> | Promise<Serializable>;
@@ -2761,6 +2822,11 @@ type ClientDataFunctionArgs<Params> = {
      * }
      **/
     params: Params;
+    /**
+     * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
+     * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
+     */
+    unstable_pattern: string;
     /**
      * When `future.v8_middleware` is not enabled, this is undefined.
      *
@@ -2789,6 +2855,11 @@ type ServerDataFunctionArgs<Params> = {
      * }
      **/
     params: Params;
+    /**
+     * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
+     * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
+     */
+    unstable_pattern: string;
     /**
      * Without `future.v8_middleware` enabled, this is the context passed in
      * to your server adapter's `getLoadContext` function. It's a way to bridge the
@@ -2914,7 +2985,7 @@ type LayoutComponent = ComponentType<{
  * A function that defines `<link>` tags to be inserted into the `<head>` of
  * the document on route transitions.
  *
- * @see https://remix.run/route/meta
+ * @see https://reactrouter.com/start/framework/route-module#meta
  */
 interface LinksFunction {
     (): LinkDescriptor[];
@@ -3031,8 +3102,90 @@ type RouteComponent = ComponentType<{}>;
 /**
  * An arbitrary object that is associated with a route.
  *
- * @see https://remix.run/route/handle
+ * @see https://reactrouter.com/how-to/using-handle
  */
 type RouteHandle = unknown;
 
-export { type PatchRoutesOnNavigationFunction as $, Action as A, type BlockerFunction as B, type ClientDataFunctionArgs as C, type DataStrategyResult as D, type ErrorBoundaryType as E, type Func as F, type GetLoaderData as G, type HydrationState as H, type InitialEntry as I, type AppLoadContext as J, RouterContextProvider as K, type LinkDescriptor as L, type MetaDescriptor as M, type Normalize as N, type MiddlewareEnabled as O, type Pretty as P, type Equal as Q, type RouteModule$1 as R, type ServerDataFunctionArgs as S, type To as T, type UIMatch as U, type ClientActionFunction as V, type ClientLoaderFunction as W, type HeadersFunction as X, type ShouldRevalidateFunction as Y, type RouterInit as Z, type RouterState as _, type Location as a, Route as a$, type DataRouteObject as a0, type StaticHandler as a1, type GetScrollPositionFunction as a2, type GetScrollRestorationKeyFunction as a3, type StaticHandlerContext as a4, type Fetcher as a5, type NavigationStates as a6, type RouterSubscriber as a7, type RouterNavigateOptions as a8, type RouterFetchOptions as a9, matchRoutes as aA, redirect as aB, redirectDocument as aC, replace as aD, resolvePath as aE, type DataRouteMatch as aF, type Navigator as aG, type PatchRoutesOnNavigationFunctionArgs as aH, type RouteMatch as aI, AwaitContextProvider as aJ, type AwaitProps as aK, type IndexRouteProps as aL, type unstable_ClientOnErrorFunction as aM, type LayoutRouteProps as aN, type MemoryRouterOpts as aO, type MemoryRouterProps as aP, type NavigateProps as aQ, type OutletProps as aR, type PathRouteProps as aS, type RouteProps as aT, type RouterProps as aU, type RouterProviderProps as aV, type RoutesProps as aW, Await as aX, MemoryRouter as aY, Navigate as aZ, Outlet as a_, type RevalidationState as aa, type ActionFunctionArgs as ab, type DataStrategyFunctionArgs as ac, type DataStrategyMatch as ad, DataWithResponseInit as ae, type ErrorResponse as af, type FormEncType as ag, type FormMethod as ah, type HTMLFormMethod as ai, type LazyRouteFunction as aj, type LoaderFunctionArgs as ak, type MiddlewareFunction as al, type PathParam as am, type RedirectFunction as an, type RouterContext as ao, type ShouldRevalidateFunctionArgs as ap, createContext as aq, createPath as ar, parsePath as as, IDLE_NAVIGATION as at, IDLE_FETCHER as au, IDLE_BLOCKER as av, data as aw, generatePath as ax, isRouteErrorResponse as ay, matchPath as az, type MiddlewareNextFunction as b, Router as b0, RouterProvider as b1, Routes as b2, createMemoryRouter as b3, createRoutesFromChildren as b4, createRoutesFromElements as b5, renderMatches as b6, type ClientActionFunctionArgs as b7, type ClientLoaderFunctionArgs as b8, type HeadersArgs as b9, type History as bA, type FutureConfig as bB, type CreateStaticHandlerOptions as bC, type MetaArgs as ba, type PageLinkDescriptor as bb, type HtmlLinkDescriptor as bc, type Future as bd, type unstable_SerializesTo as be, createBrowserHistory as bf, invariant as bg, createRouter as bh, ErrorResponseImpl as bi, DataRouterContext as bj, DataRouterStateContext as bk, FetchersContext as bl, LocationContext as bm, NavigationContext as bn, RouteContext as bo, ViewTransitionContext as bp, hydrationRouteProperties as bq, mapRouteProperties as br, WithComponentProps as bs, withComponentProps as bt, WithHydrateFallbackProps as bu, withHydrateFallbackProps as bv, WithErrorBoundaryProps as bw, withErrorBoundaryProps as bx, type RouteManifest as by, type ServerRouteModule as bz, type ServerDataFrom as c, type GetActionData as d, type Router$1 as e, type RouteModules as f, type DataStrategyFunction as g, type NavigateOptions as h, type Blocker as i, type SerializeFrom as j, type RelativeRoutingType as k, type ParamParseKey as l, type Path as m, type PathPattern as n, type PathMatch as o, type Navigation as p, type Params as q, type RouteObject as r, type IndexRouteObject as s, type RouteComponentType as t, type HydrateFallbackType as u, type LoaderFunction as v, type ActionFunction as w, type MetaFunction as x, type LinksFunction as y, type NonIndexRouteObject as z };
+type unstable_ServerInstrumentation = {
+    handler?: unstable_InstrumentRequestHandlerFunction;
+    route?: unstable_InstrumentRouteFunction;
+};
+type unstable_ClientInstrumentation = {
+    router?: unstable_InstrumentRouterFunction;
+    route?: unstable_InstrumentRouteFunction;
+};
+type unstable_InstrumentRequestHandlerFunction = (handler: InstrumentableRequestHandler) => void;
+type unstable_InstrumentRouterFunction = (router: InstrumentableRouter) => void;
+type unstable_InstrumentRouteFunction = (route: InstrumentableRoute) => void;
+type unstable_InstrumentationHandlerResult = {
+    status: "success";
+    error: undefined;
+} | {
+    status: "error";
+    error: Error;
+};
+type InstrumentFunction<T> = (handler: () => Promise<unstable_InstrumentationHandlerResult>, info: T) => Promise<void>;
+type ReadonlyRequest = {
+    method: string;
+    url: string;
+    headers: Pick<Headers, "get">;
+};
+type ReadonlyContext = MiddlewareEnabled extends true ? Pick<RouterContextProvider, "get"> : Readonly<AppLoadContext>;
+type InstrumentableRoute = {
+    id: string;
+    index: boolean | undefined;
+    path: string | undefined;
+    instrument(instrumentations: RouteInstrumentations): void;
+};
+type RouteInstrumentations = {
+    lazy?: InstrumentFunction<RouteLazyInstrumentationInfo>;
+    "lazy.loader"?: InstrumentFunction<RouteLazyInstrumentationInfo>;
+    "lazy.action"?: InstrumentFunction<RouteLazyInstrumentationInfo>;
+    "lazy.middleware"?: InstrumentFunction<RouteLazyInstrumentationInfo>;
+    middleware?: InstrumentFunction<RouteHandlerInstrumentationInfo>;
+    loader?: InstrumentFunction<RouteHandlerInstrumentationInfo>;
+    action?: InstrumentFunction<RouteHandlerInstrumentationInfo>;
+};
+type RouteLazyInstrumentationInfo = undefined;
+type RouteHandlerInstrumentationInfo = Readonly<{
+    request: ReadonlyRequest;
+    params: LoaderFunctionArgs["params"];
+    unstable_pattern: string;
+    context: ReadonlyContext;
+}>;
+type InstrumentableRouter = {
+    instrument(instrumentations: RouterInstrumentations): void;
+};
+type RouterInstrumentations = {
+    navigate?: InstrumentFunction<RouterNavigationInstrumentationInfo>;
+    fetch?: InstrumentFunction<RouterFetchInstrumentationInfo>;
+};
+type RouterNavigationInstrumentationInfo = Readonly<{
+    to: string | number;
+    currentUrl: string;
+    formMethod?: HTMLFormMethod;
+    formEncType?: FormEncType;
+    formData?: FormData;
+    body?: any;
+}>;
+type RouterFetchInstrumentationInfo = Readonly<{
+    href: string;
+    currentUrl: string;
+    fetcherKey: string;
+    formMethod?: HTMLFormMethod;
+    formEncType?: FormEncType;
+    formData?: FormData;
+    body?: any;
+}>;
+type InstrumentableRequestHandler = {
+    instrument(instrumentations: RequestHandlerInstrumentations): void;
+};
+type RequestHandlerInstrumentations = {
+    request?: InstrumentFunction<RequestHandlerInstrumentationInfo>;
+};
+type RequestHandlerInstrumentationInfo = Readonly<{
+    request: ReadonlyRequest;
+    context: ReadonlyContext | undefined;
+}>;
+
+export { type RouterState as $, type ActionFunction as A, type BlockerFunction as B, type ClientActionFunction as C, type DataStrategyResult as D, type PathMatch as E, type Func as F, type GetLoaderData as G, type HeadersFunction as H, type Navigation as I, Action as J, type RouteObject as K, type Location as L, type MetaFunction as M, type Normalize as N, type InitialEntry as O, type Params as P, type HydrationState as Q, type RouteModule$1 as R, type ShouldRevalidateFunction as S, type To as T, type UIMatch as U, type IndexRouteObject as V, type RouteComponentType as W, type HydrateFallbackType as X, type ErrorBoundaryType as Y, type NonIndexRouteObject as Z, type Equal as _, type ClientLoaderFunction as a, type RouterProviderProps as a$, type PatchRoutesOnNavigationFunction as a0, type DataRouteObject as a1, type StaticHandler as a2, type GetScrollPositionFunction as a3, type GetScrollRestorationKeyFunction as a4, type StaticHandlerContext as a5, type Fetcher as a6, type NavigationStates as a7, type RouterSubscriber as a8, type RouterNavigateOptions as a9, IDLE_FETCHER as aA, IDLE_BLOCKER as aB, data as aC, generatePath as aD, isRouteErrorResponse as aE, matchPath as aF, matchRoutes as aG, redirect as aH, redirectDocument as aI, replace as aJ, resolvePath as aK, type DataRouteMatch as aL, type Navigator as aM, type PatchRoutesOnNavigationFunctionArgs as aN, type RouteMatch as aO, AwaitContextProvider as aP, type AwaitProps as aQ, type IndexRouteProps as aR, type unstable_ClientOnErrorFunction as aS, type LayoutRouteProps as aT, type MemoryRouterOpts as aU, type MemoryRouterProps as aV, type NavigateProps as aW, type OutletProps as aX, type PathRouteProps as aY, type RouteProps as aZ, type RouterProps as a_, type RouterFetchOptions as aa, type RevalidationState as ab, type ActionFunctionArgs as ac, type DataStrategyFunctionArgs as ad, type DataStrategyMatch as ae, DataWithResponseInit as af, type ErrorResponse as ag, type FormEncType as ah, type FormMethod as ai, type HTMLFormMethod as aj, type LazyRouteFunction as ak, type LoaderFunctionArgs as al, type MiddlewareFunction as am, type PathParam as an, type RedirectFunction as ao, type RouterContext as ap, type ShouldRevalidateFunctionArgs as aq, createContext as ar, createPath as as, parsePath as at, type unstable_ServerInstrumentation as au, type unstable_InstrumentRequestHandlerFunction as av, type unstable_InstrumentRouterFunction as aw, type unstable_InstrumentRouteFunction as ax, type unstable_InstrumentationHandlerResult as ay, IDLE_NAVIGATION as az, type LinksFunction as b, type RoutesProps as b0, Await as b1, MemoryRouter as b2, Navigate as b3, Outlet as b4, Route as b5, Router as b6, RouterProvider as b7, Routes as b8, createMemoryRouter as b9, WithHydrateFallbackProps as bA, withHydrateFallbackProps as bB, WithErrorBoundaryProps as bC, withErrorBoundaryProps as bD, type RouteManifest as bE, type ServerRouteModule as bF, type History as bG, type FutureConfig as bH, type CreateStaticHandlerOptions as bI, createRoutesFromChildren as ba, createRoutesFromElements as bb, renderMatches as bc, type ClientActionFunctionArgs as bd, type ClientLoaderFunctionArgs as be, type HeadersArgs as bf, type MetaArgs as bg, type PageLinkDescriptor as bh, type HtmlLinkDescriptor as bi, type Future as bj, type unstable_SerializesTo as bk, createBrowserHistory as bl, invariant as bm, createRouter as bn, ErrorResponseImpl as bo, DataRouterContext as bp, DataRouterStateContext as bq, FetchersContext as br, LocationContext as bs, NavigationContext as bt, RouteContext as bu, ViewTransitionContext as bv, hydrationRouteProperties as bw, mapRouteProperties as bx, WithComponentProps as by, withComponentProps as bz, RouterContextProvider as c, type LoaderFunction as d, type RouterInit as e, type LinkDescriptor as f, type Pretty as g, type MetaDescriptor as h, type ServerDataFunctionArgs as i, type MiddlewareNextFunction as j, type ClientDataFunctionArgs as k, type ServerDataFrom as l, type GetActionData as m, type Router$1 as n, type RouteModules as o, type DataStrategyFunction as p, type MiddlewareEnabled as q, type AppLoadContext as r, type NavigateOptions as s, type Blocker as t, type unstable_ClientInstrumentation as u, type SerializeFrom as v, type RelativeRoutingType as w, type ParamParseKey as x, type Path as y, type PathPattern as z };

package/dist/development/lib/types/internal.d.mts

@@ -1,6 +1,5 @@
-import { R as RouteModule, L as LinkDescriptor, F as Func, P as Pretty, M as MetaDescriptor, G as GetLoaderData, S as ServerDataFunctionArgs, C as ClientDataFunctionArgs, a as ServerDataFrom, N as Normalize, b as GetActionData } from '../../route-data-DZQOUSqV.mjs';
-import { L as Location, M as MiddlewareNextFunction, D as DataStrategyResult } from '../../context-DSyS5mLj.mjs';
-import { R as RouteFiles, P as Pages } from '../../register-CI4bTprK.mjs';
+import { R as RouteModule, h as LinkDescriptor, L as Location, F as Func, i as Pretty, j as MetaDescriptor, G as GetLoaderData, k as ServerDataFunctionArgs, l as MiddlewareNextFunction, m as ClientDataFunctionArgs, D as DataStrategyResult, n as ServerDataFrom, N as Normalize, o as GetActionData } from '../../router-CAvh_Drx.mjs';
+import { R as RouteFiles, P as Pages } from '../../register-QkB3HGjm.mjs';
 import 'react';
 
 type MaybePromise<T> = T | Promise<T>;

package/dist/development/lib/types/internal.d.ts

@@ -1,5 +1,5 @@
-import { R as RouteModule, L as LinkDescriptor, a as Location, F as Func, P as Pretty, M as MetaDescriptor, G as GetLoaderData, S as ServerDataFunctionArgs, b as MiddlewareNextFunction, C as ClientDataFunctionArgs, D as DataStrategyResult, c as ServerDataFrom, N as Normalize, d as GetActionData } from '../../routeModules-D5iJ6JYT.js';
-import { R as RouteFiles, P as Pages } from '../../register-C34pU-in.js';
+import { R as RouteModule, f as LinkDescriptor, L as Location, F as Func, g as Pretty, h as MetaDescriptor, G as GetLoaderData, i as ServerDataFunctionArgs, j as MiddlewareNextFunction, k as ClientDataFunctionArgs, D as DataStrategyResult, l as ServerDataFrom, N as Normalize, m as GetActionData } from '../../instrumentation-Unc20tLk.js';
+import { R as RouteFiles, P as Pages } from '../../register-BpU9rFBJ.js';
 import 'react';
 
 type MaybePromise<T> = T | Promise<T>;

package/dist/development/lib/types/internal.js

@@ -1,5 +1,5 @@
 "use strict";/**
- * react-router v7.9.4
+ * react-router v7.9.6
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/development/lib/types/internal.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v7.9.4
+ * react-router v7.9.6
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/{production/register-C34pU-in.d.ts → development/register-BpU9rFBJ.d.ts}

@@ -1,4 +1,4 @@
-import { R as RouteModule } from './routeModules-D5iJ6JYT.js';
+import { R as RouteModule } from './instrumentation-Unc20tLk.js';
 
 /**
  * Apps can use this interface to "register" app-wide types for React Router via interface declaration merging and module augmentation.

package/dist/development/{register-CI4bTprK.d.mts → register-QkB3HGjm.d.mts}

@@ -1,4 +1,4 @@
-import { R as RouteModule } from './route-data-DZQOUSqV.mjs';
+import { R as RouteModule } from './router-CAvh_Drx.mjs';
 
 /**
  * Apps can use this interface to "register" app-wide types for React Router via interface declaration merging and module augmentation.