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

package/dist/production/{index-react-server-client-DKvU8YRr.d.ts → index-react-server-client-BDG19ZQl.d.mts}

@@ -1,5 +1,148 @@
-import { ai as HTMLFormMethod, ag as FormEncType, k as RelativeRoutingType, by as RouteManifest, bz as ServerRouteModule, O as MiddlewareEnabled, K as RouterContextProvider, J as AppLoadContext, ak as LoaderFunctionArgs, ab as ActionFunctionArgs, f as RouteModules, H as HydrationState, a0 as DataRouteObject, W as ClientLoaderFunction, a4 as StaticHandlerContext, bb as PageLinkDescriptor, T as To, bA as History, a3 as GetScrollRestorationKeyFunction, Z as RouterInit, bB as FutureConfig$1, g as DataStrategyFunction, $ as PatchRoutesOnNavigationFunction, h as NavigateOptions, a5 as Fetcher, r as RouteObject, e as Router, j as SerializeFrom, B as BlockerFunction, a as Location, bC as CreateStaticHandlerOptions$1, a1 as StaticHandler } from './routeModules-BmVo7q9e.js';
+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 { c as RouteModules, h as ClientLoaderFunction, o as ServerRouteModule, A as AppLoadContext, m as PageLinkDescriptor, d as SerializeFrom } from './routeModules-CtCOLGtG.mjs';
+
+interface Route {
+    index?: boolean;
+    caseSensitive?: boolean;
+    id: string;
+    parentId?: string;
+    path?: string;
+}
+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;
+    stack?: string;
+};
+interface FrameworkContextObject {
+    manifest: AssetsManifest;
+    routeModules: RouteModules;
+    criticalCss?: CriticalCss;
+    serverHandoffString?: string;
+    future: FutureConfig;
+    ssr: boolean;
+    isSpaMode: boolean;
+    routeDiscovery: ServerBuild["routeDiscovery"];
+    serializeError?(error: Error): SerializedError;
+    renderMeta?: {
+        didRenderScripts?: boolean;
+        streamCache?: Record<number, Promise<void> & {
+            result?: {
+                done: boolean;
+                value: string;
+            };
+            error?: unknown;
+        }>;
+    };
+}
+interface EntryContext extends FrameworkContextObject {
+    staticHandlerContext: StaticHandlerContext;
+    serverHandoffStream?: ReadableStream<Uint8Array>;
+}
+interface FutureConfig {
+    unstable_subResourceIntegrity: boolean;
+    v8_middleware: boolean;
+}
+type CriticalCss = string | {
+    rel: "stylesheet";
+    href: string;
+};
+interface AssetsManifest {
+    entry: {
+        imports: string[];
+        module: string;
+    };
+    routes: RouteManifest<EntryRoute>;
+    url: string;
+    version: string;
+    hmr?: {
+        timestamp?: number;
+        runtime: string;
+    };
+    sri?: Record<string, string> | true;
+}
+
+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: {
+        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;
+}
 
 type ParamKeyValuePair = [string, string];
 type URLSearchParamsInit = string | ParamKeyValuePair[] | Record<string, string | string[]> | URLSearchParams;
@@ -107,139 +250,6 @@ interface SubmitOptions extends FetcherSubmitOptions {
     viewTransition?: boolean;
 }
 
