react-router 0.0.0-experimental-e613d4238 → 0.0.0-experimental-4e44d47

package/dist/{production/index-react-server-client-2EDmGlsZ.d.mts → development/index-react-server-client-BDG19ZQl.d.mts}

@@ -1,60 +1,33 @@
-import { b7 as RouteManifest, i as MiddlewareEnabled, g as RouterContextProvider, b as LoaderFunctionArgs, A as ActionFunctionArgs, O as StaticHandlerContext, H as HydrationState, F as DataRouteObject, a3 as HTMLFormMethod, a1 as FormEncType, m as RelativeRoutingType, T as To, b8 as History, K as GetScrollRestorationKeyFunction, a as RouterInit, b9 as FutureConfig$1, k as DataStrategyFunction, C as PatchRoutesOnNavigationFunction, N as NavigateOptions, Q as Fetcher, t as RouteObject, j as Router, B as BlockerFunction, L as Location, ba as CreateStaticHandlerOptions$1, G as StaticHandler } from './context-BqL5Eckq.mjs';
+import { b8 as RouteManifest, H as HydrationState, G as DataRouteObject, Q as StaticHandlerContext, e as MiddlewareEnabled, c as RouterContextProvider, f as LoaderFunctionArgs, A as ActionFunctionArgs, b9 as unstable_ServerInstrumentation, a4 as HTMLFormMethod, a2 as FormEncType, n as RelativeRoutingType, T as To, ba as History, O as GetScrollRestorationKeyFunction, a as RouterInit, bb as FutureConfig$1, u as unstable_ClientInstrumentation, l as DataStrategyFunction, F as PatchRoutesOnNavigationFunction, N as NavigateOptions, V as Fetcher, v as RouteObject, k as Router, B as BlockerFunction, L as Location, bc as CreateStaticHandlerOptions$1, J as StaticHandler } from './router-2BoB34m1.mjs';
 import * as React from 'react';
-import { o as ServerRouteModule, A as AppLoadContext, c as RouteModules, h as ClientLoaderFunction, m as PageLinkDescriptor, d as SerializeFrom } from './route-data-CDwqkzPE.mjs';
+import { c as RouteModules, h as ClientLoaderFunction, o as ServerRouteModule, A as AppLoadContext, m as PageLinkDescriptor, d as SerializeFrom } from './routeModules-CtCOLGtG.mjs';
 
