@rangojs/router 0.0.0-experimental.259 → 0.0.0-experimental.26

package/src/router/segment-resolution/revalidation.ts

@@ -7,23 +7,14 @@
  */
 
 import type { ReactNode } from "react";
-import { DataNotFoundError, invariant } from "../../errors";
-import {
-  createErrorInfo,
-  createErrorSegment,
-  createNotFoundInfo,
-  createNotFoundSegment,
-} from "../error-handling.js";
+import { invariant } from "../../errors";
 import { revalidate } from "../loader-resolution.js";
 import { evaluateRevalidation } from "../revalidation.js";
-import { getRequestContext } from "../../server/request-context.js";
-import { DefaultErrorFallback } from "../../default-error-boundary.js";
 import type { EntryData } from "../../server/context";
 import type {
   HandlerContext,
   InternalHandlerContext,
   ResolvedSegment,
-  ErrorInfo,
   ShouldRevalidateFn,
 } from "../../types";
 import type {
@@ -31,10 +22,98 @@ import type {
   SegmentRevalidationResult,
   ActionContext,
 } from "../types.js";
-import { debugLog } from "../logging.js";
-import { tryStaticLookup } from "./static-store.js";
-import { handleHandlerResult } from "./fresh.js";
+import {
+  debugLog,
+  pushRevalidationTraceEntry,
+  isTraceActive,
+} from "../logging.js";
 import { resolveLoaderData } from "./loader-cache.js";
+import {
+  handleHandlerResult,
+  tryStaticHandler,
+  tryStaticSlot,
+  resolveLayoutComponent,
+  resolveWithErrorBoundary,
+} from "./helpers.js";
+import { getRouterContext } from "../router-context.js";
+import { resolveSink, safeEmit } from "../telemetry.js";
+import { track } from "../../server/context.js";
+
+// ---------------------------------------------------------------------------
+// Telemetry helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Attach a fire-and-forget rejection observer to a streamed handler promise.
+ * Silently no-ops when called outside RouterContext (e.g. in unit tests).
+ */
+function observeStreamedHandler(
+  promise: Promise<ReactNode>,
+  segmentId: string,
+  segmentType: string,
+  pathname?: string,
+  routeKey?: string,
+  params?: Record<string, string>,
+): void {
+  let routerCtx;
+  try {
+    routerCtx = getRouterContext();
+  } catch {
+    return;
+  }
+  if (!routerCtx?.telemetry) return;
+  const sink = resolveSink(routerCtx.telemetry);
+  const reqId = routerCtx.requestId;
+  promise.catch((err: unknown) => {
+    const errorObj = err instanceof Error ? err : new Error(String(err));
+    safeEmit(sink, {
+      type: "handler.error",
+      timestamp: performance.now(),
+      requestId: reqId,
+      segmentId,
+      segmentType,
+      error: errorObj,
+      handledByBoundary: true,
+      pathname,
+      routeKey,
+      params,
+    });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Revalidation telemetry helper
+// ---------------------------------------------------------------------------
+
+/**
+ * Emit revalidation.decision telemetry for a segment if a sink is configured.
+ * Called after evaluateRevalidation returns to capture the decision.
+ * Silently no-ops when called outside RouterContext (e.g. in unit tests).
+ */
+function emitRevalidationDecision(
+  segmentId: string,
+  pathname: string,
+  routeKey: string,
+  shouldRevalidate: boolean,
+): void {
+  let routerCtx;
+  try {
+    routerCtx = getRouterContext();
+  } catch {
+    return;
+  }
+  if (routerCtx?.telemetry) {
+    safeEmit(resolveSink(routerCtx.telemetry), {
+      type: "revalidation.decision",
+      timestamp: performance.now(),
+      requestId: routerCtx.requestId,
+      segmentId,
+      pathname,
+      routeKey,
+      shouldRevalidate,
+    });
+  }
+}
 
 // ---------------------------------------------------------------------------
 // Revalidation path (partial match)
@@ -85,7 +164,20 @@ export async function resolveLoadersWithRevalidation<TEnv>(
       }) => {
         const shouldRun = await revalidate(
           async () => {
-            if (!clientSegmentIds.has(segmentId)) return true;
+            if (!clientSegmentIds.has(segmentId)) {
+              if (isTraceActive()) {
+                pushRevalidationTraceEntry({
+                  segmentId,
+                  segmentType: "loader",
+                  belongsToRoute,
+                  source: "loader",
+                  defaultShouldRevalidate: true,
+                  finalShouldRevalidate: true,
+                  reason: "new-segment",
+                });
+              }
+              return true;
+            }
 
             const dummySegment: ResolvedSegment = {
               id: segmentId,
@@ -113,11 +205,13 @@ export async function resolveLoadersWithRevalidation<TEnv>(
               context: ctx,
               actionContext,
               stale,
+              traceSource: "loader",
             });
           },
           async () => true,
           () => false,
         );
+        emitRevalidationDecision(segmentId, ctx.pathname, routeKey, shouldRun);
         return { shouldRun, loaderEntry, loader, segmentId, index };
       },
     ),
@@ -160,6 +254,7 @@ export async function resolveLoadersOnlyWithRevalidation<TEnv>(
   routeKey: string,
   deps: SegmentResolutionDeps<TEnv>,
   actionContext?: ActionContext,
+  stale?: boolean,
 ): Promise<{ segments: ResolvedSegment[]; matchedIds: string[] }> {
   const allLoaderSegments: ResolvedSegment[] = [];
   const allMatchedIds: string[] = [];
@@ -178,6 +273,8 @@ export async function resolveLoadersOnlyWithRevalidation<TEnv>(
       routeKey,
       deps,
       actionContext,
+      undefined, // shortCodeOverride
+      stale,
     );
     allLoaderSegments.push(...segments);
     allMatchedIds.push(...matchedIds);
@@ -283,9 +380,35 @@ export async function resolveParallelSegmentsWithRevalidation<TEnv>(
       }
 
       const shouldResolve = await (async () => {
-        if (isFullRefetch) return true;
-        if (!clientSegmentIds.has(parallelId))
-          return belongsToRoute || isNewParent;
+        if (isFullRefetch) {
+          if (isTraceActive()) {
+            pushRevalidationTraceEntry({
+              segmentId: parallelId,
+              segmentType: "parallel",
+              belongsToRoute,
+              source: "parallel",
+              defaultShouldRevalidate: true,
+              finalShouldRevalidate: true,
+              reason: "full-refetch",
+            });
+          }
+          return true;
+        }
+        if (!clientSegmentIds.has(parallelId)) {
+          const result = belongsToRoute || isNewParent;
+          if (isTraceActive()) {
+            pushRevalidationTraceEntry({
+              segmentId: parallelId,
+              segmentType: "parallel",
+              belongsToRoute,
+              source: "parallel",
+              defaultShouldRevalidate: result,
+              finalShouldRevalidate: result,
+              reason: result ? "new-segment" : "skip-parent-chain",
+            });
+          }
+          return result;
+        }
 
         const dummySegment: ResolvedSegment = {
           id: parallelId,
@@ -317,14 +440,19 @@ export async function resolveParallelSegmentsWithRevalidation<TEnv>(
           context,
           actionContext,
           stale,
+          traceSource: "parallel",
         });
       })();
+      emitRevalidationDecision(
+        parallelId,
+        context.pathname,
+        routeKey,
+        shouldResolve,
+      );
 
       let component: ReactNode | undefined;
-      // Static handler interception for individual parallel slots
-      const slotStaticId = (parallelEntry as any).staticHandlerIds?.[slot];
-      if (slotStaticId && shouldResolve) {
-        component = await tryStaticLookup(slotStaticId, parallelId);
+      if (shouldResolve) {
+        component = await tryStaticSlot(parallelEntry, slot, parallelId);
       }
       if (component === undefined) {
         const hasLoadingFallback =
@@ -333,9 +461,25 @@ export async function resolveParallelSegmentsWithRevalidation<TEnv>(
         if (!shouldResolve) {
           component = null;
         } else if (hasLoadingFallback) {
-          component = (
-            typeof handler === "function" ? handler(context) : handler
-          ) as ReactNode;
+          const result =
+            typeof handler === "function" ? handler(context) : handler;
+          if (result instanceof Promise) {
+            const tracked = deps.trackHandler(result, {
+              segmentId: parallelId,
+              segmentType: "parallel",
+            });
+            observeStreamedHandler(
+              tracked,
+              parallelId,
+              "parallel",
+              context.pathname,
+              routeKey,
+              params,
+            );
+            component = tracked as ReactNode;
+          } else {
+            component = result as ReactNode;
+          }
         } else {
           component =
             typeof handler === "function" ? await handler(context) : handler;
@@ -413,7 +557,24 @@ export async function resolveEntryHandlerWithRevalidation<TEnv>(
         clientHasSegment: hasSegment,
         belongsToRoute,
       });
-      if (!hasSegment) return true;
+      if (!hasSegment) {
+        if (isTraceActive()) {
+          const segType =
+            entry.type === "cache"
+              ? "layout"
+              : (entry.type as "layout" | "route");
+          pushRevalidationTraceEntry({
+            segmentId: entry.shortCode,
+            segmentType: segType,
+            belongsToRoute,
+            source: "segment-resolution",
+            defaultShouldRevalidate: true,
+            finalShouldRevalidate: true,
+            reason: "new-segment",
+          });
+        }
+        return true;
+      }
 
       const dummySegment: ResolvedSegment = {
         id: entry.shortCode,
@@ -448,6 +609,12 @@ export async function resolveEntryHandlerWithRevalidation<TEnv>(
         actionContext,
         stale,
       });
+      emitRevalidationDecision(
+        entry.shortCode,
+        context.pathname,
+        routeKey,
+        shouldRevalidate,
+      );
       debugLog("segment.revalidate", "entry revalidation decision", {
         segmentId: entry.shortCode,
         shouldRevalidate,
@@ -455,40 +622,55 @@ export async function resolveEntryHandlerWithRevalidation<TEnv>(
       return shouldRevalidate;
     },
     async () => {
+      const doneHandler = track(`handler:${entry.id}`, 2);
       (context as InternalHandlerContext<any, TEnv>)._currentSegmentId =
         entry.shortCode;
-      // Static handler interception: use pre-rendered component from build-time store
-      const entryAny = entry as any;
-      if (entryAny.isStaticPrerender && entryAny.staticHandlerId) {
-        const staticComponent = await tryStaticLookup(
-          entryAny.staticHandlerId,
-          entry.shortCode,
-        );
-        if (staticComponent !== undefined) return staticComponent;
-      }
       if (entry.type === "layout" || entry.type === "cache") {
-        return typeof entry.handler === "function"
-          ? handleHandlerResult(await entry.handler(context))
-          : entry.handler;
+        const layoutComponent = await resolveLayoutComponent(entry, context);
+        doneHandler();
+        return layoutComponent;
+      }
+      const staticComponent = await tryStaticHandler(entry, entry.shortCode);
+      if (staticComponent !== undefined) {
+        doneHandler();
+        return staticComponent;
       }
       const routeEntry = entry as Extract<EntryData, { type: "route" }>;
       if (!routeEntry.loading) {
-        return handleHandlerResult(await routeEntry.handler(context));
+        const result = handleHandlerResult(await routeEntry.handler(context));
+        doneHandler();
+        return result;
       }
       if (!actionContext) {
         const result = handleHandlerResult(routeEntry.handler(context));
-        return {
-          content:
-            result instanceof Promise ? deps.trackHandler(result) : result,
-        };
+        if (result instanceof Promise) {
+          result.finally(doneHandler).catch(() => {});
+          const tracked = deps.trackHandler(result, {
+            segmentId: entry.shortCode,
+            segmentType: entry.type,
+          });
+          observeStreamedHandler(
+            tracked,
+            entry.shortCode,
+            entry.type,
+            context.pathname,
+            routeKey,
+            params,
+          );
+          return { content: tracked };
+        }
+        doneHandler();
+        return { content: result };
       }
       debugLog("segment.action", "resolving action route with awaited value", {
         entryId: entry.id,
       });
+      const actionResult = handleHandlerResult(
+        await routeEntry.handler(context),
+      );
+      doneHandler();
       return {
-        content: Promise.resolve(
-          handleHandlerResult(await routeEntry.handler(context)),
-        ),
+        content: Promise.resolve(actionResult),
       };
     },
     () => null,
@@ -605,31 +787,32 @@ export async function resolveSegmentWithRevalidation<TEnv>(
     }
   }
 
-  const parallelResult = await resolveParallelSegmentsWithRevalidation(
-    entry,
-    params,
-    context,
-    belongsToRoute,
-    clientSegmentIds,
-    prevParams,
-    request,
-    prevUrl,
-    nextUrl,
-    routeKey,
-    deps,
-    actionContext,
-    stale,
-  );
-  segments.push(...parallelResult.segments);
-  matchedIds.push(...parallelResult.matchedIds);
-
-  // Push handler BEFORE orphan layouts for layout/cache entries (matching SSR
-  // order in resolveSegment). Route handler was already executed and is pushed
-  // after children for tree composition.
   if (routeHandlerResult) {
+    // Route entry: handler already executed above; resolve parallels
+    // (handler data visible) then push handler segment last for tree order.
+    const parallelResult = await resolveParallelSegmentsWithRevalidation(
+      entry,
+      params,
+      context,
+      belongsToRoute,
+      clientSegmentIds,
+      prevParams,
+      request,
+      prevUrl,
+      nextUrl,
+      routeKey,
+      deps,
+      actionContext,
+      stale,
+    );
+    segments.push(...parallelResult.segments);
+    matchedIds.push(...parallelResult.matchedIds);
+
     segments.push(routeHandlerResult.segment);
     matchedIds.push(routeHandlerResult.matchedId);
   } else {
+    // Layout/cache entry: handler-first — resolve handler before parallels
+    // so ctx.set() values are visible to parallel children.
     const handlerResult = await resolveEntryHandlerWithRevalidation(
       entry,
       params,
@@ -647,9 +830,25 @@ export async function resolveSegmentWithRevalidation<TEnv>(
     );
     segments.push(handlerResult.segment);
     matchedIds.push(handlerResult.matchedId);
-  }
 
-  if (entry.type === "layout" || entry.type === "cache") {
+    const parallelResult = await resolveParallelSegmentsWithRevalidation(
+      entry,
+      params,
+      context,
+      belongsToRoute,
+      clientSegmentIds,
+      prevParams,
+      request,
+      prevUrl,
+      nextUrl,
+      routeKey,
+      deps,
+      actionContext,
+      stale,
+    );
+    segments.push(...parallelResult.segments);
+    matchedIds.push(...parallelResult.matchedIds);
+
     for (const orphan of entry.layout) {
       const orphanResult = await resolveOrphanLayoutWithRevalidation(
         orphan,
@@ -720,6 +919,82 @@ export async function resolveOrphanLayoutWithRevalidation<TEnv>(
   segments.push(...loaderResult.segments);
   matchedIds.push(...loaderResult.matchedIds);
 
+  // Handler-first: resolve orphan layout handler before its parallels
+  // so ctx.set() values are visible to parallel children.
+  matchedIds.push(orphan.shortCode);
+
+  const component = await revalidate(
+    async () => {
+      if (!clientSegmentIds.has(orphan.shortCode)) {
+        if (isTraceActive()) {
+          pushRevalidationTraceEntry({
+            segmentId: orphan.shortCode,
+            segmentType: "layout",
+            belongsToRoute,
+            source: "orphan-layout",
+            defaultShouldRevalidate: true,
+            finalShouldRevalidate: true,
+            reason: "new-segment",
+          });
+        }
+        return true;
+      }
+
+      const dummySegment: ResolvedSegment = {
+        id: orphan.shortCode,
+        namespace: orphan.id,
+        type: "layout",
+        index: 0,
+        component: null as any,
+        params,
+        belongsToRoute,
+        layoutName: orphan.id,
+        ...(orphan.mountPath ? { mountPath: orphan.mountPath } : {}),
+      };
+
+      const shouldRevalidate = await evaluateRevalidation({
+        segment: dummySegment,
+        prevParams,
+        getPrevSegment: null,
+        request,
+        prevUrl,
+        nextUrl,
+        revalidations: orphan.revalidate.map((fn, i) => ({
+          name: `revalidate${i}`,
+          fn,
+        })),
+        routeKey,
+        context,
+        actionContext,
+        stale,
+        traceSource: "orphan-layout",
+      });
+      emitRevalidationDecision(
+        orphan.shortCode,
+        context.pathname,
+        routeKey,
+        shouldRevalidate,
+      );
+      return shouldRevalidate;
+    },
+    async () => resolveLayoutComponent(orphan, context),
+    () => null,
+  );
+
+  segments.push({
+    id: orphan.shortCode,
+    namespace: orphan.id,
+    type: "layout",
+    index: 0,
+    component,
+    params,
+    belongsToRoute,
+    layoutName: orphan.id,
+    loading: orphan.loading === false ? null : orphan.loading,
+    transition: orphan.transition,
+    ...(orphan.mountPath ? { mountPath: orphan.mountPath } : {}),
+  });
+
   for (const parallelEntry of orphan.parallel) {
     invariant(
       parallelEntry.type === "parallel",
@@ -758,7 +1033,20 @@ export async function resolveOrphanLayoutWithRevalidation<TEnv>(
       matchedIds.push(parallelId);
 
       const shouldResolve = await (async () => {
-        if (!clientSegmentIds.has(parallelId)) return true;
+        if (!clientSegmentIds.has(parallelId)) {
+          if (isTraceActive()) {
+            pushRevalidationTraceEntry({
+              segmentId: parallelId,
+              segmentType: "parallel",
+              belongsToRoute,
+              source: "parallel",
+              defaultShouldRevalidate: true,
+              finalShouldRevalidate: true,
+              reason: "new-segment",
+            });
+          }
+          return true;
+        }
 
         const dummySegment: ResolvedSegment = {
           id: parallelId,
@@ -790,14 +1078,19 @@ export async function resolveOrphanLayoutWithRevalidation<TEnv>(
           context,
           actionContext,
           stale,
+          traceSource: "parallel",
         });
       })();
+      emitRevalidationDecision(
+        parallelId,
+        context.pathname,
+        routeKey,
+        shouldResolve,
+      );
 
       let component: ReactNode | undefined;
-      // Static handler interception for individual parallel slots
-      const slotStaticId = (parallelEntry as any).staticHandlerIds?.[slot];
-      if (slotStaticId && shouldResolve) {
-        component = await tryStaticLookup(slotStaticId, parallelId);
+      if (shouldResolve) {
+        component = await tryStaticSlot(parallelEntry, slot, parallelId);
       }
       if (component === undefined) {
         const hasLoadingFallback =
@@ -806,9 +1099,25 @@ export async function resolveOrphanLayoutWithRevalidation<TEnv>(
         if (!shouldResolve) {
           component = null;
         } else if (hasLoadingFallback) {
-          component = (
-            typeof handler === "function" ? handler(context) : handler
-          ) as ReactNode;
+          const result =
+            typeof handler === "function" ? handler(context) : handler;
+          if (result instanceof Promise) {
+            const tracked = deps.trackHandler(result, {
+              segmentId: parallelId,
+              segmentType: "parallel",
+            });
+            observeStreamedHandler(
+              tracked,
+              parallelId,
+              "parallel",
+              context.pathname,
+              routeKey,
+              params,
+            );
+            component = tracked as ReactNode;
+          } else {
+            component = result as ReactNode;
+          }
         } else {
           component =
             typeof handler === "function" ? await handler(context) : handler;
@@ -834,204 +1143,9 @@ export async function resolveOrphanLayoutWithRevalidation<TEnv>(
     }
   }
 
-  matchedIds.push(orphan.shortCode);
-
-  const component = await revalidate(
-    async () => {
-      if (!clientSegmentIds.has(orphan.shortCode)) return true;
-
-      const dummySegment: ResolvedSegment = {
-        id: orphan.shortCode,
-        namespace: orphan.id,
-        type: "layout",
-        index: 0,
-        component: null as any,
-        params,
-        belongsToRoute,
-        layoutName: orphan.id,
-        ...(orphan.mountPath ? { mountPath: orphan.mountPath } : {}),
-      };
-
-      return await evaluateRevalidation({
-        segment: dummySegment,
-        prevParams,
-        getPrevSegment: null,
-        request,
-        prevUrl,
-        nextUrl,
-        revalidations: orphan.revalidate.map((fn, i) => ({
-          name: `revalidate${i}`,
-          fn,
-        })),
-        routeKey,
-        context,
-        actionContext,
-        stale,
-      });
-    },
-    async () => {
-      // Static handler interception for orphan layouts
-      const orphanAny = orphan as any;
-      if (orphanAny.isStaticPrerender && orphanAny.staticHandlerId) {
-        const staticComponent = await tryStaticLookup(
-          orphanAny.staticHandlerId,
-          orphan.shortCode,
-        );
-        if (staticComponent !== undefined) return staticComponent;
-      }
-      return typeof orphan.handler === "function"
-        ? handleHandlerResult(await orphan.handler(context))
-        : orphan.handler;
-    },
-    () => null,
-  );
-
-  segments.push({
-    id: orphan.shortCode,
-    namespace: orphan.id,
-    type: "layout",
-    index: 0,
-    component,
-    params,
-    belongsToRoute,
-    layoutName: orphan.id,
-    loading: orphan.loading === false ? null : orphan.loading,
-    transition: orphan.transition,
-    ...(orphan.mountPath ? { mountPath: orphan.mountPath } : {}),
-  });
-
   return { segments, matchedIds };
 }
 
-/**
- * Wrapper for segment resolution with revalidation that adds error boundary handling.
- */
-export async function resolveWithRevalidationErrorHandling<TEnv>(
-  entry: EntryData,
-  params: Record<string, string>,
-  resolveFn: () => Promise<SegmentRevalidationResult>,
-  deps: SegmentResolutionDeps<TEnv>,
-  pathname?: string,
-  errorContext?: {
-    request: Request;
-    url: URL;
-    routeKey?: string;
-    env?: TEnv;
-    isPartial?: boolean;
-    requestStartTime?: number;
-  },
-): Promise<SegmentRevalidationResult> {
-  try {
-    return await resolveFn();
-  } catch (error) {
-    if (error instanceof Response) {
-      throw error;
-    }
-
-    if (error instanceof DataNotFoundError) {
-      const notFoundFallback = deps.findNearestNotFoundBoundary(entry);
-
-      if (notFoundFallback) {
-        const notFoundInfo = createNotFoundInfo(
-          error,
-          entry.shortCode,
-          entry.type,
-          pathname,
-        );
-
-        if (errorContext) {
-          deps.callOnError(error, "handler", {
-            request: errorContext.request,
-            url: errorContext.url,
-            routeKey: errorContext.routeKey,
-            params,
-            segmentId: entry.shortCode,
-            segmentType: entry.type as any,
-            env: errorContext.env,
-            isPartial: errorContext.isPartial,
-            handledByBoundary: true,
-            metadata: { notFound: true, message: notFoundInfo.message },
-            requestStartTime: errorContext.requestStartTime,
-          });
-        }
-
-        debugLog("segment", "notFound boundary handled error", {
-          segmentId: entry.shortCode,
-          message: notFoundInfo.message,
-        });
-
-        const reqCtx = getRequestContext();
-        if (reqCtx) {
-          reqCtx.res = new Response(null, {
-            status: 404,
-            headers: reqCtx.res.headers,
-          });
-        }
-
-        const notFoundSegment = createNotFoundSegment(
-          notFoundInfo,
-          notFoundFallback,
-          entry,
-          params,
-        );
-
-        return {
-          segments: [notFoundSegment],
-          matchedIds: [notFoundSegment.id],
-        };
-      }
-    }
-
-    const fallback = deps.findNearestErrorBoundary(entry);
-    const segmentType: ErrorInfo["segmentType"] = entry.type;
-    const errorInfo = createErrorInfo(error, entry.shortCode, segmentType);
-    const effectiveFallback = fallback ?? DefaultErrorFallback;
-
-    if (errorContext) {
-      deps.callOnError(error, "handler", {
-        request: errorContext.request,
-        url: errorContext.url,
-        routeKey: errorContext.routeKey,
-        params,
-        segmentId: entry.shortCode,
-        segmentType: entry.type as any,
-        env: errorContext.env,
-        isPartial: errorContext.isPartial,
-        handledByBoundary: !!fallback,
-        requestStartTime: errorContext.requestStartTime,
-      });
-    }
-
-    debugLog("segment", "error boundary handled error", {
-      segmentId: entry.shortCode,
-      boundary: fallback ? "custom" : "default",
-      message: errorInfo.message,
-    });
-
-    {
-      const reqCtx = getRequestContext();
-      if (reqCtx) {
-        reqCtx.res = new Response(null, {
-          status: 500,
-          headers: reqCtx.res.headers,
-        });
-      }
-    }
-
-    const errorSegment = createErrorSegment(
-      errorInfo,
-      effectiveFallback,
-      entry,
-      params,
-    );
-
-    return {
-      segments: [errorSegment],
-      matchedIds: [errorSegment.id],
-    };
-  }
-}
-
 /**
  * Resolve all segments for a route with revalidation logic (for matchPartial).
  */
@@ -1057,6 +1171,8 @@ export async function resolveAllSegmentsWithRevalidation<TEnv>(
   const seenSegIds = new Set<string>();
   const seenMatchIds = new Set<string>();
 
+  const telemetry = getRouterContext()?.telemetry;
+
   for (const entry of entries) {
     if (entry.type === "route" && interceptResult) {
       debugLog(
@@ -1075,7 +1191,8 @@ export async function resolveAllSegmentsWithRevalidation<TEnv>(
     }
 
     const nonParallelEntry = entry as Exclude<EntryData, { type: "parallel" }>;
-    const resolved = await resolveWithRevalidationErrorHandling(
+    const doneEntry = track(`segment:${entry.id}`, 1);
+    const resolved = await resolveWithErrorBoundary(
       nonParallelEntry,
       params,
       () =>
@@ -1094,9 +1211,14 @@ export async function resolveAllSegmentsWithRevalidation<TEnv>(
           actionContext,
           false,
         ),
+      (seg) => ({ segments: [seg], matchedIds: [seg.id] }),
       deps,
+      telemetry
+        ? { request, url: context.url, routeKey, isPartial: true, telemetry }
+        : undefined,
       pathname,
     );
+    doneEntry();
 
     // Deduplicate segments and matchedIds by ID, matching resolveAllSegments.
     // include() scopes can produce entries that resolve the same shared