-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;
-}
-/**
- * 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 Route {
-    index?: boolean;
-    caseSensitive?: boolean;
-    id: string;
-    parentId?: string;
-    path?: string;
-}
-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;
-    stack?: string;
-};
-interface FrameworkContextObject {
-    manifest: AssetsManifest;
-    routeModules: RouteModules;
-    criticalCss?: CriticalCss;
-    serverHandoffString?: string;
-    future: FutureConfig;
-    ssr: boolean;
-    isSpaMode: boolean;
-    routeDiscovery: ServerBuild["routeDiscovery"];
-    serializeError?(error: Error): SerializedError;
-    renderMeta?: {
-        didRenderScripts?: boolean;
-        streamCache?: Record<number, Promise<void> & {
-            result?: {
-                done: boolean;
-                value: string;
-            };
-            error?: unknown;
-        }>;
-    };
-}
-interface EntryContext extends FrameworkContextObject {
-    staticHandlerContext: StaticHandlerContext;
-    serverHandoffStream?: ReadableStream<Uint8Array>;
-}
-interface FutureConfig {
-    unstable_subResourceIntegrity: boolean;
-    v8_middleware: boolean;
-}
-type CriticalCss = string | {
-    rel: "stylesheet";
-    href: string;
-};
-interface AssetsManifest {
-    entry: {
-        imports: string[];
-        module: string;
-    };
-    routes: RouteManifest<EntryRoute>;
-    url: string;
-    version: string;
-    hmr?: {
-        timestamp?: number;
-        runtime: string;
-    };
-    sri?: Record<string, string> | true;
-}
-
 declare const FrameworkContext: React.Context<FrameworkContextObject | undefined>;
 /**
  * Defines the discovery behavior of the link:
@@ -521,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}.
@@ -1026,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>`}
@@ -1044,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/production/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/production/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/production/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 _chunkE4G6PZCJjs = require('./chunk-E4G6PZCJ.js');
+var _chunkUNIYMJFUjs = require('./chunk-UNIYMJFU.js');
 
 
 
 
-var _chunkQBUHFRYZjs = require('./chunk-QBUHFRYZ.js');
+var _chunkOXRQQZPRjs = require('./chunk-OXRQQZPR.js');
 
 
 
@@ -58,4 +58,4 @@ var _chunkQBUHFRYZjs = require('./chunk-QBUHFRYZ.js');
 
 
 
-exports.BrowserRouter = _chunkE4G6PZCJjs.BrowserRouter; exports.Form = _chunkE4G6PZCJjs.Form; exports.HashRouter = _chunkE4G6PZCJjs.HashRouter; exports.Link = _chunkE4G6PZCJjs.Link; exports.Links = _chunkQBUHFRYZjs.Links; exports.MemoryRouter = _chunkE4G6PZCJjs.MemoryRouter; exports.Meta = _chunkQBUHFRYZjs.Meta; exports.NavLink = _chunkE4G6PZCJjs.NavLink; exports.Navigate = _chunkE4G6PZCJjs.Navigate; exports.Outlet = _chunkE4G6PZCJjs.Outlet; exports.Route = _chunkE4G6PZCJjs.Route; exports.Router = _chunkE4G6PZCJjs.Router; exports.RouterProvider = _chunkE4G6PZCJjs.RouterProvider; exports.Routes = _chunkE4G6PZCJjs.Routes; exports.ScrollRestoration = _chunkE4G6PZCJjs.ScrollRestoration; exports.StaticRouter = _chunkE4G6PZCJjs.StaticRouter; exports.StaticRouterProvider = _chunkE4G6PZCJjs.StaticRouterProvider; exports.UNSAFE_AwaitContextProvider = _chunkQBUHFRYZjs.AwaitContextProvider; exports.UNSAFE_WithComponentProps = _chunkE4G6PZCJjs.WithComponentProps; exports.UNSAFE_WithErrorBoundaryProps = _chunkE4G6PZCJjs.WithErrorBoundaryProps; exports.UNSAFE_WithHydrateFallbackProps = _chunkE4G6PZCJjs.WithHydrateFallbackProps; exports.unstable_HistoryRouter = _chunkE4G6PZCJjs.HistoryRouter;
+exports.BrowserRouter = _chunkUNIYMJFUjs.BrowserRouter; exports.Form = _chunkUNIYMJFUjs.Form; exports.HashRouter = _chunkUNIYMJFUjs.HashRouter; exports.Link = _chunkUNIYMJFUjs.Link; exports.Links = _chunkOXRQQZPRjs.Links; exports.MemoryRouter = _chunkUNIYMJFUjs.MemoryRouter; exports.Meta = _chunkOXRQQZPRjs.Meta; exports.NavLink = _chunkUNIYMJFUjs.NavLink; exports.Navigate = _chunkUNIYMJFUjs.Navigate; exports.Outlet = _chunkUNIYMJFUjs.Outlet; exports.Route = _chunkUNIYMJFUjs.Route; exports.Router = _chunkUNIYMJFUjs.Router; exports.RouterProvider = _chunkUNIYMJFUjs.RouterProvider; exports.Routes = _chunkUNIYMJFUjs.Routes; exports.ScrollRestoration = _chunkUNIYMJFUjs.ScrollRestoration; exports.StaticRouter = _chunkUNIYMJFUjs.StaticRouter; exports.StaticRouterProvider = _chunkUNIYMJFUjs.StaticRouterProvider; exports.UNSAFE_AwaitContextProvider = _chunkOXRQQZPRjs.AwaitContextProvider; exports.UNSAFE_WithComponentProps = _chunkUNIYMJFUjs.WithComponentProps; exports.UNSAFE_WithErrorBoundaryProps = _chunkUNIYMJFUjs.WithErrorBoundaryProps; exports.UNSAFE_WithHydrateFallbackProps = _chunkUNIYMJFUjs.WithHydrateFallbackProps; exports.unstable_HistoryRouter = _chunkUNIYMJFUjs.HistoryRouter;

package/dist/production/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-VNGQS422.mjs";
+} from "./chunk-GSSVRQ6M.mjs";
 export {
   BrowserRouter,
   Form,

package/dist/production/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.
      *