-type ServerRouteManifest = RouteManifest<Omit<ServerRoute, "children">>;
-interface ServerRoute extends Route {
-    children: ServerRoute[];
-    module: ServerRouteModule;
-}
-
-type OptionalCriticalCss = CriticalCss | undefined;
-/**
- * The output of the compiler for the server build.
- */
-interface ServerBuild {
-    entry: {
-        module: ServerEntryModule;
-    };
-    routes: ServerRouteManifest;
-    assets: AssetsManifest;
-    basename?: string;
-    publicPath: string;
-    assetsBuildDirectory: string;
-    future: FutureConfig;
-    ssr: boolean;
-    unstable_getCriticalCss?: (args: {
-        pathname: string;
-    }) => OptionalCriticalCss | Promise<OptionalCriticalCss>;
-    /**
-     * @deprecated This is now done via a custom header during prerendering
-     */
-    isSpaMode: boolean;
-    prerender: string[];
-    routeDiscovery: {
-        mode: "lazy" | "initial";
-        manifestPath: string;
-    };
-}
-interface HandleDocumentRequestFunction {
-    (request: Request, responseStatusCode: number, responseHeaders: Headers, context: EntryContext, loadContext: MiddlewareEnabled extends true ? RouterContextProvider : AppLoadContext): Promise<Response> | Response;
-}
-interface HandleDataRequestFunction {
-    (response: Response, args: LoaderFunctionArgs | ActionFunctionArgs): Promise<Response> | Response;
-}
-interface HandleErrorFunction {
-    (error: unknown, args: LoaderFunctionArgs | ActionFunctionArgs): void;
+interface Route {
+    index?: boolean;
+    caseSensitive?: boolean;
+    id: string;
+    parentId?: string;
+    path?: string;
 }
-/**
- * A module that serves as the entry point for a Remix app during server
- * rendering.
- */
-interface ServerEntryModule {
-    default: HandleDocumentRequestFunction;
-    handleDataRequest?: HandleDataRequestFunction;
-    handleError?: HandleErrorFunction;
-    streamTimeout?: number;
+interface EntryRoute extends Route {
+    hasAction: boolean;
+    hasLoader: boolean;
+    hasClientAction: boolean;
+    hasClientLoader: boolean;
+    hasClientMiddleware: boolean;
+    hasErrorBoundary: boolean;
+    imports?: string[];
+    css?: string[];
+    module: string;
+    clientActionModule: string | undefined;
+    clientLoaderModule: string | undefined;
+    clientMiddlewareModule: string | undefined;
+    hydrateFallbackModule: string | undefined;
+    parentId?: string;
 }
+declare function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation: Set<string>, manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState, ssr: boolean, isSpaMode: boolean): DataRouteObject[];
+declare function createClientRoutes(manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState | null, ssr: boolean, isSpaMode: boolean, parentId?: string, routesByParentId?: Record<string, Omit<EntryRoute, "children">[]>, needsRevalidation?: Set<string>): DataRouteObject[];
+declare function shouldHydrateRouteLoader(routeId: string, clientLoader: ClientLoaderFunction | undefined, hasLoader: boolean, isSpaMode: boolean): boolean;
 
 type SerializedError = {
     message: string;
@@ -108,32 +81,68 @@ interface AssetsManifest {
     sri?: Record<string, string> | true;
 }
 
-interface Route {
-    index?: boolean;
-    caseSensitive?: boolean;
-    id: string;
-    parentId?: string;
-    path?: string;
+type ServerRouteManifest = RouteManifest<Omit<ServerRoute, "children">>;
+interface ServerRoute extends Route {
+    children: ServerRoute[];
+    module: ServerRouteModule;
 }
-interface EntryRoute extends Route {
-    hasAction: boolean;
-    hasLoader: boolean;
-    hasClientAction: boolean;
-    hasClientLoader: boolean;
-    hasClientMiddleware: boolean;
-    hasErrorBoundary: boolean;
-    imports?: string[];
-    css?: string[];
-    module: string;
-    clientActionModule: string | undefined;
-    clientLoaderModule: string | undefined;
-    clientMiddlewareModule: string | undefined;
-    hydrateFallbackModule: string | undefined;
-    parentId?: string;
+
+type OptionalCriticalCss = CriticalCss | undefined;
+/**
+ * The output of the compiler for the server build.
+ */
+interface ServerBuild {
+    entry: {
+        module: ServerEntryModule;
+    };
+    routes: ServerRouteManifest;
+    assets: AssetsManifest;
+    basename?: string;
+    publicPath: string;
+    assetsBuildDirectory: string;
+    future: FutureConfig;
+    ssr: boolean;
+    unstable_getCriticalCss?: (args: {
+        pathname: string;
+    }) => OptionalCriticalCss | Promise<OptionalCriticalCss>;
+    /**
+     * @deprecated This is now done via a custom header during prerendering
+     */
+    isSpaMode: boolean;
+    prerender: string[];
+    routeDiscovery: {
+        mode: "lazy" | "initial";
+        manifestPath: string;
+    };
+}
+interface HandleDocumentRequestFunction {
+    (request: Request, responseStatusCode: number, responseHeaders: Headers, context: EntryContext, loadContext: MiddlewareEnabled extends true ? RouterContextProvider : AppLoadContext): Promise<Response> | Response;
+}
+interface HandleDataRequestFunction {
+    (response: Response, args: {
+        request: LoaderFunctionArgs["request"] | ActionFunctionArgs["request"];
+        context: LoaderFunctionArgs["context"] | ActionFunctionArgs["context"];
+        params: LoaderFunctionArgs["params"] | ActionFunctionArgs["params"];
+    }): Promise<Response> | Response;
+}
+interface HandleErrorFunction {
+    (error: unknown, args: {
+        request: LoaderFunctionArgs["request"] | ActionFunctionArgs["request"];
+        context: LoaderFunctionArgs["context"] | ActionFunctionArgs["context"];
+        params: LoaderFunctionArgs["params"] | ActionFunctionArgs["params"];
+    }): void;
+}
+/**
+ * A module that serves as the entry point for a Remix app during server
+ * rendering.
+ */
+interface ServerEntryModule {
+    default: HandleDocumentRequestFunction;
+    handleDataRequest?: HandleDataRequestFunction;
+    handleError?: HandleErrorFunction;
+    unstable_instrumentations?: unstable_ServerInstrumentation[];
+    streamTimeout?: number;
 }
-declare function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation: Set<string>, manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState, ssr: boolean, isSpaMode: boolean): DataRouteObject[];
-declare function createClientRoutes(manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState | null, ssr: boolean, isSpaMode: boolean, parentId?: string, routesByParentId?: Record<string, Omit<EntryRoute, "children">[]>, needsRevalidation?: Set<string>): DataRouteObject[];
-declare function shouldHydrateRouteLoader(routeId: string, clientLoader: ClientLoaderFunction | undefined, hasLoader: boolean, isSpaMode: boolean): boolean;
 
 type ParamKeyValuePair = [string, string];
 type URLSearchParamsInit = string | ParamKeyValuePair[] | Record<string, string | string[]> | URLSearchParams;
@@ -522,6 +531,58 @@ interface DOMRouterOpts {
      * ```
      */
     hydrationData?: HydrationState;
+    /**
+     * 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}`);
+     *   try {
+     *     await impl();
+     *   } finally {
+     *     let end = performance.now();
+     *     console.log(`end ${label} (${Math.round(end - start)}ms)`);
+     *   }
+     * }
+     * ```
+     */
+    unstable_instrumentations?: unstable_ClientInstrumentation[];
     /**
      * Override the default data strategy of running loaders in parallel.
      * See {@link DataStrategyFunction}.
@@ -1027,6 +1088,7 @@ interface DOMRouterOpts {
  * @param {DOMRouterOpts.future} opts.future n/a
  * @param {DOMRouterOpts.getContext} opts.getContext n/a
  * @param {DOMRouterOpts.hydrationData} opts.hydrationData n/a
+ * @param {DOMRouterOpts.unstable_instrumentations} opts.unstable_instrumentations n/a
  * @param {DOMRouterOpts.patchRoutesOnNavigation} opts.patchRoutesOnNavigation n/a
  * @param {DOMRouterOpts.window} opts.window n/a
  * @returns An initialized {@link DataRouter| data router} to pass to {@link RouterProvider | `<RouterProvider>`}
@@ -1045,6 +1107,7 @@ declare function createBrowserRouter(routes: RouteObject[], opts?: DOMRouterOpts
  * @param {DOMRouterOpts.future} opts.future n/a
  * @param {DOMRouterOpts.getContext} opts.getContext n/a
  * @param {DOMRouterOpts.hydrationData} opts.hydrationData n/a
+ * @param {DOMRouterOpts.unstable_instrumentations} opts.unstable_instrumentations n/a
  * @param {DOMRouterOpts.dataStrategy} opts.dataStrategy n/a
  * @param {DOMRouterOpts.patchRoutesOnNavigation} opts.patchRoutesOnNavigation n/a
  * @param {DOMRouterOpts.window} opts.window n/a

package/dist/development/index-react-server-client.d.mts

@@ -1,4 +1,4 @@
-export { aE as MemoryRouter, aF as Navigate, aG as Outlet, aH as Route, aI as Router, aJ as RouterProvider, aK as Routes, ar as UNSAFE_AwaitContextProvider, b1 as UNSAFE_WithComponentProps, b5 as UNSAFE_WithErrorBoundaryProps, b3 as UNSAFE_WithHydrateFallbackProps } from './context-BqL5Eckq.mjs';
-export { l as BrowserRouter, q as Form, m as HashRouter, n as Link, X as Links, W as Meta, p as NavLink, r as ScrollRestoration, T as StaticRouter, V as StaticRouterProvider, o as unstable_HistoryRouter } from './index-react-server-client-2EDmGlsZ.mjs';
+export { aF as MemoryRouter, aG as Navigate, aH as Outlet, aI as Route, aJ as Router, aK as RouterProvider, aL as Routes, as as UNSAFE_AwaitContextProvider, b2 as UNSAFE_WithComponentProps, b6 as UNSAFE_WithErrorBoundaryProps, b4 as UNSAFE_WithHydrateFallbackProps } from './router-2BoB34m1.mjs';
+export { l as BrowserRouter, q as Form, m as HashRouter, n as Link, X as Links, W as Meta, p as NavLink, r as ScrollRestoration, T as StaticRouter, V as StaticRouterProvider, o as unstable_HistoryRouter } from './index-react-server-client-BDG19ZQl.mjs';
 import 'react';
-import './route-data-CDwqkzPE.mjs';
+import './routeModules-CtCOLGtG.mjs';

package/dist/development/index-react-server-client.d.ts

@@ -1,3 +1,4 @@
-export { aY as MemoryRouter, aZ as Navigate, a_ as Outlet, a$ as Route, b0 as Router, b1 as RouterProvider, b2 as Routes, aJ as UNSAFE_AwaitContextProvider, bs as UNSAFE_WithComponentProps, bw as UNSAFE_WithErrorBoundaryProps, bu as UNSAFE_WithHydrateFallbackProps } from './routeModules-BmVo7q9e.js';
-export { l as BrowserRouter, q as Form, m as HashRouter, n as Link, X as Links, W as Meta, p as NavLink, r as ScrollRestoration, T as StaticRouter, V as StaticRouterProvider, o as unstable_HistoryRouter } from './index-react-server-client-DKvU8YRr.js';
+export { af as MemoryRouter, ag as Navigate, ah as Outlet, ai as Route, aj as Router, ak as RouterProvider, al as Routes, a0 as UNSAFE_AwaitContextProvider, aH as UNSAFE_WithComponentProps, aL as UNSAFE_WithErrorBoundaryProps, aJ as UNSAFE_WithHydrateFallbackProps } from './routeModules-Bu1JamQV.js';
+export { l as BrowserRouter, q as Form, m as HashRouter, n as Link, X as Links, W as Meta, p as NavLink, r as ScrollRestoration, T as StaticRouter, V as StaticRouterProvider, o as unstable_HistoryRouter } from './index-react-server-client-83aVZHgI.js';
 import 'react';
+import './instrumentation-XYmrzhe3.js';

package/dist/development/index-react-server-client.js

@@ -1,5 +1,5 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});/**
- * react-router v0.0.0-experimental-e613d4238
+ * react-router v0.0.0-experimental-4e44d47
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -29,12 +29,12 @@
 
 
 
-var _chunkXXC4LMW2js = require('./chunk-XXC4LMW2.js');
+var _chunkMTLWRICGjs = require('./chunk-MTLWRICG.js');
 
 
 
 
-var _chunkYJ6T7YSEjs = require('./chunk-YJ6T7YSE.js');
+var _chunk7B7CUJYEjs = require('./chunk-7B7CUJYE.js');
 
 
 
@@ -58,4 +58,4 @@ var _chunkYJ6T7YSEjs = require('./chunk-YJ6T7YSE.js');
 
 
 
-exports.BrowserRouter = _chunkXXC4LMW2js.BrowserRouter; exports.Form = _chunkXXC4LMW2js.Form; exports.HashRouter = _chunkXXC4LMW2js.HashRouter; exports.Link = _chunkXXC4LMW2js.Link; exports.Links = _chunkYJ6T7YSEjs.Links; exports.MemoryRouter = _chunkXXC4LMW2js.MemoryRouter; exports.Meta = _chunkYJ6T7YSEjs.Meta; exports.NavLink = _chunkXXC4LMW2js.NavLink; exports.Navigate = _chunkXXC4LMW2js.Navigate; exports.Outlet = _chunkXXC4LMW2js.Outlet; exports.Route = _chunkXXC4LMW2js.Route; exports.Router = _chunkXXC4LMW2js.Router; exports.RouterProvider = _chunkXXC4LMW2js.RouterProvider; exports.Routes = _chunkXXC4LMW2js.Routes; exports.ScrollRestoration = _chunkXXC4LMW2js.ScrollRestoration; exports.StaticRouter = _chunkXXC4LMW2js.StaticRouter; exports.StaticRouterProvider = _chunkXXC4LMW2js.StaticRouterProvider; exports.UNSAFE_AwaitContextProvider = _chunkYJ6T7YSEjs.AwaitContextProvider; exports.UNSAFE_WithComponentProps = _chunkXXC4LMW2js.WithComponentProps; exports.UNSAFE_WithErrorBoundaryProps = _chunkXXC4LMW2js.WithErrorBoundaryProps; exports.UNSAFE_WithHydrateFallbackProps = _chunkXXC4LMW2js.WithHydrateFallbackProps; exports.unstable_HistoryRouter = _chunkXXC4LMW2js.HistoryRouter;
+exports.BrowserRouter = _chunkMTLWRICGjs.BrowserRouter; exports.Form = _chunkMTLWRICGjs.Form; exports.HashRouter = _chunkMTLWRICGjs.HashRouter; exports.Link = _chunkMTLWRICGjs.Link; exports.Links = _chunk7B7CUJYEjs.Links; exports.MemoryRouter = _chunkMTLWRICGjs.MemoryRouter; exports.Meta = _chunk7B7CUJYEjs.Meta; exports.NavLink = _chunkMTLWRICGjs.NavLink; exports.Navigate = _chunkMTLWRICGjs.Navigate; exports.Outlet = _chunkMTLWRICGjs.Outlet; exports.Route = _chunkMTLWRICGjs.Route; exports.Router = _chunkMTLWRICGjs.Router; exports.RouterProvider = _chunkMTLWRICGjs.RouterProvider; exports.Routes = _chunkMTLWRICGjs.Routes; exports.ScrollRestoration = _chunkMTLWRICGjs.ScrollRestoration; exports.StaticRouter = _chunkMTLWRICGjs.StaticRouter; exports.StaticRouterProvider = _chunkMTLWRICGjs.StaticRouterProvider; exports.UNSAFE_AwaitContextProvider = _chunk7B7CUJYEjs.AwaitContextProvider; exports.UNSAFE_WithComponentProps = _chunkMTLWRICGjs.WithComponentProps; exports.UNSAFE_WithErrorBoundaryProps = _chunkMTLWRICGjs.WithErrorBoundaryProps; exports.UNSAFE_WithHydrateFallbackProps = _chunkMTLWRICGjs.WithHydrateFallbackProps; exports.unstable_HistoryRouter = _chunkMTLWRICGjs.HistoryRouter;

package/dist/development/index-react-server-client.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v0.0.0-experimental-e613d4238
+ * react-router v0.0.0-experimental-4e44d47
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -32,7 +32,7 @@ import {
   WithComponentProps,
   WithErrorBoundaryProps,
   WithHydrateFallbackProps
-} from "./chunk-5P3HEZQU.mjs";
+} from "./chunk-XVVWTPHF.mjs";
 export {
   BrowserRouter,
   Form,

package/dist/development/index-react-server.d.mts

@@ -351,6 +351,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.
+     */
+    pattern: string;
     /**
      * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
      * @example
@@ -571,7 +576,7 @@ type AgnosticPatchRoutesOnNavigationFunction<O extends AgnosticRouteObject = Agn
  * properties from framework-agnostic properties
  */
 interface MapRoutePropertiesFunction {
-    (route: AgnosticRouteObject): {
+    (route: AgnosticDataRouteObject): {
         hasErrorBoundary: boolean;
     } & Record<string, any>;
 }
@@ -887,6 +892,99 @@ type ErrorResponse = {
  */
 declare function isRouteErrorResponse(error: any): error is ErrorResponse;
 
+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;
+interface GenericInstrumentFunction {
+    (handler: () => Promise<void>, info: unknown): Promise<void>;
+}
+type InstrumentableRoute = {
+    id: string;
+    index: boolean | undefined;
+    path: string | undefined;
+    instrument(instrumentations: RouteInstrumentations): void;
+};
+type RouteInstrumentations = {
+    lazy?: InstrumentLazyFunction;
+    "lazy.loader"?: InstrumentLazyFunction;
+    "lazy.action"?: InstrumentLazyFunction;
+    "lazy.middleware"?: InstrumentLazyFunction;
+    middleware?: InstrumentRouteHandlerFunction;
+    loader?: InstrumentRouteHandlerFunction;
+    action?: InstrumentRouteHandlerFunction;
+};
+type RouteHandlerInstrumentationInfo = Readonly<{
+    request: {
+        method: string;
+        url: string;
+        headers: Pick<Headers, "get">;
+    };
+    params: LoaderFunctionArgs["params"];
+    pattern: string;
+    context: Pick<RouterContextProvider, "get">;
+}>;
+interface InstrumentLazyFunction extends GenericInstrumentFunction {
+    (handler: () => Promise<void>): Promise<void>;
+}
+interface InstrumentRouteHandlerFunction extends GenericInstrumentFunction {
+    (handler: () => Promise<void>, info: RouteHandlerInstrumentationInfo): Promise<void>;
+}
+type InstrumentableRouter = {
+    instrument(instrumentations: RouterInstrumentations): void;
+};
+type RouterInstrumentations = {
+    navigate?: InstrumentNavigateFunction;
+    fetch?: InstrumentFetchFunction;
+};
+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;
+}>;
+interface InstrumentNavigateFunction extends GenericInstrumentFunction {
+    (handler: () => Promise<void>, info: RouterNavigationInstrumentationInfo): MaybePromise<void>;
+}
+interface InstrumentFetchFunction extends GenericInstrumentFunction {
+    (handler: () => Promise<void>, info: RouterFetchInstrumentationInfo): MaybePromise<void>;
+}
+type InstrumentableRequestHandler = {
+    instrument(instrumentations: RequestHandlerInstrumentations): void;
+};
+type RequestHandlerInstrumentations = {
+    request?: InstrumentRequestHandlerFunction;
+};
+type RequestHandlerInstrumentationInfo = Readonly<{
+    request: {
+        method: string;
+        url: string;
+        headers: Pick<Headers, "get">;
+    };
+    context: Pick<RouterContextProvider, "get">;
+}>;
+interface InstrumentRequestHandlerFunction extends GenericInstrumentFunction {
+    (handler: () => Promise<void>, info: RequestHandlerInstrumentationInfo): MaybePromise<void>;
+}
+
 /**
  * A Router instance manages all navigation and data loading/mutations
  */
@@ -1171,6 +1269,7 @@ interface RouterInit {
     history: History;
     basename?: string;
     getContext?: () => MaybePromise<RouterContextProvider>;
+    unstable_instrumentations?: unstable_ClientInstrumentation[];
     mapRouteProperties?: MapRoutePropertiesFunction;
     future?: Partial<FutureConfig>;
     hydrationRouteProperties?: string[];
@@ -1437,6 +1536,7 @@ type BlockerFunction = (args: {
 interface CreateStaticHandlerOptions {
     basename?: string;
     mapRouteProperties?: MapRoutePropertiesFunction;
+    unstable_instrumentations?: Pick<unstable_ServerInstrumentation, "route">[];
     future?: {};
 }
 declare function createStaticHandler(routes: AgnosticRouteObject[], opts?: CreateStaticHandlerOptions): StaticHandler;
@@ -1807,6 +1907,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.
+     */
+    pattern: string;
     /**
      * When `future.v8_middleware` is not enabled, this is undefined.
      *

package/dist/development/index-react-server.d.ts

@@ -351,6 +351,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.
+     */
+    pattern: string;
     /**
      * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
      * @example
@@ -571,7 +576,7 @@ type AgnosticPatchRoutesOnNavigationFunction<O extends AgnosticRouteObject = Agn
  * properties from framework-agnostic properties
  */
 interface MapRoutePropertiesFunction {
-    (route: AgnosticRouteObject): {
+    (route: AgnosticDataRouteObject): {
         hasErrorBoundary: boolean;
     } & Record<string, any>;
 }
@@ -887,6 +892,99 @@ type ErrorResponse = {
  */
 declare function isRouteErrorResponse(error: any): error is ErrorResponse;
 
+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;
+interface GenericInstrumentFunction {
+    (handler: () => Promise<void>, info: unknown): Promise<void>;
+}
+type InstrumentableRoute = {
+    id: string;
+    index: boolean | undefined;
+    path: string | undefined;
+    instrument(instrumentations: RouteInstrumentations): void;
+};
+type RouteInstrumentations = {
+    lazy?: InstrumentLazyFunction;
+    "lazy.loader"?: InstrumentLazyFunction;
+    "lazy.action"?: InstrumentLazyFunction;
+    "lazy.middleware"?: InstrumentLazyFunction;
+    middleware?: InstrumentRouteHandlerFunction;
+    loader?: InstrumentRouteHandlerFunction;
+    action?: InstrumentRouteHandlerFunction;
+};
+type RouteHandlerInstrumentationInfo = Readonly<{
+    request: {
+        method: string;
+        url: string;
+        headers: Pick<Headers, "get">;
+    };
+    params: LoaderFunctionArgs["params"];
+    pattern: string;
+    context: Pick<RouterContextProvider, "get">;
+}>;
+interface InstrumentLazyFunction extends GenericInstrumentFunction {
+    (handler: () => Promise<void>): Promise<void>;
+}
+interface InstrumentRouteHandlerFunction extends GenericInstrumentFunction {
+    (handler: () => Promise<void>, info: RouteHandlerInstrumentationInfo): Promise<void>;
+}
+type InstrumentableRouter = {
+    instrument(instrumentations: RouterInstrumentations): void;
+};
+type RouterInstrumentations = {
+    navigate?: InstrumentNavigateFunction;
+    fetch?: InstrumentFetchFunction;
+};
+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;
+}>;
+interface InstrumentNavigateFunction extends GenericInstrumentFunction {
+    (handler: () => Promise<void>, info: RouterNavigationInstrumentationInfo): MaybePromise<void>;
+}
+interface InstrumentFetchFunction extends GenericInstrumentFunction {
+    (handler: () => Promise<void>, info: RouterFetchInstrumentationInfo): MaybePromise<void>;
+}
+type InstrumentableRequestHandler = {
+    instrument(instrumentations: RequestHandlerInstrumentations): void;
+};
+type RequestHandlerInstrumentations = {
+    request?: InstrumentRequestHandlerFunction;
+};
+type RequestHandlerInstrumentationInfo = Readonly<{
+    request: {
+        method: string;
+        url: string;
+        headers: Pick<Headers, "get">;
+    };
+    context: Pick<RouterContextProvider, "get">;
+}>;
+interface InstrumentRequestHandlerFunction extends GenericInstrumentFunction {
+    (handler: () => Promise<void>, info: RequestHandlerInstrumentationInfo): MaybePromise<void>;
+}
+
 /**
  * A Router instance manages all navigation and data loading/mutations
  */
@@ -1171,6 +1269,7 @@ interface RouterInit {
     history: History;
     basename?: string;
     getContext?: () => MaybePromise<RouterContextProvider>;
+    unstable_instrumentations?: unstable_ClientInstrumentation[];
     mapRouteProperties?: MapRoutePropertiesFunction;
     future?: Partial<FutureConfig>;
     hydrationRouteProperties?: string[];
@@ -1437,6 +1536,7 @@ type BlockerFunction = (args: {
 interface CreateStaticHandlerOptions {
     basename?: string;
     mapRouteProperties?: MapRoutePropertiesFunction;
+    unstable_instrumentations?: Pick<unstable_ServerInstrumentation, "route">[];
     future?: {};
 }
 declare function createStaticHandler(routes: AgnosticRouteObject[], opts?: CreateStaticHandlerOptions): StaticHandler;
@@ -1807,6 +1907,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.
+     */
+    pattern: string;
     /**
      * When `future.v8_middleware` is not enabled, this is undefined.
      *