@octanejs/remix-router 0.1.1 → 0.1.2

package/src/lib/router/instrumentation.ts

@@ -1,9 +1,9 @@
-// Vendored from react-router@7.18.1 packages/react-router/lib/router/instrumentation.ts — unmodified except: type-only ../server-runtime/* imports → local ./server-runtime-types stub.
+// Vendored from react-router@8.2.0 packages/react-router/lib/router/instrumentation.ts — unmodified except: type-only ../server-runtime/server import → local ./server-runtime-types stub.
 // Re-vendor with `node scripts/vendor-remix-router.mjs`; never hand-edit.
-import type { AppLoadContext, RequestHandler } from './server-runtime-types';
-import type { MiddlewareEnabled } from '../types/future';
+import type { RequestHandler } from './server-runtime-types';
 import { createPath, invariant } from './history';
 import type { Router } from './router';
+import { createContext, RouterContextProvider } from './utils';
 import type {
 	ActionFunctionArgs,
 	DataRouteObject,
@@ -15,7 +15,6 @@ import type {
 	MaybePromise,
 	MiddlewareFunction,
 	RouterContext,
-	RouterContextProvider,
 } from './utils';
 
 // Public APIs
@@ -35,13 +34,45 @@ export type InstrumentRouterFunction = (router: InstrumentableRouter) => void;
 
 export type InstrumentRouteFunction = (route: InstrumentableRoute) => void;
 
+/**
+ * Route metadata available after React Router has matched an instrumented
+ * request, navigation, or fetcher call.
+ */
+export type InstrumentationResultMeta = {
+	url: LoaderFunctionArgs['url'];
+	pattern: string;
+	params: LoaderFunctionArgs['params'];
+};
+
+/**
+ * Result returned by route-level instrumented handler calls, such as
+ * instrumented loaders, actions, middleware, and lazy route functions.
+ */
 export type InstrumentationHandlerResult =
 	| { status: 'success'; error: undefined }
 	| { status: 'error'; error: Error };
 
+/**
+ * Result returned by client-side router instrumented navigation and fetcher
+ * calls.
+ */
+export type InstrumentationClientRouterResult = InstrumentationHandlerResult & {
+	meta: InstrumentationResultMeta | undefined;
+};
+
+/**
+ * Result returned by server request handler instrumentation.
+ */
+export type InstrumentationServerHandlerResult = InstrumentationHandlerResult & {
+	statusCode: number;
+	meta: InstrumentationResultMeta | undefined;
+};
+
+export type InstrumentationMetaReceiver = (meta: InstrumentationResultMeta | undefined) => void;
+
 // Shared
-type InstrumentFunction<T> = (
-	handler: () => Promise<InstrumentationHandlerResult>,
+type InstrumentFunction<T, TInnerResult = InstrumentationHandlerResult> = (
+	handler: () => Promise<TInnerResult>,
 	info: T,
 ) => Promise<void>;
 
@@ -58,9 +89,7 @@ type ReadonlyRequest = {
 	headers: Pick<Headers, 'get'>;
 };
 
-type ReadonlyContext = MiddlewareEnabled extends true
-	? Pick<RouterContextProvider, 'get'>
-	: Readonly<AppLoadContext>;
+type ReadonlyContext = Pick<RouterContextProvider, 'get'>;
 
 // Route Instrumentation
 type InstrumentableRoute = {
@@ -82,12 +111,12 @@ type RouteInstrumentations = {
 
 type RouteLazyInstrumentationInfo = undefined;
 
-type RouteHandlerInstrumentationInfo = Readonly<{
-	request: ReadonlyRequest;
-	params: LoaderFunctionArgs['params'];
-	pattern: string;
-	context: ReadonlyContext;
-}>;
+type RouteHandlerInstrumentationInfo = Readonly<
+	Omit<LoaderFunctionArgs, 'request' | 'context'> & {
+		request: ReadonlyRequest;
+		context: ReadonlyContext;
+	}
+>;
 
 // Router Instrumentation
 type InstrumentableRouter = {
@@ -95,8 +124,11 @@ type InstrumentableRouter = {
 };
 
 type RouterInstrumentations = {
-	navigate?: InstrumentFunction<RouterNavigationInstrumentationInfo>;
-	fetch?: InstrumentFunction<RouterFetchInstrumentationInfo>;
+	navigate?: InstrumentFunction<
+		RouterNavigationInstrumentationInfo,
+		InstrumentationClientRouterResult
+	>;
+	fetch?: InstrumentFunction<RouterFetchInstrumentationInfo, InstrumentationClientRouterResult>;
 };
 
 type RouterNavigationInstrumentationInfo = Readonly<{
@@ -124,7 +156,10 @@ type InstrumentableRequestHandler = {
 };
 
 type RequestHandlerInstrumentations = {
-	request?: InstrumentFunction<RequestHandlerInstrumentationInfo>;
+	request?: InstrumentFunction<
+		RequestHandlerInstrumentationInfo,
+		InstrumentationServerHandlerResult
+	>;
 };
 
 type RequestHandlerInstrumentationInfo = Readonly<{
@@ -134,18 +169,31 @@ type RequestHandlerInstrumentationInfo = Readonly<{
 
 const UninstrumentedSymbol = Symbol('Uninstrumented');
 
+type InstrumentableFunction = (...args: never[]) => MaybePromise<unknown>;
+type InstrumentedFunction<T extends InstrumentableFunction> = T & {
+	[UninstrumentedSymbol]?: T;
+};
+
+export const instrumentationResultMetaContext = createContext<InstrumentationResultMeta>();
+
+// Client router instrumentations need route metadata captured inside the router
+// after matching, but exposing this on public router state/options would make it
+// part of the API. Keep a private, one-shot receiver keyed by router instance so
+// navigate/fetch instrumentation can receive the metadata without leaking it.
+let instrumentationClientResultMetaReceivers = new WeakMap<Router, InstrumentationMetaReceiver>();
+
 export function getRouteInstrumentationUpdates(
 	fns: InstrumentRouteFunction[],
 	route: Readonly<DataRouteObject>,
 ) {
 	let aggregated: {
-		lazy: InstrumentFunction<RouteLazyInstrumentationInfo>[];
-		'lazy.loader': InstrumentFunction<RouteLazyInstrumentationInfo>[];
-		'lazy.action': InstrumentFunction<RouteLazyInstrumentationInfo>[];
-		'lazy.middleware': InstrumentFunction<RouteLazyInstrumentationInfo>[];
-		middleware: InstrumentFunction<RouteHandlerInstrumentationInfo>[];
-		loader: InstrumentFunction<RouteHandlerInstrumentationInfo>[];
-		action: InstrumentFunction<RouteHandlerInstrumentationInfo>[];
+		lazy: NonNullable<RouteInstrumentations['lazy']>[];
+		'lazy.loader': NonNullable<RouteInstrumentations['lazy.loader']>[];
+		'lazy.action': NonNullable<RouteInstrumentations['lazy.action']>[];
+		'lazy.middleware': NonNullable<RouteInstrumentations['lazy.middleware']>[];
+		middleware: NonNullable<RouteInstrumentations['middleware']>[];
+		loader: NonNullable<RouteInstrumentations['loader']>[];
+		action: NonNullable<RouteInstrumentations['action']>[];
 	} = {
 		lazy: [],
 		'lazy.loader': [],
@@ -162,11 +210,26 @@ export function getRouteInstrumentationUpdates(
 			index: route.index,
 			path: route.path,
 			instrument(i) {
-				let keys = Object.keys(aggregated) as Array<keyof typeof aggregated>;
-				for (let key of keys) {
-					if (i[key]) {
-						aggregated[key].push(i[key] as any);
-					}
+				if (i.lazy != null) {
+					aggregated.lazy.push(i.lazy);
+				}
+				if (i['lazy.loader'] != null) {
+					aggregated['lazy.loader'].push(i['lazy.loader']);
+				}
+				if (i['lazy.action'] != null) {
+					aggregated['lazy.action'].push(i['lazy.action']);
+				}
+				if (i['lazy.middleware'] != null) {
+					aggregated['lazy.middleware'].push(i['lazy.middleware']);
+				}
+				if (i.middleware != null) {
+					aggregated.middleware.push(i.middleware);
+				}
+				if (i.loader != null) {
+					aggregated.loader.push(i.loader);
+				}
+				if (i.action != null) {
+					aggregated.action.push(i.action);
 				}
 			},
 		}),
@@ -181,63 +244,123 @@ export function getRouteInstrumentationUpdates(
 
 	// Instrument lazy functions
 	if (typeof route.lazy === 'function' && aggregated.lazy.length > 0) {
-		let instrumented = wrapImpl(aggregated.lazy, route.lazy, () => undefined);
-		if (instrumented) {
-			updates.lazy = instrumented as DataRouteObject['lazy'];
-		}
+		let lazy = route.lazy;
+		updates.lazy = async (...args) => {
+			let result = await recurseRight(
+				aggregated.lazy,
+				undefined,
+				() => lazy(...args),
+				getInstrumentationInnerResult,
+			);
+			return throwOrReturnResult(result);
+		};
 	}
 
 	// Instrument the lazy object format
 	if (typeof route.lazy === 'object') {
 		let lazyObject: LazyRouteObject<DataRouteObject> = route.lazy;
-		(['middleware', 'loader', 'action'] as const).forEach((key) => {
-			let lazyFn = lazyObject[key];
-			let instrumentations = aggregated[`lazy.${key}`];
-			if (typeof lazyFn === 'function' && instrumentations.length > 0) {
-				let instrumented = wrapImpl(instrumentations, lazyFn, () => undefined);
-				if (instrumented) {
-					updates.lazy = Object.assign(updates.lazy || {}, {
-						[key]: instrumented,
-					});
-				}
-			}
-		});
+
+		if (typeof lazyObject.middleware === 'function' && aggregated['lazy.middleware'].length > 0) {
+			let middleware = lazyObject.middleware;
+			updates.lazy = Object.assign(updates.lazy || {}, {
+				middleware: async (
+					...args: Parameters<NonNullable<LazyRouteObject<DataRouteObject>['middleware']>>
+				) => {
+					let result = await recurseRight(
+						aggregated['lazy.middleware'],
+						undefined,
+						() => middleware(...args),
+						getInstrumentationInnerResult,
+					);
+					return throwOrReturnResult(result);
+				},
+			});
+		}
+
+		if (typeof lazyObject.loader === 'function' && aggregated['lazy.loader'].length > 0) {
+			let loader = lazyObject.loader;
+			updates.lazy = Object.assign(updates.lazy || {}, {
+				loader: async (
+					...args: Parameters<NonNullable<LazyRouteObject<DataRouteObject>['loader']>>
+				) => {
+					let result = await recurseRight(
+						aggregated['lazy.loader'],
+						undefined,
+						() => loader(...args),
+						getInstrumentationInnerResult,
+					);
+					return throwOrReturnResult(result);
+				},
+			});
+		}
+
+		if (typeof lazyObject.action === 'function' && aggregated['lazy.action'].length > 0) {
+			let action = lazyObject.action;
+			updates.lazy = Object.assign(updates.lazy || {}, {
+				action: async (
+					...args: Parameters<NonNullable<LazyRouteObject<DataRouteObject>['action']>>
+				) => {
+					let result = await recurseRight(
+						aggregated['lazy.action'],
+						undefined,
+						() => action(...args),
+						getInstrumentationInnerResult,
+					);
+					return throwOrReturnResult(result);
+				},
+			});
+		}
 	}
 
 	// Instrument loader/action functions
-	(['loader', 'action'] as const).forEach((key) => {
-		let handler = route[key];
-		if (typeof handler === 'function' && aggregated[key].length > 0) {
-			// @ts-expect-error
-			let original = handler[UninstrumentedSymbol] ?? handler;
-			let instrumented = wrapImpl(aggregated[key], original, (...args) =>
-				getHandlerInfo(args[0] as LoaderFunctionArgs | ActionFunctionArgs),
+	if (typeof route.loader === 'function' && aggregated.loader.length > 0) {
+		let original = getUninstrumentedHandler(route.loader);
+		let instrumented = async (...args: Parameters<typeof original>) => {
+			let result = await recurseRight(
+				aggregated.loader,
+				getHandlerInfo(args[0]),
+				() => original(...args),
+				getInstrumentationInnerResult,
 			);
-			if (instrumented) {
-				if (key === 'loader' && original.hydrate === true) {
-					(instrumented as LoaderFunction).hydrate = true;
-				}
-				// @ts-expect-error
-				instrumented[UninstrumentedSymbol] = original;
-				updates[key] = instrumented;
-			}
+			return throwOrReturnResult(result);
+		};
+		if (original.hydrate === true) {
+			(instrumented as LoaderFunction).hydrate = true;
 		}
-	});
+		setUninstrumentedHandler(instrumented, original);
+		updates.loader = instrumented;
+	}
+
+	if (typeof route.action === 'function' && aggregated.action.length > 0) {
+		let original = getUninstrumentedHandler(route.action);
+		let instrumented = async (...args: Parameters<typeof original>) => {
+			let result = await recurseRight(
+				aggregated.action,
+				getHandlerInfo(args[0]),
+				() => original(...args),
+				getInstrumentationInnerResult,
+			);
+			return throwOrReturnResult(result);
+		};
+		setUninstrumentedHandler(instrumented, original);
+		updates.action = instrumented;
+	}
 
 	// Instrument middleware functions
 	if (route.middleware && route.middleware.length > 0 && aggregated.middleware.length > 0) {
 		updates.middleware = route.middleware.map((middleware) => {
-			// @ts-expect-error
-			let original = middleware[UninstrumentedSymbol] ?? middleware;
-			let instrumented = wrapImpl(aggregated.middleware, original, (...args) =>
-				getHandlerInfo(args[0] as Parameters<MiddlewareFunction>[0]),
-			);
-			if (instrumented) {
-				// @ts-expect-error
-				instrumented[UninstrumentedSymbol] = original;
-				return instrumented;
-			}
-			return middleware;
+			let original = getUninstrumentedHandler(middleware);
+			let instrumented = async (...args: Parameters<typeof original>) => {
+				let result = await recurseRight(
+					aggregated.middleware,
+					getHandlerInfo(args[0]),
+					() => original(...args),
+					getInstrumentationInnerResult,
+				);
+				return throwOrReturnResult(result);
+			};
+			setUninstrumentedHandler(instrumented, original);
+			return instrumented;
 		});
 	}
 
@@ -249,8 +372,8 @@ export function instrumentClientSideRouter(
 	fns: InstrumentRouterFunction[],
 ): Router {
 	let aggregated: {
-		navigate: InstrumentFunction<RouterNavigationInstrumentationInfo>[];
-		fetch: InstrumentFunction<RouterFetchInstrumentationInfo>[];
+		navigate: NonNullable<RouterInstrumentations['navigate']>[];
+		fetch: NonNullable<RouterInstrumentations['fetch']>[];
 	} = {
 		navigate: [],
 		fetch: [],
@@ -259,49 +382,85 @@ export function instrumentClientSideRouter(
 	fns.forEach((fn) =>
 		fn({
 			instrument(i) {
-				let keys = Object.keys(i) as Array<keyof RouterInstrumentations>;
-				for (let key of keys) {
-					if (i[key]) {
-						aggregated[key].push(i[key] as any);
-					}
+				if (i.navigate != null) {
+					aggregated.navigate.push(i.navigate);
+				}
+				if (i.fetch != null) {
+					aggregated.fetch.push(i.fetch);
 				}
 			},
 		}),
 	);
 
 	if (aggregated.navigate.length > 0) {
-		// @ts-expect-error
-		let navigate = router.navigate[UninstrumentedSymbol] ?? router.navigate;
-		let instrumentedNavigate = wrapImpl(aggregated.navigate, navigate, (...args) => {
-			let [to, opts] = args as Parameters<Router['navigate']>;
-			return {
+		let navigate = getUninstrumentedHandler(router.navigate);
+		let instrumentedNavigate = async (
+			...args: Parameters<typeof navigate>
+		): Promise<Awaited<ReturnType<typeof navigate>>> => {
+			let [to, opts] = args;
+			let meta: InstrumentationResultMeta | undefined;
+			let info: RouterNavigationInstrumentationInfo = {
 				to: typeof to === 'number' || typeof to === 'string' ? to : to ? createPath(to) : '.',
 				...getRouterInfo(router, opts ?? {}),
-			} satisfies RouterNavigationInstrumentationInfo;
-		}) as Router['navigate'];
-		if (instrumentedNavigate) {
-			// @ts-expect-error
-			instrumentedNavigate[UninstrumentedSymbol] = navigate;
-			router.navigate = instrumentedNavigate;
-		}
+			};
+			let result = await recurseRight(
+				aggregated.navigate,
+				info,
+				async () => {
+					if (typeof to === 'number') {
+						return await navigate(...args);
+					}
+					let cleanup = setInstrumentationClientResultMetaReceiver(router, (value) => {
+						meta = value;
+					});
+					try {
+						return await navigate(...args);
+					} finally {
+						cleanup();
+					}
+				},
+				(result): InstrumentationClientRouterResult => ({
+					...getInstrumentationInnerResult(result),
+					meta,
+				}),
+			);
+			return throwOrReturnResult(result);
+		};
+		setUninstrumentedHandler(instrumentedNavigate, navigate);
+		router.navigate = instrumentedNavigate as Router['navigate'];
 	}
 
 	if (aggregated.fetch.length > 0) {
-		// @ts-expect-error
-		let fetch = router.fetch[UninstrumentedSymbol] ?? router.fetch;
-		let instrumentedFetch = wrapImpl(aggregated.fetch, fetch, (...args) => {
-			let [key, , href, opts] = args as Parameters<Router['fetch']>;
-			return {
-				href: href ?? '.',
-				fetcherKey: key,
-				...getRouterInfo(router, opts ?? {}),
-			} satisfies RouterFetchInstrumentationInfo;
-		}) as Router['fetch'];
-		if (instrumentedFetch) {
-			// @ts-expect-error
-			instrumentedFetch[UninstrumentedSymbol] = fetch;
-			router.fetch = instrumentedFetch;
-		}
+		let fetch = getUninstrumentedHandler(router.fetch);
+		let instrumentedFetch = async (...args: Parameters<typeof fetch>) => {
+			let [key, _, href, opts] = args;
+			let meta: InstrumentationResultMeta | undefined;
+			let result = await recurseRight(
+				aggregated.fetch,
+				{
+					href: href ?? '.',
+					fetcherKey: key,
+					...getRouterInfo(router, opts ?? {}),
+				} satisfies RouterFetchInstrumentationInfo,
+				async () => {
+					let cleanup = setInstrumentationClientResultMetaReceiver(router, (value) => {
+						meta = value;
+					});
+					try {
+						return await fetch(...args);
+					} finally {
+						cleanup();
+					}
+				},
+				(result): InstrumentationClientRouterResult => ({
+					...getInstrumentationInnerResult(result),
+					meta,
+				}),
+			);
+			return throwOrReturnResult(result);
+		};
+		setUninstrumentedHandler(instrumentedFetch, fetch);
+		router.fetch = instrumentedFetch;
 	}
 
 	return router;
@@ -312,7 +471,10 @@ export function instrumentHandler(
 	fns: InstrumentRequestHandlerFunction[],
 ): RequestHandler {
 	let aggregated: {
-		request: InstrumentFunction<RequestHandlerInstrumentationInfo>[];
+		request: InstrumentFunction<
+			RequestHandlerInstrumentationInfo,
+			InstrumentationServerHandlerResult
+		>[];
 	} = {
 		request: [],
 	};
@@ -320,11 +482,8 @@ export function instrumentHandler(
 	fns.forEach((fn) =>
 		fn({
 			instrument(i) {
-				let keys = Object.keys(i) as Array<keyof typeof i>;
-				for (let key of keys) {
-					if (i[key]) {
-						aggregated[key].push(i[key] as any);
-					}
+				if (i.request != null) {
+					aggregated.request.push(i.request);
 				}
 			},
 		}),
@@ -333,73 +492,122 @@ export function instrumentHandler(
 	let instrumentedHandler = handler;
 
 	if (aggregated.request.length > 0) {
-		instrumentedHandler = wrapImpl(aggregated.request, handler, (...args) => {
-			let [request, context] = args as Parameters<RequestHandler>;
-			return {
-				request: getReadonlyRequest(request),
-				context: context != null ? getReadonlyContext(context) : context,
-			} satisfies RequestHandlerInstrumentationInfo;
-		}) as RequestHandler;
+		instrumentedHandler = async (...args) => {
+			let [request, context] = args;
+			let instrumentationContext = context ?? new RouterContextProvider();
+			let result = await recurseRight(
+				aggregated.request,
+				{
+					request: getReadonlyRequest(request),
+					context: getReadonlyContext(instrumentationContext),
+				} satisfies RequestHandlerInstrumentationInfo,
+				() => handler(request, instrumentationContext),
+				(result, info) => {
+					let meta: InstrumentationResultMeta | undefined;
+					try {
+						meta = info.context?.get(instrumentationResultMetaContext);
+					} catch {
+						// Not all instrumentation contexts have request/route metadata.
+					}
+					invariant(
+						result.value instanceof Response,
+						'Expected a Response from the request handler',
+					);
+					return {
+						...getInstrumentationInnerResult(result),
+						statusCode: result.value.status,
+						meta,
+					};
+				},
+			);
+			return throwOrReturnResult(result);
+		};
 	}
 
 	return instrumentedHandler;
 }
 
-function wrapImpl<T extends InstrumentationInfo>(
-	impls: InstrumentFunction<T>[],
-	handler: (...args: any[]) => MaybePromise<any>,
-	getInfo: (...args: unknown[]) => T,
+function getUninstrumentedHandler<T extends InstrumentableFunction>(handler: T): T {
+	return (handler as InstrumentedFunction<T>)[UninstrumentedSymbol] ?? handler;
+}
+
+function setUninstrumentedHandler<TArgs extends unknown[], TResult>(
+	handler: (...args: TArgs) => MaybePromise<TResult>,
+	uninstrumentedHandler: (...args: TArgs) => MaybePromise<TResult>,
 ) {
-	if (impls.length === 0) {
-		return null;
-	}
-	return async (...args: unknown[]) => {
-		let result = await recurseRight(
-			impls,
-			getInfo(...args),
-			() => handler(...args),
-			impls.length - 1,
-		);
-		if (result.type === 'error') {
-			throw result.value;
+	(handler as InstrumentedFunction<(...args: TArgs) => MaybePromise<TResult>>)[
+		UninstrumentedSymbol
+	] = uninstrumentedHandler;
+}
+
+export function setInstrumentationClientResultMetaReceiver(
+	router: Router,
+	receiver: InstrumentationMetaReceiver,
+): () => void {
+	instrumentationClientResultMetaReceivers.set(router, receiver);
+	return () => {
+		if (instrumentationClientResultMetaReceivers.get(router) === receiver) {
+			instrumentationClientResultMetaReceivers.delete(router);
 		}
-		return result.value;
 	};
 }
 
-type RecurseResult = { type: 'success' | 'error'; value: unknown };
+export function consumeInstrumentationClientResultMetaReceiver(
+	router: Router,
+): InstrumentationMetaReceiver | undefined {
+	let receiver = instrumentationClientResultMetaReceivers.get(router);
+	instrumentationClientResultMetaReceivers.delete(router);
+	return receiver;
+}
+
+type RecurseResult<TResult> =
+	| { type: 'success'; value: TResult }
+	| { type: 'error'; value: unknown };
 
-async function recurseRight<T extends InstrumentationInfo>(
-	impls: InstrumentFunction<T>[],
-	info: T,
-	handler: () => MaybePromise<void>,
-	index: number,
-): Promise<RecurseResult> {
+function throwOrReturnResult<TResult>(result: RecurseResult<TResult>): TResult {
+	if (result.type === 'error') {
+		throw result.value;
+	}
+	return result.value;
+}
+
+async function recurseRight<
+	TResult,
+	TInfo extends InstrumentationInfo,
+	TInnerResult extends InstrumentationHandlerResult,
+>(
+	impls: InstrumentFunction<TInfo, TInnerResult>[],
+	info: TInfo,
+	handler: () => MaybePromise<TResult>,
+	getInnerResult: (result: RecurseResult<TResult>, info: TInfo) => TInnerResult,
+	state: RecurseState<TResult, TInnerResult> = {
+		result: null,
+		innerResult: null,
+	},
+	index = impls.length - 1,
+): Promise<RecurseResult<TResult>> {
 	let impl = impls[index];
-	let result: RecurseResult | undefined;
 	if (!impl) {
 		try {
 			let value = await handler();
-			result = { type: 'success', value };
+			state.result = { type: 'success', value };
 		} catch (e) {
-			result = { type: 'error', value: e };
+			state.result = { type: 'error', value: e };
 		}
+		state.innerResult = getInnerResult(state.result, info);
 	} else {
 		// If they forget to call the handler, or if they throw before calling the
 		// handler, we need to ensure the handlers still gets called
-		let handlerPromise: ReturnType<typeof recurseRight> | undefined = undefined;
-		let callHandler = async (): Promise<InstrumentationHandlerResult> => {
+		let handlerPromise: Promise<RecurseResult<TResult>> | undefined = undefined;
+		let callHandler = async (): Promise<TInnerResult> => {
 			if (handlerPromise) {
 				console.error('You cannot call instrumented handlers more than once');
 			} else {
-				handlerPromise = recurseRight(impls, info, handler, index - 1);
+				handlerPromise = recurseRight(impls, info, handler, getInnerResult, state, index - 1);
 			}
-			result = await handlerPromise;
-			invariant(result, 'Expected a result');
-			if (result.type === 'error' && result.value instanceof Error) {
-				return { status: 'error', error: result.value };
-			}
-			return { status: 'success', error: undefined };
+			await handlerPromise;
+			invariant(state.innerResult, 'Expected an inner result');
+			return state.innerResult;
 		};
 
 		try {
@@ -416,24 +624,40 @@ async function recurseRight<T extends InstrumentationInfo>(
 		await handlerPromise;
 	}
 
-	if (result) {
-		return result;
+	if (state.result) {
+		return state.result;
 	}
 
-	return {
+	state.result = {
 		type: 'error',
 		value: new Error('No result assigned in instrumentation chain.'),
 	};
+	state.innerResult = getInnerResult(state.result, info);
+	return state.result;
+}
+
+type RecurseState<TResult, TInnerResult> = {
+	result: RecurseResult<TResult> | null;
+	innerResult: TInnerResult | null;
+};
+
+function getInstrumentationInnerResult<TResult>(
+	result: RecurseResult<TResult>,
+): InstrumentationHandlerResult {
+	if (result.type === 'error' && result.value instanceof Error) {
+		return { status: 'error', error: result.value };
+	}
+	return { status: 'success', error: undefined };
 }
 
 function getHandlerInfo(
 	args: LoaderFunctionArgs | ActionFunctionArgs | Parameters<MiddlewareFunction>[0],
 ): RouteHandlerInstrumentationInfo {
-	let { request, context, params, pattern } = args;
+	let { request, context, params } = args;
 	return {
+		...args,
 		request: getReadonlyRequest(request),
 		params: { ...params },
-		pattern,
 		context: getReadonlyContext(context),
 	};
 }
@@ -450,6 +674,7 @@ function getRouterInfo(
 		...('body' in opts ? { body: opts.body } : {}),
 	};
 }
+
 // Return a shallow readonly "clone" of the Request with the info they may
 // want to read from during instrumentation
 function getReadonlyRequest(request: Request): {
@@ -467,30 +692,9 @@ function getReadonlyRequest(request: Request): {
 }
 
 function getReadonlyContext(
-	context: MiddlewareEnabled extends true ? RouterContextProvider : AppLoadContext,
-): MiddlewareEnabled extends true ? Pick<RouterContextProvider, 'get'> : Readonly<AppLoadContext> {
-	if (isPlainObject(context)) {
-		let frozen = { ...context };
-		Object.freeze(frozen);
-		return frozen;
-	} else {
-		return {
-			get: <T>(ctx: RouterContext<T>) => (context as unknown as RouterContextProvider).get(ctx),
-		};
-	}
-}
-
-// From turbo-stream-v2/flatten.ts
-const objectProtoNames = Object.getOwnPropertyNames(Object.prototype).sort().join('\0');
-
-function isPlainObject(thing: unknown): thing is Record<string | number | symbol, unknown> {
-	if (thing === null || typeof thing !== 'object') {
-		return false;
-	}
-	const proto = Object.getPrototypeOf(thing);
-	return (
-		proto === Object.prototype ||
-		proto === null ||
-		Object.getOwnPropertyNames(proto).sort().join('\0') === objectProtoNames
-	);
+	context: Readonly<RouterContextProvider>,
+): Pick<RouterContextProvider, 'get'> {
+	return {
+		get: <T>(ctx: RouterContext<T>) => context.get(ctx),
+	};
 }